Update and convert glide.lock; chase gps tip
diff --git a/glide.lock b/glide.lock
index 0482f9d..04611c5 100644
--- a/glide.lock
+++ b/glide.lock
@@ -1,18 +1,24 @@
-hash: 7b0d46d2b21d5d8ff24023a402285f87b14b9f554ae52913cc7ea08bfd17453d
-updated: 2016-07-13T23:09:11.03428654-04:00
+hash: e12d18f87508f2f53e2981b52a02ed23d135f59ab90f3afca813727c0685eec0
+updated: 2016-09-15T09:56:26.054743146-04:00
imports:
- name: github.com/armon/go-radix
- version: 4239b77079c7b5d1243b7b4736304ce8ddb6f0f2
+ branch: master
+ revision: 4239b77079c7b5d1243b7b4736304ce8ddb6f0f2
- name: github.com/codegangsta/cli
- version: 71f57d300dd6a780ac1856c005c4b518cfd498ec
+ version: v1.14.0
+ revision: 71f57d300dd6a780ac1856c005c4b518cfd498ec
- name: github.com/Masterminds/semver
- version: b3ef6b1808e9889dfb8767ce7068db923a3d07de
+ branch: 2.x
+ revision: b3ef6b1808e9889dfb8767ce7068db923a3d07de
- name: github.com/Masterminds/vcs
- version: fbe9fb6ad5b5f35b3e82a7c21123cfc526cbf895
+ version: v1.8.0
+ revision: fbe9fb6ad5b5f35b3e82a7c21123cfc526cbf895
- name: github.com/sdboyer/gps
- version: 6e8a101af5e735feedcdae1f716bebc338b74525
+ branch: master
+ revision: 166f36103aedbb9d835b9b6dcc7762a6bd900a98
- name: github.com/termie/go-shutil
- version: bcacb06fecaeec8dc42af03c87c6949f4a05c74c
+ revision: bcacb06fecaeec8dc42af03c87c6949f4a05c74c
- name: gopkg.in/yaml.v2
- version: a83829b6f1293c91addabc89d0571c246397bbf4
+ branch: v2
+ revision: 31c299268d302dd0aa9a0dcf765a3d58971ac83f
testImports: []
diff --git a/vendor/github.com/sdboyer/gps/README.md b/vendor/github.com/sdboyer/gps/README.md
index 2cd2d99..381c2a8 100644
--- a/vendor/github.com/sdboyer/gps/README.md
+++ b/vendor/github.com/sdboyer/gps/README.md
@@ -3,7 +3,7 @@
src="header.png"
width="800" height="255" border="0" alt="gps">
<br>
-<a href="https://circleci.com/gh/sdboyer/gps"><img src="https://circleci.com/gh/sdboyer/gps.svg?style=svg" alt="Build Status"></a>
+<a href="https://circleci.com/gh/sdboyer/gps"><img src="https://circleci.com/gh/sdboyer/gps.svg?style=shield" alt="Build Status"></a>
<a href="https://ci.appveyor.com/project/sdboyer/gps"><img src="https://ci.appveyor.com/api/projects/status/github/sdboyer/gps?svg=true&branch=master&passingText=Windows%20-%20OK&failingText=Windows%20-%20failed&pendingText=Windows%20-%20pending" alt="Windows Build Status"></a>
<a href="https://goreportcard.com/report/github.com/sdboyer/gps"><img src="https://goreportcard.com/badge/github.com/sdboyer/gps" alt="Build Status"></a>
<a href="https://codecov.io/gh/sdboyer/gps"><img src="https://codecov.io/gh/sdboyer/gps/branch/master/graph/badge.svg" alt="Codecov" /></a>
diff --git a/vendor/github.com/sdboyer/gps/analysis.go b/vendor/github.com/sdboyer/gps/analysis.go
index 7fcb5bf..d410eb3 100644
--- a/vendor/github.com/sdboyer/gps/analysis.go
+++ b/vendor/github.com/sdboyer/gps/analysis.go
@@ -69,7 +69,7 @@
// A PackageTree is returned, which contains the ImportRoot and map of import path
// to PackageOrErr - each path under the root that exists will have either a
// Package, or an error describing why the directory is not a valid package.
-func listPackages(fileRoot, importRoot string) (PackageTree, error) {
+func ListPackages(fileRoot, importRoot string) (PackageTree, error) {
// Set up a build.ctx for parsing
ctx := build.Default
ctx.GOROOT = ""
@@ -148,9 +148,6 @@
// We do skip dot-dirs, though, because it's such a ubiquitous standard
// that they not be visited by normal commands, and because things get
// really weird if we don't.
- //
- // TODO(sdboyer) does this entail that we should chuck dot-led import
- // paths later on?
if strings.HasPrefix(fi.Name(), ".") {
return filepath.SkipDir
}
@@ -297,19 +294,279 @@
return fmt.Sprintf("import path %s had problematic local imports", e.Dir)
}
+func readFileBuildTags(fp string) ([]string, error) {
+ co, err := readGoContents(fp)
+ if err != nil {
+ return []string{}, err
+ }
+
+ var tags []string
+ // Only look at places where we had a code comment.
+ if len(co) > 0 {
+ t := findTags(co)
+ for _, tg := range t {
+ found := false
+ for _, tt := range tags {
+ if tt == tg {
+ found = true
+ }
+ }
+ if !found {
+ tags = append(tags, tg)
+ }
+ }
+ }
+
+ return tags, nil
+}
+
+// Read contents of a Go file up to the package declaration. This can be used
+// to find the the build tags.
+func readGoContents(fp string) ([]byte, error) {
+ f, err := os.Open(fp)
+ defer f.Close()
+ if err != nil {
+ return []byte{}, err
+ }
+
+ var s scanner.Scanner
+ s.Init(f)
+ var tok rune
+ var pos scanner.Position
+ for tok != scanner.EOF {
+ tok = s.Scan()
+
+ // Getting the token text will skip comments by default.
+ tt := s.TokenText()
+ // build tags will not be after the package declaration.
+ if tt == "package" {
+ pos = s.Position
+ break
+ }
+ }
+
+ var buf bytes.Buffer
+ f.Seek(0, 0)
+ _, err = io.CopyN(&buf, f, int64(pos.Offset))
+ if err != nil {
+ return []byte{}, err
+ }
+
+ return buf.Bytes(), nil
+}
+
+// From a byte slice of a Go file find the tags.
+func findTags(co []byte) []string {
+ p := co
+ var tgs []string
+ for len(p) > 0 {
+ line := p
+ if i := bytes.IndexByte(line, '\n'); i >= 0 {
+ line, p = line[:i], p[i+1:]
+ } else {
+ p = p[len(p):]
+ }
+ line = bytes.TrimSpace(line)
+ // Only look at comment lines that are well formed in the Go style
+ if bytes.HasPrefix(line, []byte("//")) {
+ line = bytes.TrimSpace(line[len([]byte("//")):])
+ if len(line) > 0 && line[0] == '+' {
+ f := strings.Fields(string(line))
+
+ // We've found a +build tag line.
+ if f[0] == "+build" {
+ for _, tg := range f[1:] {
+ tgs = append(tgs, tg)
+ }
+ }
+ }
+ }
+ }
+
+ return tgs
+}
+
+// A PackageTree represents the results of recursively parsing a tree of
+// packages, starting at the ImportRoot. The results of parsing the files in the
+// directory identified by each import path - a Package or an error - are stored
+// in the Packages map, keyed by that import path.
+type PackageTree struct {
+ ImportRoot string
+ Packages map[string]PackageOrErr
+}
+
+// dup copies the PackageTree.
+//
+// This is really only useful as a defensive measure to prevent external state
+// mutations.
+func (t PackageTree) dup() PackageTree {
+ t2 := PackageTree{
+ ImportRoot: t.ImportRoot,
+ Packages: map[string]PackageOrErr{},
+ }
+
+ for path, poe := range t.Packages {
+ poe2 := PackageOrErr{
+ Err: poe.Err,
+ P: poe.P,
+ }
+ if len(poe.P.Imports) > 0 {
+ poe2.P.Imports = make([]string, len(poe.P.Imports))
+ copy(poe2.P.Imports, poe.P.Imports)
+ }
+ if len(poe.P.TestImports) > 0 {
+ poe2.P.TestImports = make([]string, len(poe.P.TestImports))
+ copy(poe2.P.TestImports, poe.P.TestImports)
+ }
+
+ t2.Packages[path] = poe2
+ }
+
+ return t2
+}
+
type wm struct {
err error
ex map[string]bool
in map[string]bool
}
-// wmToReach takes an externalReach()-style workmap and transitively walks all
-// internal imports until they reach an external path or terminate, then
+// PackageOrErr stores the results of attempting to parse a single directory for
+// Go source code.
+type PackageOrErr struct {
+ P Package
+ Err error
+}
+
+// ReachMap maps a set of import paths (keys) to the set of external packages
+// transitively reachable from the packages at those import paths.
+//
+// See PackageTree.ExternalReach() for more information.
+type ReachMap map[string][]string
+
+// ExternalReach looks through a PackageTree and computes the list of external
+// import statements (that is, import statements pointing to packages that are
+// not logical children of PackageTree.ImportRoot) that are transitively
+// imported by the internal packages in the tree.
+//
+// main indicates whether (true) or not (false) to include main packages in the
+// analysis. When utilized by gps' solver, main packages are generally excluded
+// from analyzing anything other than the root project, as they necessarily can't
+// be imported.
+//
+// tests indicates whether (true) or not (false) to include imports from test
+// files in packages when computing the reach map.
+//
+// ignore is a map of import paths that, if encountered, should be excluded from
+// analysis. This exclusion applies to both internal and external packages. If
+// an external import path is ignored, it is simply omitted from the results.
+//
+// If an internal path is ignored, then not only does it not appear in the final
+// map, but it is also excluded from the transitive calculations of other
+// internal packages. That is, if you ignore A/foo, then the external package
+// list for all internal packages that import A/foo will not include external
+// packages that are only reachable through A/foo.
+//
+// Visually, this means that, given a PackageTree with root A and packages at A,
+// A/foo, and A/bar, and the following import chain:
+//
+// A -> A/foo -> A/bar -> B/baz
+//
+// In this configuration, all of A's packages transitively import B/baz, so the
+// returned map would be:
+//
+// map[string][]string{
+// "A": []string{"B/baz"},
+// "A/foo": []string{"B/baz"}
+// "A/bar": []string{"B/baz"},
+// }
+//
+// However, if you ignore A/foo, then A's path to B/baz is broken, and A/foo is
+// omitted entirely. Thus, the returned map would be:
+//
+// map[string][]string{
+// "A": []string{},
+// "A/bar": []string{"B/baz"},
+// }
+//
+// If there are no packages to ignore, it is safe to pass a nil map.
+func (t PackageTree) ExternalReach(main, tests bool, ignore map[string]bool) ReachMap {
+ if ignore == nil {
+ ignore = make(map[string]bool)
+ }
+
+ // world's simplest adjacency list
+ workmap := make(map[string]wm)
+
+ var imps []string
+ for ip, perr := range t.Packages {
+ if perr.Err != nil {
+ workmap[ip] = wm{
+ err: perr.Err,
+ }
+ continue
+ }
+ p := perr.P
+
+ // Skip main packages, unless param says otherwise
+ if p.Name == "main" && !main {
+ continue
+ }
+ // Skip ignored packages
+ if ignore[ip] {
+ continue
+ }
+
+ imps = imps[:0]
+ imps = p.Imports
+ if tests {
+ imps = dedupeStrings(imps, p.TestImports)
+ }
+
+ w := wm{
+ ex: make(map[string]bool),
+ in: make(map[string]bool),
+ }
+
+ for _, imp := range imps {
+ // Skip ignored imports
+ if ignore[imp] {
+ continue
+ }
+
+ if !checkPrefixSlash(filepath.Clean(imp), t.ImportRoot) {
+ w.ex[imp] = true
+ } else {
+ if w2, seen := workmap[imp]; seen {
+ for i := range w2.ex {
+ w.ex[i] = true
+ }
+ for i := range w2.in {
+ w.in[i] = true
+ }
+ } else {
+ w.in[imp] = true
+ }
+ }
+ }
+
+ workmap[ip] = w
+ }
+
+ //return wmToReach(workmap, t.ImportRoot)
+ return wmToReach(workmap, "") // TODO(sdboyer) this passes tests, but doesn't seem right
+}
+
+// wmToReach takes an internal "workmap" constructed by
+// PackageTree.ExternalReach(), transitively walks (via depth-first traversal)
+// all internal imports until they reach an external path or terminate, then
// translates the results into a slice of external imports for each internal
// pkg.
//
// The basedir string, with a trailing slash ensured, will be stripped from the
// keys of the returned map.
+//
+// This is mostly separated out for testing purposes.
func wmToReach(workmap map[string]wm, basedir string) map[string][]string {
// Uses depth-first exploration to compute reachability into external
// packages, dropping any internal packages on "poisoned paths" - a path
@@ -502,351 +759,9 @@
return rm
}
-func readBuildTags(p string) ([]string, error) {
- _, err := os.Stat(p)
- if err != nil {
- return []string{}, err
- }
-
- d, err := os.Open(p)
- if err != nil {
- return []string{}, err
- }
-
- objects, err := d.Readdir(-1)
- if err != nil {
- return []string{}, err
- }
-
- var tags []string
- for _, obj := range objects {
-
- // only process Go files
- if strings.HasSuffix(obj.Name(), ".go") {
- fp := filepath.Join(p, obj.Name())
-
- co, err := readGoContents(fp)
- if err != nil {
- return []string{}, err
- }
-
- // Only look at places where we had a code comment.
- if len(co) > 0 {
- t := findTags(co)
- for _, tg := range t {
- found := false
- for _, tt := range tags {
- if tt == tg {
- found = true
- }
- }
- if !found {
- tags = append(tags, tg)
- }
- }
- }
- }
- }
-
- return tags, nil
-}
-
-func readFileBuildTags(fp string) ([]string, error) {
- co, err := readGoContents(fp)
- if err != nil {
- return []string{}, err
- }
-
- var tags []string
- // Only look at places where we had a code comment.
- if len(co) > 0 {
- t := findTags(co)
- for _, tg := range t {
- found := false
- for _, tt := range tags {
- if tt == tg {
- found = true
- }
- }
- if !found {
- tags = append(tags, tg)
- }
- }
- }
-
- return tags, nil
-}
-
-// Read contents of a Go file up to the package declaration. This can be used
-// to find the the build tags.
-func readGoContents(fp string) ([]byte, error) {
- f, err := os.Open(fp)
- defer f.Close()
- if err != nil {
- return []byte{}, err
- }
-
- var s scanner.Scanner
- s.Init(f)
- var tok rune
- var pos scanner.Position
- for tok != scanner.EOF {
- tok = s.Scan()
-
- // Getting the token text will skip comments by default.
- tt := s.TokenText()
- // build tags will not be after the package declaration.
- if tt == "package" {
- pos = s.Position
- break
- }
- }
-
- var buf bytes.Buffer
- f.Seek(0, 0)
- _, err = io.CopyN(&buf, f, int64(pos.Offset))
- if err != nil {
- return []byte{}, err
- }
-
- return buf.Bytes(), nil
-}
-
-// From a byte slice of a Go file find the tags.
-func findTags(co []byte) []string {
- p := co
- var tgs []string
- for len(p) > 0 {
- line := p
- if i := bytes.IndexByte(line, '\n'); i >= 0 {
- line, p = line[:i], p[i+1:]
- } else {
- p = p[len(p):]
- }
- line = bytes.TrimSpace(line)
- // Only look at comment lines that are well formed in the Go style
- if bytes.HasPrefix(line, []byte("//")) {
- line = bytes.TrimSpace(line[len([]byte("//")):])
- if len(line) > 0 && line[0] == '+' {
- f := strings.Fields(string(line))
-
- // We've found a +build tag line.
- if f[0] == "+build" {
- for _, tg := range f[1:] {
- tgs = append(tgs, tg)
- }
- }
- }
- }
- }
-
- return tgs
-}
-
-// Get an OS value that's not the one passed in.
-func getOsValue(n string) string {
- for _, o := range osList {
- if o != n {
- return o
- }
- }
-
- return n
-}
-
-func isSupportedOs(n string) bool {
- for _, o := range osList {
- if o == n {
- return true
- }
- }
-
- return false
-}
-
-// Get an Arch value that's not the one passed in.
-func getArchValue(n string) string {
- for _, o := range archList {
- if o != n {
- return o
- }
- }
-
- return n
-}
-
-func isSupportedArch(n string) bool {
- for _, o := range archList {
- if o == n {
- return true
- }
- }
-
- return false
-}
-
-func ensureTrailingSlash(s string) string {
- return strings.TrimSuffix(s, string(os.PathSeparator)) + string(os.PathSeparator)
-}
-
-// helper func to merge, dedupe, and sort strings
-func dedupeStrings(s1, s2 []string) (r []string) {
- dedupe := make(map[string]bool)
-
- if len(s1) > 0 && len(s2) > 0 {
- for _, i := range s1 {
- dedupe[i] = true
- }
- for _, i := range s2 {
- dedupe[i] = true
- }
-
- for i := range dedupe {
- r = append(r, i)
- }
- // And then re-sort them
- sort.Strings(r)
- } else if len(s1) > 0 {
- r = s1
- } else if len(s2) > 0 {
- r = s2
- }
-
- return
-}
-
-// A PackageTree represents the results of recursively parsing a tree of
-// packages, starting at the ImportRoot. The results of parsing the files in the
-// directory identified by each import path - a Package or an error - are stored
-// in the Packages map, keyed by that import path.
-type PackageTree struct {
- ImportRoot string
- Packages map[string]PackageOrErr
-}
-
-// PackageOrErr stores the results of attempting to parse a single directory for
-// Go source code.
-type PackageOrErr struct {
- P Package
- Err error
-}
-
-// ExternalReach looks through a PackageTree and computes the list of external
-// import statements (that is, import statements pointing to packages that are
-// not logical children of PackageTree.ImportRoot) that are transitively
-// imported by the internal packages in the tree.
-//
-// main indicates whether (true) or not (false) to include main packages in the
-// analysis. When utilized by gps' solver, main packages are generally excluded
-// from analyzing anything other than the root project, as they necessarily can't
-// be imported.
-//
-// tests indicates whether (true) or not (false) to include imports from test
-// files in packages when computing the reach map.
-//
-// ignore is a map of import paths that, if encountered, should be excluded from
-// analysis. This exclusion applies to both internal and external packages. If
-// an external import path is ignored, it is simply omitted from the results.
-//
-// If an internal path is ignored, then not only does it not appear in the final
-// map, but it is also excluded from the transitive calculations of other
-// internal packages. That is, if you ignore A/foo, then the external package
-// list for all internal packages that import A/foo will not include external
-// packages that are only reachable through A/foo.
-//
-// Visually, this means that, given a PackageTree with root A and packages at A,
-// A/foo, and A/bar, and the following import chain:
-//
-// A -> A/foo -> A/bar -> B/baz
-//
-// In this configuration, all of A's packages transitively import B/baz, so the
-// returned map would be:
-//
-// map[string][]string{
-// "A": []string{"B/baz"},
-// "A/foo": []string{"B/baz"}
-// "A/bar": []string{"B/baz"},
-// }
-//
-// However, if you ignore A/foo, then A's path to B/baz is broken, and A/foo is
-// omitted entirely. Thus, the returned map would be:
-//
-// map[string][]string{
-// "A": []string{},
-// "A/bar": []string{"B/baz"},
-// }
-//
-// If there are no packages to ignore, it is safe to pass a nil map.
-func (t PackageTree) ExternalReach(main, tests bool, ignore map[string]bool) map[string][]string {
- if ignore == nil {
- ignore = make(map[string]bool)
- }
-
- // world's simplest adjacency list
- workmap := make(map[string]wm)
-
- var imps []string
- for ip, perr := range t.Packages {
- if perr.Err != nil {
- workmap[ip] = wm{
- err: perr.Err,
- }
- continue
- }
- p := perr.P
-
- // Skip main packages, unless param says otherwise
- if p.Name == "main" && !main {
- continue
- }
- // Skip ignored packages
- if ignore[ip] {
- continue
- }
-
- imps = imps[:0]
- imps = p.Imports
- if tests {
- imps = dedupeStrings(imps, p.TestImports)
- }
-
- w := wm{
- ex: make(map[string]bool),
- in: make(map[string]bool),
- }
-
- for _, imp := range imps {
- // Skip ignored imports
- if ignore[imp] {
- continue
- }
-
- if !checkPrefixSlash(filepath.Clean(imp), t.ImportRoot) {
- w.ex[imp] = true
- } else {
- if w2, seen := workmap[imp]; seen {
- for i := range w2.ex {
- w.ex[i] = true
- }
- for i := range w2.in {
- w.in[i] = true
- }
- } else {
- w.in[imp] = true
- }
- }
- }
-
- workmap[ip] = w
- }
-
- //return wmToReach(workmap, t.ImportRoot)
- return wmToReach(workmap, "") // TODO(sdboyer) this passes tests, but doesn't seem right
-}
-
// ListExternalImports computes a sorted, deduplicated list of all the external
-// packages that are reachable through imports from all valid packages in the
-// PackageTree.
+// packages that are reachable through imports from all valid packages in a
+// ReachMap, as computed by PackageTree.ExternalReach().
//
// main and tests determine whether main packages and test imports should be
// included in the calculation. "External" is defined as anything not prefixed,
@@ -910,10 +825,7 @@
// -> A/.bar -> B/baz
//
// A is legal, and it imports A/.bar, so the results will include B/baz.
-func (t PackageTree) ListExternalImports(main, tests bool, ignore map[string]bool) []string {
- // First, we need a reachmap
- rm := t.ExternalReach(main, tests, ignore)
-
+func (rm ReachMap) ListExternalImports() []string {
exm := make(map[string]struct{})
for pkg, reach := range rm {
// Eliminate import paths with any elements having leading dots, leading
@@ -962,3 +874,33 @@
}
return s == prefix || strings.HasPrefix(s, ensureTrailingSlash(prefix))
}
+
+func ensureTrailingSlash(s string) string {
+ return strings.TrimSuffix(s, string(os.PathSeparator)) + string(os.PathSeparator)
+}
+
+// helper func to merge, dedupe, and sort strings
+func dedupeStrings(s1, s2 []string) (r []string) {
+ dedupe := make(map[string]bool)
+
+ if len(s1) > 0 && len(s2) > 0 {
+ for _, i := range s1 {
+ dedupe[i] = true
+ }
+ for _, i := range s2 {
+ dedupe[i] = true
+ }
+
+ for i := range dedupe {
+ r = append(r, i)
+ }
+ // And then re-sort them
+ sort.Strings(r)
+ } else if len(s1) > 0 {
+ r = s1
+ } else if len(s2) > 0 {
+ r = s2
+ }
+
+ return
+}
diff --git a/vendor/github.com/sdboyer/gps/analysis_test.go b/vendor/github.com/sdboyer/gps/analysis_test.go
index 210d036..c21f53b 100644
--- a/vendor/github.com/sdboyer/gps/analysis_test.go
+++ b/vendor/github.com/sdboyer/gps/analysis_test.go
@@ -836,7 +836,7 @@
continue
}
- out, err := listPackages(fix.fileRoot, fix.importRoot)
+ out, err := ListPackages(fix.fileRoot, fix.importRoot)
if err != nil && fix.err == nil {
t.Errorf("listPackages(%q): Received error but none expected: %s", name, err)
@@ -889,7 +889,7 @@
func TestListExternalImports(t *testing.T) {
// There's enough in the 'varied' test case to test most of what matters
- vptree, err := listPackages(filepath.Join(getwd(t), "_testdata", "src", "varied"), "varied")
+ vptree, err := ListPackages(filepath.Join(getwd(t), "_testdata", "src", "varied"), "varied")
if err != nil {
t.Fatalf("listPackages failed on varied test case: %s", err)
}
@@ -900,7 +900,7 @@
var main, tests bool
validate := func() {
- result := vptree.ListExternalImports(main, tests, ignore)
+ result := vptree.ExternalReach(main, tests, ignore).ListExternalImports()
if !reflect.DeepEqual(expect, result) {
t.Errorf("Wrong imports in %q case:\n\t(GOT): %s\n\t(WNT): %s", name, result, expect)
}
@@ -1034,12 +1034,12 @@
validate()
// The only thing varied *doesn't* cover is disallowed path patterns
- ptree, err := listPackages(filepath.Join(getwd(t), "_testdata", "src", "disallow"), "disallow")
+ ptree, err := ListPackages(filepath.Join(getwd(t), "_testdata", "src", "disallow"), "disallow")
if err != nil {
t.Fatalf("listPackages failed on disallow test case: %s", err)
}
- result := ptree.ListExternalImports(false, false, nil)
+ result := ptree.ExternalReach(false, false, nil).ListExternalImports()
expect = []string{"github.com/sdboyer/gps", "hash", "sort"}
if !reflect.DeepEqual(expect, result) {
t.Errorf("Wrong imports in %q case:\n\t(GOT): %s\n\t(WNT): %s", name, result, expect)
@@ -1048,7 +1048,7 @@
func TestExternalReach(t *testing.T) {
// There's enough in the 'varied' test case to test most of what matters
- vptree, err := listPackages(filepath.Join(getwd(t), "_testdata", "src", "varied"), "varied")
+ vptree, err := ListPackages(filepath.Join(getwd(t), "_testdata", "src", "varied"), "varied")
if err != nil {
t.Fatalf("listPackages failed on varied test case: %s", err)
}
diff --git a/vendor/github.com/sdboyer/gps/bridge.go b/vendor/github.com/sdboyer/gps/bridge.go
index a7368e3..379cd4b 100644
--- a/vendor/github.com/sdboyer/gps/bridge.go
+++ b/vendor/github.com/sdboyer/gps/bridge.go
@@ -14,7 +14,6 @@
type sourceBridge interface {
SourceManager // composes SourceManager
verifyRootDir(path string) error
- computeRootReach() ([]string, error)
pairRevision(id ProjectIdentifier, r Revision) []Version
pairVersion(id ProjectIdentifier, v UnpairedVersion) PairedVersion
vendorCodeExists(id ProjectIdentifier) (bool, error)
@@ -68,7 +67,7 @@
}
func (b *bridge) GetManifestAndLock(id ProjectIdentifier, v Version) (Manifest, Lock, error) {
- if id.ProjectRoot == b.s.params.ImportRoot {
+ if id.ProjectRoot == ProjectRoot(b.s.rpt.ImportRoot) {
return b.s.rm, b.s.rl, nil
}
return b.sm.GetManifestAndLock(id, v)
@@ -339,57 +338,14 @@
return nil
}
-// computeRootReach is a specialized, less stringent version of listExternal
-// that allows for a bit of fuzziness in the source inputs.
-//
-// Specifically, we need to:
-// - Analyze test-type files as well as typical source files
-// - Make a best-effort attempt even if the code doesn't compile
-// - Include main packages in the analysis
-//
-// Perhaps most important is that we don't want to have the results of this
-// analysis be in any permanent cache, and we want to read directly from our
-// potentially messy root project source location on disk. Together, this means
-// that we can't ask the real SourceManager to do it.
-func (b *bridge) computeRootReach() ([]string, error) {
- // TODO(sdboyer) i now cannot remember the reasons why i thought being less stringent
- // in the analysis was OK. so, for now, we just compute a bog-standard list
- // of externally-touched packages, including mains and test.
- ptree, err := b.listRootPackages()
- if err != nil {
- return nil, err
- }
-
- return ptree.ListExternalImports(true, true, b.s.ig), nil
-}
-
-func (b *bridge) listRootPackages() (PackageTree, error) {
- if b.crp == nil {
- ptree, err := listPackages(b.s.params.RootDir, string(b.s.params.ImportRoot))
-
- b.crp = &struct {
- ptree PackageTree
- err error
- }{
- ptree: ptree,
- err: err,
- }
- }
- if b.crp.err != nil {
- return PackageTree{}, b.crp.err
- }
-
- return b.crp.ptree, nil
-}
-
// listPackages lists all the packages contained within the given project at a
// particular version.
//
// The root project is handled separately, as the source manager isn't
// responsible for that code.
func (b *bridge) ListPackages(id ProjectIdentifier, v Version) (PackageTree, error) {
- if id.ProjectRoot == b.s.params.ImportRoot {
- return b.listRootPackages()
+ if id.ProjectRoot == ProjectRoot(b.s.rpt.ImportRoot) {
+ panic("should never call ListPackages on root project")
}
return b.sm.ListPackages(id, v)
diff --git a/vendor/github.com/sdboyer/gps/example.go b/vendor/github.com/sdboyer/gps/example.go
index 2bbbe2c..c3a827a 100644
--- a/vendor/github.com/sdboyer/gps/example.go
+++ b/vendor/github.com/sdboyer/gps/example.go
@@ -32,10 +32,10 @@
// Set up params, including tracing
params := gps.SolveParameters{
RootDir: root,
- ImportRoot: gps.ProjectRoot(importroot),
Trace: true,
TraceLogger: log.New(os.Stdout, "", 0),
}
+ params.RootPackageTree, _ = gps.ListPackages(root, importroot)
// Set up a SourceManager with the NaiveAnalyzer
sourcemgr, _ := gps.NewSourceManager(NaiveAnalyzer{}, ".repocache", false)
diff --git a/vendor/github.com/sdboyer/gps/hash.go b/vendor/github.com/sdboyer/gps/hash.go
index 893c34e..ca9c9a2 100644
--- a/vendor/github.com/sdboyer/gps/hash.go
+++ b/vendor/github.com/sdboyer/gps/hash.go
@@ -20,7 +20,7 @@
// Do these checks up front before any other work is needed, as they're the
// only things that can cause errors
// Pass in magic root values, and the bridge will analyze the right thing
- ptree, err := s.b.ListPackages(ProjectIdentifier{ProjectRoot: s.params.ImportRoot}, nil)
+ ptree, err := s.b.ListPackages(ProjectIdentifier{ProjectRoot: ProjectRoot(s.params.RootPackageTree.ImportRoot)}, nil)
if err != nil {
return nil, badOptsFailure(fmt.Sprintf("Error while parsing packages under %s: %s", s.params.RootDir, err.Error()))
}
diff --git a/vendor/github.com/sdboyer/gps/hash_test.go b/vendor/github.com/sdboyer/gps/hash_test.go
index f356ced..51732ca 100644
--- a/vendor/github.com/sdboyer/gps/hash_test.go
+++ b/vendor/github.com/sdboyer/gps/hash_test.go
@@ -10,9 +10,9 @@
fix := basicFixtures["shared dependency with overlapping constraints"]
params := SolveParameters{
- RootDir: string(fix.ds[0].n),
- ImportRoot: fix.ds[0].n,
- Manifest: fix.rootmanifest(),
+ RootDir: string(fix.ds[0].n),
+ RootPackageTree: fix.rootTree(),
+ Manifest: fix.rootmanifest(),
}
s, err := Prepare(params, newdepspecSM(fix.ds, nil))
@@ -51,15 +51,16 @@
func TestHashInputsIgnores(t *testing.T) {
fix := basicFixtures["shared dependency with overlapping constraints"]
- rm := fix.rootmanifest().(simpleRootManifest)
+ rm := fix.rootmanifest().(simpleRootManifest).dup()
rm.ig = map[string]bool{
"foo": true,
"bar": true,
}
+
params := SolveParameters{
- RootDir: string(fix.ds[0].n),
- ImportRoot: fix.ds[0].n,
- Manifest: rm,
+ RootDir: string(fix.ds[0].n),
+ RootPackageTree: fix.rootTree(),
+ Manifest: rm,
}
s, err := Prepare(params, newdepspecSM(fix.ds, nil))
@@ -101,7 +102,7 @@
func TestHashInputsOverrides(t *testing.T) {
fix := basicFixtures["shared dependency with overlapping constraints"]
- rm := fix.rootmanifest().(simpleRootManifest)
+ rm := fix.rootmanifest().(simpleRootManifest).dup()
// First case - override something not in the root, just with network name
rm.ovr = map[ProjectRoot]ProjectProperties{
"c": ProjectProperties{
@@ -109,9 +110,9 @@
},
}
params := SolveParameters{
- RootDir: string(fix.ds[0].n),
- ImportRoot: fix.ds[0].n,
- Manifest: rm,
+ RootDir: string(fix.ds[0].n),
+ RootPackageTree: fix.rootTree(),
+ Manifest: rm,
}
s, err := Prepare(params, newdepspecSM(fix.ds, nil))
diff --git a/vendor/github.com/sdboyer/gps/manifest.go b/vendor/github.com/sdboyer/gps/manifest.go
index 94513d0..ff23ec0 100644
--- a/vendor/github.com/sdboyer/gps/manifest.go
+++ b/vendor/github.com/sdboyer/gps/manifest.go
@@ -90,6 +90,26 @@
func (m simpleRootManifest) IgnorePackages() map[string]bool {
return m.ig
}
+func (m simpleRootManifest) dup() simpleRootManifest {
+ m2 := simpleRootManifest{
+ c: make([]ProjectConstraint, len(m.c)),
+ tc: make([]ProjectConstraint, len(m.tc)),
+ ovr: ProjectConstraints{},
+ ig: map[string]bool{},
+ }
+
+ copy(m2.c, m.c)
+ copy(m2.tc, m.tc)
+
+ for k, v := range m.ovr {
+ m2.ovr[k] = v
+ }
+ for k, v := range m.ig {
+ m2.ig[k] = v
+ }
+
+ return m2
+}
// prepManifest ensures a manifest is prepared and safe for use by the solver.
// This is mostly about ensuring that no outside routine can modify the manifest
diff --git a/vendor/github.com/sdboyer/gps/solve_basic_test.go b/vendor/github.com/sdboyer/gps/solve_basic_test.go
index c0ca587..9fe9780 100644
--- a/vendor/github.com/sdboyer/gps/solve_basic_test.go
+++ b/vendor/github.com/sdboyer/gps/solve_basic_test.go
@@ -348,6 +348,7 @@
type specfix interface {
name() string
rootmanifest() RootManifest
+ rootTree() PackageTree
specs() []depspec
maxTries() int
solution() map[ProjectIdentifier]Version
@@ -413,6 +414,33 @@
}
}
+func (f basicFixture) rootTree() PackageTree {
+ var imp, timp []string
+ for _, dep := range f.ds[0].deps {
+ imp = append(imp, string(dep.Ident.ProjectRoot))
+ }
+ for _, dep := range f.ds[0].devdeps {
+ timp = append(timp, string(dep.Ident.ProjectRoot))
+ }
+
+ n := string(f.ds[0].n)
+ pt := PackageTree{
+ ImportRoot: n,
+ Packages: map[string]PackageOrErr{
+ string(n): {
+ P: Package{
+ ImportPath: n,
+ Name: n,
+ Imports: imp,
+ TestImports: timp,
+ },
+ },
+ },
+ }
+
+ return pt
+}
+
func (f basicFixture) failure() error {
return f.fail
}
@@ -667,6 +695,10 @@
"bar 1.0.1",
),
},
+ // This fixture describes a situation that should be impossible with a
+ // real-world VCS (contents of dep at same rev are different, as indicated
+ // by different constraints on bar). But, that's not the SUT here, so it's
+ // OK.
"pairs bare revs in lock with all versions": {
ds: []depspec{
mkDepspec("root 0.0.0", "foo ~1.0.1"),
@@ -682,7 +714,7 @@
),
r: mksolution(
"foo 1.0.2 foorev",
- "bar 1.0.1",
+ "bar 1.0.2",
),
},
"does not pair bare revs in manifest with unpaired lock version": {
@@ -703,6 +735,35 @@
"bar 1.0.1",
),
},
+ "lock to branch on old rev keeps old rev": {
+ ds: []depspec{
+ mkDepspec("root 0.0.0", "foo bmaster"),
+ mkDepspec("foo bmaster newrev"),
+ },
+ l: mklock(
+ "foo bmaster oldrev",
+ ),
+ r: mksolution(
+ "foo bmaster oldrev",
+ ),
+ },
+ // Whereas this is a normal situation for a branch, when it occurs for a
+ // tag, it means someone's been naughty upstream. Still, though, the outcome
+ // is the same.
+ //
+ // TODO(sdboyer) this needs to generate a warning, once we start doing that
+ "lock to now-moved tag on old rev keeps old rev": {
+ ds: []depspec{
+ mkDepspec("root 0.0.0", "foo ptaggerino"),
+ mkDepspec("foo ptaggerino newrev"),
+ },
+ l: mklock(
+ "foo ptaggerino oldrev",
+ ),
+ r: mksolution(
+ "foo ptaggerino oldrev",
+ ),
+ },
"includes root package's dev dependencies": {
ds: []depspec{
mkDepspec("root 1.0.0", "(dev) foo 1.0.0", "(dev) bar 1.0.0"),
@@ -1175,6 +1236,16 @@
}
func (sm *depspecSourceManager) GetManifestAndLock(id ProjectIdentifier, v Version) (Manifest, Lock, error) {
+ // If the input version is a PairedVersion, look only at its top version,
+ // not the underlying. This is generally consistent with the idea that, for
+ // this class of lookup, the rev probably DOES exist, but upstream changed
+ // it (typically a branch). For the purposes of tests, then, that's an OK
+ // scenario, because otherwise we'd have to enumerate all the revs in the
+ // fixture declarations, which would screw up other things.
+ if pv, ok := v.(PairedVersion); ok {
+ v = pv.Unpair()
+ }
+
for _, ds := range sm.specs {
if id.netName() == string(ds.n) && v.Matches(ds.v) {
return ds, dummyLock{}, nil
@@ -1210,7 +1281,7 @@
pid := pident{n: ProjectRoot(id.netName()), v: v}
if r, exists := sm.rm[pid]; exists {
- ptree := PackageTree{
+ return PackageTree{
ImportRoot: string(pid.n),
Packages: map[string]PackageOrErr{
string(pid.n): {
@@ -1221,8 +1292,29 @@
},
},
},
+ }, nil
+ }
+
+ // if incoming version was paired, walk the map and search for a match on
+ // top-only version
+ if pv, ok := v.(PairedVersion); ok {
+ uv := pv.Unpair()
+ for pid, r := range sm.rm {
+ if uv.Matches(pid.v) {
+ return PackageTree{
+ ImportRoot: string(pid.n),
+ Packages: map[string]PackageOrErr{
+ string(pid.n): {
+ P: Package{
+ ImportPath: string(pid.n),
+ Name: string(pid.n),
+ Imports: r[string(pid.n)],
+ },
+ },
+ },
+ }, nil
+ }
}
- return ptree, nil
}
return PackageTree{}, fmt.Errorf("Project %s at version %s could not be found", pid.n, v)
@@ -1272,10 +1364,6 @@
return nil
}
-func (sm *depspecSourceManager) VendorCodeExists(id ProjectIdentifier) (bool, error) {
- return false, nil
-}
-
func (sm *depspecSourceManager) Release() {}
func (sm *depspecSourceManager) ExportProject(id ProjectIdentifier, v Version, to string) error {
@@ -1308,26 +1396,11 @@
*bridge
}
-// override computeRootReach() on bridge to read directly out of the depspecs
-func (b *depspecBridge) computeRootReach() ([]string, error) {
- // This only gets called for the root project, so grab that one off the test
- // source manager
- dsm := b.sm.(fixSM)
- root := dsm.rootSpec()
-
- ptree, err := dsm.ListPackages(mkPI(string(root.n)), nil)
- if err != nil {
- return nil, err
- }
-
- return ptree.ListExternalImports(true, true, dsm.ignore()), nil
-}
-
// override verifyRoot() on bridge to prevent any filesystem interaction
func (b *depspecBridge) verifyRootDir(path string) error {
root := b.sm.(fixSM).rootSpec()
if string(root.n) != path {
- return fmt.Errorf("Expected only root project %q to computeRootReach(), got %q", root.n, path)
+ return fmt.Errorf("Expected only root project %q to verifyRootDir(), got %q", root.n, path)
}
return nil
@@ -1337,6 +1410,10 @@
return b.sm.(fixSM).ListPackages(id, v)
}
+func (sm *depspecBridge) vendorCodeExists(id ProjectIdentifier) (bool, error) {
+ return false, nil
+}
+
// enforce interfaces
var _ Manifest = depspec{}
var _ Lock = dummyLock{}
diff --git a/vendor/github.com/sdboyer/gps/solve_bimodal_test.go b/vendor/github.com/sdboyer/gps/solve_bimodal_test.go
index 9ebe483..f430ad9 100644
--- a/vendor/github.com/sdboyer/gps/solve_bimodal_test.go
+++ b/vendor/github.com/sdboyer/gps/solve_bimodal_test.go
@@ -3,6 +3,7 @@
import (
"fmt"
"path/filepath"
+ "strings"
)
// dsp - "depspec with packages"
@@ -791,6 +792,28 @@
return m
}
+func (f bimodalFixture) rootTree() PackageTree {
+ pt := PackageTree{
+ ImportRoot: string(f.ds[0].n),
+ Packages: map[string]PackageOrErr{},
+ }
+
+ for _, pkg := range f.ds[0].pkgs {
+ elems := strings.Split(pkg.path, "/")
+ pt.Packages[pkg.path] = PackageOrErr{
+ P: Package{
+ ImportPath: pkg.path,
+ Name: elems[len(elems)-1],
+ // TODO(sdboyer) ugh, tpkg type has no space for supporting test
+ // imports...
+ Imports: pkg.imports,
+ },
+ }
+ }
+
+ return pt
+}
+
func (f bimodalFixture) failure() error {
return f.fail
}
diff --git a/vendor/github.com/sdboyer/gps/solve_test.go b/vendor/github.com/sdboyer/gps/solve_test.go
index 53bcdcd..425dd50 100644
--- a/vendor/github.com/sdboyer/gps/solve_test.go
+++ b/vendor/github.com/sdboyer/gps/solve_test.go
@@ -19,7 +19,7 @@
// TODO(sdboyer) regression test ensuring that locks with only revs for projects don't cause errors
func init() {
- flag.StringVar(&fixtorun, "gps.fix", "", "A single fixture to run in TestBasicSolves")
+ flag.StringVar(&fixtorun, "gps.fix", "", "A single fixture to run in TestBasicSolves or TestBimodalSolves")
overrideMkBridge()
}
@@ -87,12 +87,12 @@
sm := newdepspecSM(fix.ds, nil)
params := SolveParameters{
- RootDir: string(fix.ds[0].n),
- ImportRoot: ProjectRoot(fix.ds[0].n),
- Manifest: fix.rootmanifest(),
- Lock: dummyLock{},
- Downgrade: fix.downgrade,
- ChangeAll: fix.changeall,
+ RootDir: string(fix.ds[0].n),
+ RootPackageTree: fix.rootTree(),
+ Manifest: fix.rootmanifest(),
+ Lock: dummyLock{},
+ Downgrade: fix.downgrade,
+ ChangeAll: fix.changeall,
}
if fix.l != nil {
@@ -137,12 +137,12 @@
sm := newbmSM(fix)
params := SolveParameters{
- RootDir: string(fix.ds[0].n),
- ImportRoot: ProjectRoot(fix.ds[0].n),
- Manifest: fix.rootmanifest(),
- Lock: dummyLock{},
- Downgrade: fix.downgrade,
- ChangeAll: fix.changeall,
+ RootDir: string(fix.ds[0].n),
+ RootPackageTree: fix.rootTree(),
+ Manifest: fix.rootmanifest(),
+ Lock: dummyLock{},
+ Downgrade: fix.downgrade,
+ ChangeAll: fix.changeall,
}
if fix.l != nil {
@@ -163,6 +163,13 @@
return fmt.Sprintf("%s (from %s)", id.ProjectRoot, id.NetworkName)
}
+ pv := func(v Version) string {
+ if pv, ok := v.(PairedVersion); ok {
+ return fmt.Sprintf("%s (%s)", pv.Unpair(), pv.Underlying())
+ }
+ return v.String()
+ }
+
fixfail := fix.failure()
if err != nil {
if fixfail == nil {
@@ -207,7 +214,7 @@
// delete result from map so we skip it on the reverse pass
delete(rp, p)
if v != av {
- t.Errorf("(fixture: %q) Expected version %q of project %q, but actual version was %q", fix.name(), v, ppi(p), av)
+ t.Errorf("(fixture: %q) Expected version %q of project %q, but actual version was %q", fix.name(), pv(v), ppi(p), pv(av))
}
}
}
@@ -217,7 +224,7 @@
if fv, exists := fix.solution()[p]; !exists {
t.Errorf("(fixture: %q) Unexpected project %q present in results", fix.name(), ppi(p))
} else if v != fv {
- t.Errorf("(fixture: %q) Got version %q of project %q, but expected version was %q", fix.name(), v, ppi(p), fv)
+ t.Errorf("(fixture: %q) Got version %q of project %q, but expected version was %q", fix.name(), pv(v), ppi(p), pv(fv))
}
}
}
@@ -232,7 +239,7 @@
// produce weird side effects.
func TestRootLockNoVersionPairMatching(t *testing.T) {
fix := basicFixture{
- n: "does not pair bare revs in manifest with unpaired lock version",
+ n: "does not match unpaired lock versions with paired real versions",
ds: []depspec{
mkDepspec("root 0.0.0", "foo *"), // foo's constraint rewritten below to foorev
mkDepspec("foo 1.0.0", "bar 1.0.0"),
@@ -247,7 +254,7 @@
),
r: mksolution(
"foo 1.0.2 foorev",
- "bar 1.0.1",
+ "bar 1.0.2",
),
}
@@ -262,10 +269,10 @@
l2[0].v = nil
params := SolveParameters{
- RootDir: string(fix.ds[0].n),
- ImportRoot: ProjectRoot(fix.ds[0].n),
- Manifest: fix.rootmanifest(),
- Lock: l2,
+ RootDir: string(fix.ds[0].n),
+ RootPackageTree: fix.rootTree(),
+ Manifest: fix.rootmanifest(),
+ Lock: l2,
}
res, err := fixSolve(params, sm)
@@ -303,7 +310,27 @@
t.Error("Prepare should have given error on empty import root, but gave:", err)
}
- params.ImportRoot = ProjectRoot(pn)
+ params.RootPackageTree = PackageTree{
+ ImportRoot: pn,
+ }
+ _, err = Prepare(params, sm)
+ if err == nil {
+ t.Errorf("Prepare should have errored on empty name")
+ } else if !strings.Contains(err.Error(), "at least one package") {
+ t.Error("Prepare should have given error on empty import root, but gave:", err)
+ }
+
+ params.RootPackageTree = PackageTree{
+ ImportRoot: pn,
+ Packages: map[string]PackageOrErr{
+ pn: {
+ P: Package{
+ ImportPath: pn,
+ Name: pn,
+ },
+ },
+ },
+ }
params.Trace = true
_, err = Prepare(params, sm)
if err == nil {
diff --git a/vendor/github.com/sdboyer/gps/solver.go b/vendor/github.com/sdboyer/gps/solver.go
index f7d9a24..8993b78 100644
--- a/vendor/github.com/sdboyer/gps/solver.go
+++ b/vendor/github.com/sdboyer/gps/solver.go
@@ -31,16 +31,15 @@
// A real path to a readable directory is required.
RootDir string
- // The import path at the base of all import paths covered by the project.
- // For example, the appropriate value for gps itself here is:
+ // The tree of packages that comprise the root project, as well as the
+ // import path that should identify the root of that tree.
//
- // github.com/sdboyer/gps
+ // In most situations, tools should simply pass the result of ListPackages()
+ // directly through here.
//
- // In most cases, this should match the latter portion of RootDir. However,
- // that is not (currently) required.
- //
- // A non-empty string is required.
- ImportRoot ProjectRoot
+ // The ImportRoot property must be a non-empty string, and at least one
+ // element must be present in the Packages map.
+ RootPackageTree PackageTree
// The root manifest. This contains all the dependency constraints
// associated with normal Manifests, as well as the particular controls
@@ -157,6 +156,9 @@
// A defensively-copied instance of the root lock.
rl Lock
+
+ // A defensively-copied instance of params.RootPackageTree
+ rpt PackageTree
}
// A Solver is the main workhorse of gps: given a set of project inputs, it
@@ -192,9 +194,12 @@
if params.RootDir == "" {
return nil, badOptsFailure("params must specify a non-empty root directory")
}
- if params.ImportRoot == "" {
+ if params.RootPackageTree.ImportRoot == "" {
return nil, badOptsFailure("params must include a non-empty import root")
}
+ if len(params.RootPackageTree.Packages) == 0 {
+ return nil, badOptsFailure("at least one package must be present in the PackageTree")
+ }
if params.Trace && params.TraceLogger == nil {
return nil, badOptsFailure("trace requested, but no logger provided")
}
@@ -208,6 +213,7 @@
ig: params.Manifest.IgnorePackages(),
ovr: params.Manifest.Overrides(),
tl: params.TraceLogger,
+ rpt: params.RootPackageTree.dup(),
}
// Ensure the ignore and overrides maps are at least initialized
@@ -316,7 +322,7 @@
return soln, err
}
-// solve is the top-level loop for the SAT solving process.
+// solve is the top-level loop for the solving process.
func (s *solver) solve() (map[atom]map[string]struct{}, error) {
// Main solving loop
for {
@@ -331,9 +337,9 @@
// satisfiability and selection paths depending on whether we've already
// selected the base project/repo that came off the unselected queue.
//
- // (If we already have selected the project, other parts of the
- // algorithm guarantee the bmi will contain at least one package from
- // this project that has yet to be selected.)
+ // (If we've already selected the project, other parts of the algorithm
+ // guarantee the bmi will contain at least one package from this project
+ // that has yet to be selected.)
if awp, is := s.sel.selected(bmi.id); !is {
// Analysis path for when we haven't selected the project yet - need
// to create a version queue.
@@ -425,7 +431,7 @@
func (s *solver) selectRoot() error {
pa := atom{
id: ProjectIdentifier{
- ProjectRoot: s.params.ImportRoot,
+ ProjectRoot: ProjectRoot(s.rpt.ImportRoot),
},
// This is a hack so that the root project doesn't have a nil version.
// It's sort of OK because the root never makes it out into the results.
@@ -462,7 +468,7 @@
// Err is not possible at this point, as it could only come from
// listPackages(), which if we're here already succeeded for root
- reach, _ := s.b.computeRootReach()
+ reach := s.rpt.ExternalReach(true, true, s.ig).ListExternalImports()
deps, err := s.intersectConstraintsWithImports(mdeps, reach)
if err != nil {
@@ -472,8 +478,8 @@
for _, dep := range deps {
// If we have no lock, or if this dep isn't in the lock, then prefetch
- // it. See explanation longer comment in selectRoot() for how we benefit
- // from parallelism here.
+ // it. See longer explanation in selectRoot() for how we benefit from
+ // parallelism here.
if _, has := s.rlm[dep.Ident.ProjectRoot]; !has {
go s.b.SyncSourceFor(dep.Ident)
}
@@ -490,7 +496,7 @@
func (s *solver) getImportsAndConstraintsOf(a atomWithPackages) ([]completeDep, error) {
var err error
- if s.params.ImportRoot == a.a.id.ProjectRoot {
+ if ProjectRoot(s.rpt.ImportRoot) == a.a.id.ProjectRoot {
panic("Should never need to recheck imports/constraints from root during solve")
}
@@ -625,7 +631,7 @@
func (s *solver) createVersionQueue(bmi bimodalIdentifier) (*versionQueue, error) {
id := bmi.id
// If on the root package, there's no queue to make
- if s.params.ImportRoot == id.ProjectRoot {
+ if ProjectRoot(s.rpt.ImportRoot) == id.ProjectRoot {
return newVersionQueue(id, nil, nil, s.b)
}
@@ -665,7 +671,7 @@
// TODO(sdboyer) nested loop; prime candidate for a cache somewhere
for _, dep := range s.sel.getDependenciesOn(bmi.id) {
// Skip the root, of course
- if s.params.ImportRoot == dep.depender.id.ProjectRoot {
+ if ProjectRoot(s.rpt.ImportRoot) == dep.depender.id.ProjectRoot {
continue
}
@@ -1023,7 +1029,7 @@
// selection?
// skip if the root project
- if s.params.ImportRoot != id.ProjectRoot {
+ if ProjectRoot(s.rpt.ImportRoot) != id.ProjectRoot {
// just look for the first (oldest) one; the backtracker will necessarily
// traverse through and pop off any earlier ones
for _, vq := range s.vqs {
diff --git a/vendor/github.com/sdboyer/gps/source.go b/vendor/github.com/sdboyer/gps/source.go
index 6256c51..75265d9 100644
--- a/vendor/github.com/sdboyer/gps/source.go
+++ b/vendor/github.com/sdboyer/gps/source.go
@@ -335,7 +335,7 @@
err = bs.crepo.r.UpdateVersion(v.String())
}
- ptree, err = listPackages(bs.crepo.r.LocalPath(), string(pr))
+ ptree, err = ListPackages(bs.crepo.r.LocalPath(), string(pr))
bs.crepo.mut.Unlock()
// TODO(sdboyer) cache errs?
diff --git a/vendor/github.com/sdboyer/gps/trace.go b/vendor/github.com/sdboyer/gps/trace.go
index 4c20279..e08dcf7 100644
--- a/vendor/github.com/sdboyer/gps/trace.go
+++ b/vendor/github.com/sdboyer/gps/trace.go
@@ -109,7 +109,7 @@
// so who cares
rm := ptree.ExternalReach(true, true, s.ig)
- s.tl.Printf("Root project is %q", s.params.ImportRoot)
+ s.tl.Printf("Root project is %q", s.rpt.ImportRoot)
var expkgs int
for _, cdep := range cdeps {
diff --git a/vendor/github.com/sdboyer/gps/vcs_source.go b/vendor/github.com/sdboyer/gps/vcs_source.go
index 277b1db..ecded0c 100644
--- a/vendor/github.com/sdboyer/gps/vcs_source.go
+++ b/vendor/github.com/sdboyer/gps/vcs_source.go
@@ -54,9 +54,10 @@
if rv, ok := v.(PairedVersion); ok {
vstr = rv.Underlying().String()
}
- _, err = r.RunFromDir("git", "read-tree", vstr)
+
+ out, err := r.RunFromDir("git", "read-tree", vstr)
if err != nil {
- return err
+ return fmt.Errorf("%s: %s", out, err)
}
// Ensure we have exactly one trailing slash
@@ -68,8 +69,11 @@
// the alternative is using plain checkout, though we have a bunch of
// housekeeping to do to set up, then tear down, the sparse checkout
// controls, as well as restore the original index and HEAD.
- _, err = r.RunFromDir("git", "checkout-index", "-a", "--prefix="+to)
- return err
+ out, err = r.RunFromDir("git", "checkout-index", "-a", "--prefix="+to)
+ if err != nil {
+ return fmt.Errorf("%s: %s", out, err)
+ }
+ return nil
}
func (s *gitSource) listVersions() (vlist []Version, err error) {
diff --git a/vendor/github.com/sdboyer/gps/version.go b/vendor/github.com/sdboyer/gps/version.go
index 1e15029..f288b2a 100644
--- a/vendor/github.com/sdboyer/gps/version.go
+++ b/vendor/github.com/sdboyer/gps/version.go
@@ -411,11 +411,7 @@
}
switch tv := v.v.(type) {
- case plainVersion:
- if tv.Matches(v2) {
- return true
- }
- case branchVersion:
+ case plainVersion, branchVersion:
if tv.Matches(v2) {
return true
}
@@ -491,22 +487,23 @@
case branchVersion, plainVersion, semVersion:
return 1
}
- case branchVersion:
- switch r.(type) {
- case Revision:
- return -1
- case branchVersion:
- return 0
- case plainVersion, semVersion:
- return 1
- }
case plainVersion:
switch r.(type) {
- case Revision, branchVersion:
+ case Revision:
return -1
case plainVersion:
return 0
+ case branchVersion, semVersion:
+ return 1
+ }
+
+ case branchVersion:
+ switch r.(type) {
+ case Revision, plainVersion:
+ return -1
+ case branchVersion:
+ return 0
case semVersion:
return 1
}
@@ -531,9 +528,9 @@
// - Semver versions with a prerelease are after *all* non-prerelease semver.
// Against each other, they are sorted first by their numerical component, then
// lexicographically by their prerelease version.
+// - All branches are next, and sort lexicographically against each other.
// - All non-semver versions (tags) are next, and sort lexicographically
// against each other.
-// - All branches are next, and sort lexicographically against each other.
// - Revisions are last, and sort lexicographically against each other.
//
// So, given a slice of the following versions:
@@ -553,14 +550,15 @@
// SortForDowngrade sorts a slice of []Version in roughly ascending order, so
// that presumably older versions are visited first.
//
-// This is *not* the reverse of the same as SortForUpgrade (or you could simply
-// sort.Reverse(). The type precedence is the same, including the
-// semver vs. semver-with-prerelease relation. Lexicographic comparisons within
-// non-semver tags, branches, and revisions remains the same as well; because
-// these domains have no implicit chronology, there is no reason to reverse
+// This is *not* the same as reversing SortForUpgrade (or you could simply
+// sort.Reverse()). The type precedence is the same, including the semver vs.
+// semver-with-prerelease relation. Lexicographic comparisons within non-semver
+// tags, branches, and revisions remains the same as well; because we treat
+// these domains as having no ordering relations (chronology), there can be no
+// real concept of "upgrade" vs "downgrade", so there is no reason to reverse
// them.
//
-// The only binary relation that is reversed for downgrade is within-type
+// Thus, the only binary relation that is reversed for downgrade is within-type
// comparisons for semver (with and without prerelease).
//
// So, given a slice of the following versions:
diff --git a/vendor/github.com/sdboyer/gps/version_test.go b/vendor/github.com/sdboyer/gps/version_test.go
index 436dbe4..394bb27 100644
--- a/vendor/github.com/sdboyer/gps/version_test.go
+++ b/vendor/github.com/sdboyer/gps/version_test.go
@@ -32,15 +32,15 @@
edown := []Version{
v3, v4, v5, // semvers
- v6, v8, // plain versions
v1, v2, v7, // floating/branches
+ v6, v8, // plain versions
rev, // revs
}
eup := []Version{
v5, v4, v3, // semvers
- v6, v8, // plain versions
v1, v2, v7, // floating/branches
+ v6, v8, // plain versions
rev, // revs
}
diff --git a/vendor/gopkg.in/yaml.v2/LICENSE b/vendor/gopkg.in/yaml.v2/LICENSE
index a68e67f..866d74a 100644
--- a/vendor/gopkg.in/yaml.v2/LICENSE
+++ b/vendor/gopkg.in/yaml.v2/LICENSE
@@ -1,188 +1,13 @@
+Copyright 2011-2016 Canonical Ltd.
-Copyright (c) 2011-2014 - Canonical Inc.
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
-This software is licensed under the LGPLv3, included below.
+ http://www.apache.org/licenses/LICENSE-2.0
-As a special exception to the GNU Lesser General Public License version 3
-("LGPL3"), the copyright holders of this Library give you permission to
-convey to a third party a Combined Work that links statically or dynamically
-to this Library without providing any Minimal Corresponding Source or
-Minimal Application Code as set out in 4d or providing the installation
-information set out in section 4e, provided that you comply with the other
-provisions of LGPL3 and provided that you meet, for the Application the
-terms and conditions of the license(s) which apply to the Application.
-
-Except as stated in this special exception, the provisions of LGPL3 will
-continue to comply in full to this Library. If you modify this Library, you
-may apply this exception to your version of this Library, but you are not
-obliged to do so. If you do not wish to do so, delete this exception
-statement from your version. This exception does not (and cannot) modify any
-license terms which apply to the Application, with which you must still
-comply.
-
-
- GNU LESSER GENERAL PUBLIC LICENSE
- Version 3, 29 June 2007
-
- Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-
- This version of the GNU Lesser General Public License incorporates
-the terms and conditions of version 3 of the GNU General Public
-License, supplemented by the additional permissions listed below.
-
- 0. Additional Definitions.
-
- As used herein, "this License" refers to version 3 of the GNU Lesser
-General Public License, and the "GNU GPL" refers to version 3 of the GNU
-General Public License.
-
- "The Library" refers to a covered work governed by this License,
-other than an Application or a Combined Work as defined below.
-
- An "Application" is any work that makes use of an interface provided
-by the Library, but which is not otherwise based on the Library.
-Defining a subclass of a class defined by the Library is deemed a mode
-of using an interface provided by the Library.
-
- A "Combined Work" is a work produced by combining or linking an
-Application with the Library. The particular version of the Library
-with which the Combined Work was made is also called the "Linked
-Version".
-
- The "Minimal Corresponding Source" for a Combined Work means the
-Corresponding Source for the Combined Work, excluding any source code
-for portions of the Combined Work that, considered in isolation, are
-based on the Application, and not on the Linked Version.
-
- The "Corresponding Application Code" for a Combined Work means the
-object code and/or source code for the Application, including any data
-and utility programs needed for reproducing the Combined Work from the
-Application, but excluding the System Libraries of the Combined Work.
-
- 1. Exception to Section 3 of the GNU GPL.
-
- You may convey a covered work under sections 3 and 4 of this License
-without being bound by section 3 of the GNU GPL.
-
- 2. Conveying Modified Versions.
-
- If you modify a copy of the Library, and, in your modifications, a
-facility refers to a function or data to be supplied by an Application
-that uses the facility (other than as an argument passed when the
-facility is invoked), then you may convey a copy of the modified
-version:
-
- a) under this License, provided that you make a good faith effort to
- ensure that, in the event an Application does not supply the
- function or data, the facility still operates, and performs
- whatever part of its purpose remains meaningful, or
-
- b) under the GNU GPL, with none of the additional permissions of
- this License applicable to that copy.
-
- 3. Object Code Incorporating Material from Library Header Files.
-
- The object code form of an Application may incorporate material from
-a header file that is part of the Library. You may convey such object
-code under terms of your choice, provided that, if the incorporated
-material is not limited to numerical parameters, data structure
-layouts and accessors, or small macros, inline functions and templates
-(ten or fewer lines in length), you do both of the following:
-
- a) Give prominent notice with each copy of the object code that the
- Library is used in it and that the Library and its use are
- covered by this License.
-
- b) Accompany the object code with a copy of the GNU GPL and this license
- document.
-
- 4. Combined Works.
-
- You may convey a Combined Work under terms of your choice that,
-taken together, effectively do not restrict modification of the
-portions of the Library contained in the Combined Work and reverse
-engineering for debugging such modifications, if you also do each of
-the following:
-
- a) Give prominent notice with each copy of the Combined Work that
- the Library is used in it and that the Library and its use are
- covered by this License.
-
- b) Accompany the Combined Work with a copy of the GNU GPL and this license
- document.
-
- c) For a Combined Work that displays copyright notices during
- execution, include the copyright notice for the Library among
- these notices, as well as a reference directing the user to the
- copies of the GNU GPL and this license document.
-
- d) Do one of the following:
-
- 0) Convey the Minimal Corresponding Source under the terms of this
- License, and the Corresponding Application Code in a form
- suitable for, and under terms that permit, the user to
- recombine or relink the Application with a modified version of
- the Linked Version to produce a modified Combined Work, in the
- manner specified by section 6 of the GNU GPL for conveying
- Corresponding Source.
-
- 1) Use a suitable shared library mechanism for linking with the
- Library. A suitable mechanism is one that (a) uses at run time
- a copy of the Library already present on the user's computer
- system, and (b) will operate properly with a modified version
- of the Library that is interface-compatible with the Linked
- Version.
-
- e) Provide Installation Information, but only if you would otherwise
- be required to provide such information under section 6 of the
- GNU GPL, and only to the extent that such information is
- necessary to install and execute a modified version of the
- Combined Work produced by recombining or relinking the
- Application with a modified version of the Linked Version. (If
- you use option 4d0, the Installation Information must accompany
- the Minimal Corresponding Source and Corresponding Application
- Code. If you use option 4d1, you must provide the Installation
- Information in the manner specified by section 6 of the GNU GPL
- for conveying Corresponding Source.)
-
- 5. Combined Libraries.
-
- You may place library facilities that are a work based on the
-Library side by side in a single library together with other library
-facilities that are not Applications and are not covered by this
-License, and convey such a combined library under terms of your
-choice, if you do both of the following:
-
- a) Accompany the combined library with a copy of the same work based
- on the Library, uncombined with any other library facilities,
- conveyed under the terms of this License.
-
- b) Give prominent notice with the combined library that part of it
- is a work based on the Library, and explaining where to find the
- accompanying uncombined form of the same work.
-
- 6. Revised Versions of the GNU Lesser General Public License.
-
- The Free Software Foundation may publish revised and/or new versions
-of the GNU Lesser General Public License from time to time. Such new
-versions will be similar in spirit to the present version, but may
-differ in detail to address new problems or concerns.
-
- Each version is given a distinguishing version number. If the
-Library as you received it specifies that a certain numbered version
-of the GNU Lesser General Public License "or any later version"
-applies to it, you have the option of following the terms and
-conditions either of that published version or of any later version
-published by the Free Software Foundation. If the Library as you
-received it does not specify a version number of the GNU Lesser
-General Public License, you may choose any version of the GNU Lesser
-General Public License ever published by the Free Software Foundation.
-
- If the Library as you received it specifies that a proxy can decide
-whether future versions of the GNU Lesser General Public License shall
-apply, that proxy's public statement of acceptance of any version is
-permanent authorization for you to choose that version for the
-Library.
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/vendor/gopkg.in/yaml.v2/README.md b/vendor/gopkg.in/yaml.v2/README.md
index 7b8bd86..1884de6 100644
--- a/vendor/gopkg.in/yaml.v2/README.md
+++ b/vendor/gopkg.in/yaml.v2/README.md
@@ -42,7 +42,7 @@
License
-------
-The yaml package is licensed under the LGPL with an exception that allows it to be linked statically. Please see the LICENSE file for details.
+The yaml package is licensed under the Apache License 2.0. Please see the LICENSE file for details.
Example
