-
Notifications
You must be signed in to change notification settings - Fork 6
/
glide.go
171 lines (149 loc) · 4.8 KB
/
glide.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
package validation
import (
"fmt"
"io"
"io/ioutil"
"strings"
"gopkg.in/yaml.v2"
)
// GlideYML unmarshals the parts of a glide.yml file we care about.
type GlideYML struct {
Imports []Import `yaml:"import"`
}
// Import contained within a glide.yml.
type Import struct {
Package string `yaml:"package"`
Version string `yaml:"version"`
}
// GlideLock unmarshals the parts of a glide.lock file we care about.
type GlideLock struct {
Imports []LockedVersion `yaml:"imports"`
}
// LockedVersion contained within a glide.lock.
type LockedVersion struct {
Name string `yaml:"name"`
Version string `yaml:"version"`
}
// requirements describes dependencies we require wag users to use in their apps.
var requirements = []Import{
{
Package: "github.com/lightstep/lightstep-tracer-go",
Version: "0d48cd619841b1e1a3cdd20cd6ac97774c0002ce",
},
{
Package: "github.com/opentracing/opentracing-go",
Version: "^1.0.0",
},
{
Package: "github.com/opentracing/basictracer-go",
Version: "1b32af207119a14b1b231d451df3ed04a72efebf",
},
{
Package: "github.com/gorilla/mux",
Version: "757bef944d0f21880861c2dd9c871ca543023cba",
},
{
Package: "github.com/golang/mock",
Version: "13f360950a79f5864a972c786a10a50e44b69541",
},
}
// ValidateGlideYAML looks at a user's glide.yml and makes sure certain dependencies
// that wag requires are present and locked to the correct version.
func ValidateGlideYAML(glideYMLFile io.Reader) error {
var glideYML GlideYML
bs, err := ioutil.ReadAll(glideYMLFile)
if err != nil {
return fmt.Errorf("error reading glide.yaml: %s", err)
}
if err = yaml.Unmarshal(bs, &glideYML); err != nil {
return fmt.Errorf("error unmarshalling yaml: %s", err)
}
pdes := &ListOfPeerDependencyError{}
for _, req := range requirements {
if err := validateImports(glideYML.Imports, req); err != nil {
pdes.Errors = append(pdes.Errors, err)
}
}
if len(pdes.Errors) > 0 {
return pdes
}
return nil
}
// ValidateGlideLock looks at a user's glide.yml and makes sure certain dependencies
// that wag requires are present and locked to the correct version.
func ValidateGlideLock(glideLockFile io.Reader) error {
var glideLock GlideLock
bs, err := ioutil.ReadAll(glideLockFile)
if err != nil {
return fmt.Errorf("error reading glide.lock: %s", err)
}
if err = yaml.Unmarshal(bs, &glideLock); err != nil {
return fmt.Errorf("error unmarshalling yaml in glide.lock: %s", err)
}
pdes := &ListOfPeerDependencyError{}
for _, req := range requirements {
if err := validateLockedVersion(glideLock.Imports, req); err != nil {
pdes.Errors = append(pdes.Errors, err)
}
}
if len(pdes.Errors) > 0 {
return pdes
}
return nil
}
// PeerDependencyError occurs when glide.yml and/or glide.lock dont have the
// required dependency versions for wag
type PeerDependencyError struct {
Package string
Version string
File string
}
func (e *PeerDependencyError) Error() string {
return fmt.Sprintf("Error: wag peer dependency not met. \n"+
"Version %s of %s must be set in glide.yaml and glide.lock.\n"+
"Please ensure your glide.yaml file includes\n\n"+
"```\n"+
"- package: %s\n"+
" version: %s\n"+
"```\n\n"+
"then run `glide up`.", e.Version, e.Package, e.Package, e.Version)
}
// ListOfPeerDependencyError is a list of PeerDependency errors
type ListOfPeerDependencyError struct {
Errors []*PeerDependencyError
}
func (e *ListOfPeerDependencyError) Error() string {
unmetVersions := ""
packageVersions := ""
for _, e := range e.Errors {
unmetVersions += fmt.Sprintf("* version %s of %s not found in %s\n", e.Version, e.Package, e.File)
packageVersions += fmt.Sprintf("- package: %s\n version: %s\n", e.Package, e.Version)
}
return fmt.Sprint("Error: wag peer dependencies not met. \n\n" +
unmetVersions +
"\nPlease ensure your glide.yaml file includes\n\n" +
"```\n" +
packageVersions +
"```\n\n" +
"then run `glide up`.")
}
func validateImports(imports []Import, requiredImport Import) *PeerDependencyError {
for _, i := range imports {
if i.Package == requiredImport.Package &&
i.Version == requiredImport.Version {
return nil
}
}
return &PeerDependencyError{Package: requiredImport.Package, Version: requiredImport.Version, File: "glide.yaml"}
}
func validateLockedVersion(versions []LockedVersion, requiredImport Import) *PeerDependencyError {
for _, v := range versions {
// If we've specified locking to a semantic version like "^1.0.0", we can't easily determine
// if the locked version satisfies that. We accept any version as long as the package is present.
if (v.Name == requiredImport.Package && strings.HasPrefix(requiredImport.Version, "^")) ||
(v.Name == requiredImport.Package && v.Version == requiredImport.Version) {
return nil
}
}
return &PeerDependencyError{Package: requiredImport.Package, Version: requiredImport.Version, File: "glide.lock"}
}