Catch back up to master again
diff --git a/action/create.go b/action/create.go
index 5d42199..e44e2fe 100644
--- a/action/create.go
+++ b/action/create.go
@@ -85,7 +85,7 @@
config := new(cfg.Config)
// Get the name of the top level package
- config.Name = name
+ config.ProjectRoot = name
// Import by looking at other package managers and looking over the
// entire directory structure.
@@ -131,7 +131,7 @@
n := strings.TrimPrefix(pa, vpath)
root, subpkg := util.NormalizeName(n)
- if !config.Imports.Has(root) && root != config.Name {
+ if !config.Imports.Has(root) && root != config.ProjectRoot {
msg.Info("--> Found reference to %s\n", n)
d := &cfg.Dependency{
Name: root,
@@ -156,9 +156,9 @@
n := strings.TrimPrefix(pa, vpath)
root, subpkg := util.NormalizeName(n)
- if config.Imports.Has(root) && root != config.Name {
+ if config.Imports.Has(root) && root != config.ProjectRoot {
msg.Debug("--> Found test reference to %s already listed as an import", n)
- } else if !config.DevImports.Has(root) && root != config.Name {
+ } else if !config.DevImports.Has(root) && root != config.ProjectRoot {
msg.Info("--> Found test reference to %s", n)
d := &cfg.Dependency{
Name: root,
diff --git a/action/ensure.go b/action/ensure.go
index 2f5f5af..43f2df9 100644
--- a/action/ensure.go
+++ b/action/ensure.go
@@ -48,8 +48,8 @@
b, err = filepath.Rel(b, cwd)
if err == nil {
name := buildContext.PackageName(b)
- if name != conf.Name {
- msg.Warn("The name listed in the config file (%s) does not match the current location (%s)", conf.Name, name)
+ if name != conf.ProjectRoot {
+ msg.Warn("The name listed in the config file (%s) does not match the current location (%s)", conf.ProjectRoot, name)
}
} else {
msg.Warn("Problem finding the config file path (%s) relative to the current directory (%s): %s", b, cwd, err)
diff --git a/action/get.go b/action/get.go
index 009d90d..8b29cdb 100644
--- a/action/get.go
+++ b/action/get.go
@@ -2,111 +2,112 @@
import (
"fmt"
+ "log"
+ "os"
"path/filepath"
"strings"
"github.com/Masterminds/glide/cache"
"github.com/Masterminds/glide/cfg"
- "github.com/Masterminds/glide/godep"
+ "github.com/Masterminds/glide/dependency"
"github.com/Masterminds/glide/msg"
gpath "github.com/Masterminds/glide/path"
"github.com/Masterminds/glide/repo"
"github.com/Masterminds/glide/util"
"github.com/Masterminds/semver"
+ "github.com/sdboyer/gps"
)
// Get fetches one or more dependencies and installs.
//
-// This includes resolving dependency resolution and re-generating the lock file.
-func Get(names []string, installer *repo.Installer, insecure, skipRecursive, strip, stripVendor, nonInteract, testDeps bool) {
- if installer.UseCache {
- cache.SystemLock()
- }
-
+// This includes a solver run and re-generating the lock file.
+func Get(names []string, installer *repo.Installer, stripVendor, nonInteract bool) {
base := gpath.Basepath()
EnsureGopath()
EnsureVendorDir()
conf := EnsureConfig()
+
glidefile, err := gpath.Glide()
if err != nil {
msg.Die("Could not find Glide file: %s", err)
}
+ vend, err := gpath.Vendor()
+ if err != nil {
+ msg.Die("Could not find the vendor dir: %s", err)
+ }
+
+ params := gps.SolveParameters{
+ RootDir: filepath.Dir(glidefile),
+ ImportRoot: gps.ProjectRoot(conf.ProjectRoot),
+ Manifest: conf,
+ Ignore: conf.Ignore,
+ Trace: true,
+ TraceLogger: log.New(os.Stdout, "", 0),
+ }
+
+ // We load the lock file early and bail out if there's a problem, because we
+ // don't want a get to just update all deps without the user explictly
+ // making that choice.
+ if gpath.HasLock(base) {
+ params.Lock, err = loadLockfile(base, conf)
+ if err != nil {
+ msg.Err("Could not load lockfile; aborting get. Existing dependency versions cannot be safely preserved without a lock file. Error was: %s", err)
+ return
+ }
+ }
+
+ // Create the SourceManager for this run
+ sm, err := gps.NewSourceManager(dependency.Analyzer{}, filepath.Join(installer.Home, "cache"), false)
+ defer sm.Release()
+ if err != nil {
+ msg.Err(err.Error())
+ return
+ }
+
+ // Now, with the easy/fast errors out of the way, dive into adding the new
+ // deps to the manifest.
+
// Add the packages to the config.
- if count, err2 := addPkgsToConfig(conf, names, insecure, nonInteract, testDeps); err2 != nil {
+ //if count, err2 := addPkgsToConfig(conf, names, insecure, nonInteract, testDeps); err2 != nil {
+ if count, err2 := addPkgsToConfig(conf, names, false, nonInteract, false); err2 != nil {
msg.Die("Failed to get new packages: %s", err2)
} else if count == 0 {
msg.Warn("Nothing to do")
return
}
- // Fetch the new packages. Can't resolve versions via installer.Update if
- // get is called while the vendor/ directory is empty so we checkout
- // everything.
- err = installer.Checkout(conf)
+ // Prepare a solver. This validates our params.
+ s, err := gps.Prepare(params, sm)
if err != nil {
- msg.Die("Failed to checkout packages: %s", err)
+ msg.Err("Aborted get - could not set up solver to reconcile dependencies: %s", err)
+ return
}
- // Prior to resolving dependencies we need to start working with a clone
- // of the conf because we'll be making real changes to it.
- confcopy := conf.Clone()
-
- if !skipRecursive {
- // Get all repos and update them.
- // TODO: Can we streamline this in any way? The reason that we update all
- // of the dependencies is that we need to re-negotiate versions. For example,
- // if an existing dependency has the constraint >1.0 and this new package
- // adds the constraint <2.0, then this may re-resolve the existing dependency
- // to be between 1.0 and 2.0. But changing that dependency may then result
- // in that dependency's dependencies changing... so we sorta do the whole
- // thing to be safe.
- err = installer.Update(confcopy)
- if err != nil {
- msg.Die("Could not update packages: %s", err)
- }
+ r, err := s.Solve()
+ if err != nil {
+ // TODO better error handling
+ msg.Err("Failed to find a solution for all new dependencies: %s", err.Error())
+ return
}
- // Set Reference
- if err := repo.SetReference(confcopy, installer.ResolveTest); err != nil {
- msg.Err("Failed to set references: %s", err)
+ // Solve succeeded. Write out the yaml, lock, and vendor to a tmpdir, then mv
+ // them all into place iff all the writes worked
+
+ gw := safeGroupWriter{
+ conf: conf,
+ lock: params.Lock.(*cfg.Lockfile),
+ resultLock: r,
+ sm: sm,
+ glidefile: glidefile,
+ vendor: vend,
+ stripVendor: stripVendor,
}
- // VendoredCleanup
- // When stripping VCS happens this will happen as well. No need for double
- // effort.
- if installer.UpdateVendored && !strip {
- repo.VendoredCleanup(confcopy)
- }
-
- // Write YAML
- if err := conf.WriteFile(glidefile); err != nil {
- msg.Die("Failed to write glide YAML file: %s", err)
- }
- if !skipRecursive {
- // Write lock
- if stripVendor {
- confcopy = godep.RemoveGodepSubpackages(confcopy)
- }
- writeLock(conf, confcopy, base)
- } else {
- msg.Warn("Skipping lockfile generation because full dependency tree is not being calculated")
- }
-
- if strip {
- msg.Info("Removing version control data from vendor directory...")
- err := gpath.StripVcs()
- if err != nil {
- msg.Err("Unable to strip version control data: %s", err)
- }
- }
-
- if stripVendor {
- msg.Info("Removing nested vendor and Godeps/_workspace directories...")
- err := gpath.StripVendor()
- if err != nil {
- msg.Err("Unable to strip vendor directories: %s", err)
- }
+ err = gw.writeAllSafe()
+ if err != nil {
+ msg.Err(err.Error())
+ return
}
}
@@ -134,7 +135,7 @@
// - sets up insecure repo URLs where necessary
// - generates a list of subpackages
func addPkgsToConfig(conf *cfg.Config, names []string, insecure, nonInteract, testDeps bool) (int, error) {
-
+ // TODO refactor this to take and use a gps.SourceManager
if len(names) == 1 {
msg.Info("Preparing to install %d package.", len(names))
} else {
@@ -201,7 +202,8 @@
}
dep := &cfg.Dependency{
- Name: root,
+ Name: root,
+ Constraint: gps.Any(),
}
// When retriving from an insecure location set the repo to the
diff --git a/action/install.go b/action/install.go
index b1566a2..c10f5d3 100644
--- a/action/install.go
+++ b/action/install.go
@@ -1,87 +1,349 @@
package action
import (
+ "bytes"
+ "fmt"
+ "io/ioutil"
+ "log"
+ "os"
"path/filepath"
- "github.com/Masterminds/glide/cache"
"github.com/Masterminds/glide/cfg"
"github.com/Masterminds/glide/dependency"
"github.com/Masterminds/glide/msg"
gpath "github.com/Masterminds/glide/path"
"github.com/Masterminds/glide/repo"
+ "github.com/sdboyer/gps"
)
// Install installs a vendor directory based on an existing Glide configuration.
-func Install(installer *repo.Installer, strip, stripVendor bool) {
- if installer.UseCache {
- cache.SystemLock()
- }
-
+func Install(installer *repo.Installer, io, so, sv bool) {
base := "."
// Ensure GOPATH
EnsureGopath()
EnsureVendorDir()
conf := EnsureConfig()
- // Lockfile exists
- if !gpath.HasLock(base) {
- msg.Info("Lock file (glide.lock) does not exist. Performing update.")
- Update(installer, false, strip, stripVendor)
+ // TODO might need a better way for discovering the root
+ vend, err := gpath.Vendor()
+ if err != nil {
+ msg.Die("Could not find the vendor dir: %s", err)
+ }
+
+ // Create the SourceManager for this run
+ sm, err := gps.NewSourceManager(dependency.Analyzer{}, filepath.Join(installer.Home, "cache"), false)
+ defer sm.Release()
+ if err != nil {
+ msg.Err(err.Error())
return
}
- // Load lockfile
- lock, err := cfg.ReadLockFile(filepath.Join(base, gpath.LockFile))
- if err != nil {
- msg.Die("Could not load lockfile.")
- }
- // Verify lockfile hasn't changed
- hash, err := conf.Hash()
- if err != nil {
- msg.Die("Could not load lockfile.")
- } else if hash != lock.Hash {
- msg.Warn("Lock file may be out of date. Hash check of YAML failed. You may need to run 'update'")
+
+ params := gps.SolveParameters{
+ RootDir: filepath.Dir(vend),
+ ImportRoot: gps.ProjectRoot(conf.ProjectRoot),
+ Manifest: conf,
+ Ignore: conf.Ignore,
+ Trace: true,
+ TraceLogger: log.New(os.Stdout, "", 0),
}
- // Install
- newConf, err := installer.Install(lock, conf)
- if err != nil {
- msg.Die("Failed to install: %s", err)
- }
-
- msg.Info("Setting references.")
-
- // Set reference
- if err := repo.SetReference(newConf, installer.ResolveTest); err != nil {
- msg.Err("Failed to set references: %s (Skip to cleanup)", err)
- }
-
- // Delete unused packages
- if installer.DeleteUnused {
- // newConf is calculated based on the lock file so it should be
- // accurate to the project list.
- dependency.DeleteUnused(newConf)
- }
-
- // VendoredCleanup. This should ONLY be run if UpdateVendored was specified.
- // When stripping VCS happens this will happen as well. No need for double
- // effort.
- if installer.UpdateVendored && !strip {
- repo.VendoredCleanup(newConf)
- }
-
- if strip {
- msg.Info("Removing version control data from vendor directory...")
- err := gpath.StripVcs()
+ var s gps.Solver
+ if gpath.HasLock(base) {
+ params.Lock, err = loadLockfile(base, conf)
if err != nil {
- msg.Err("Unable to strip version control data: %s", err)
+ msg.Err("Could not load lockfile.")
+ return
+ }
+
+ s, err = gps.Prepare(params, sm)
+ if err != nil {
+ msg.Err("Could not set up solver: %s", err)
+ return
+ }
+ digest, err := s.HashInputs()
+
+ // Check if digests match, and warn if they don't
+ if bytes.Equal(digest, params.Lock.InputHash()) {
+ if so {
+ msg.Err("glide.yaml is out of sync with glide.lock")
+ return
+ } else {
+ msg.Warn("glide.yaml is out of sync with glide.lock!")
+ }
+ }
+
+ gw := safeGroupWriter{
+ resultLock: params.Lock,
+ vendor: vend,
+ sm: sm,
+ stripVendor: sv,
+ }
+
+ err = gw.writeAllSafe()
+ if err != nil {
+ msg.Err(err.Error())
+ return
+ }
+ } else if io || so {
+ msg.Err("No glide.lock file could be found.")
+ return
+ } else {
+ // There is no lock, so we have to solve first
+ s, err = gps.Prepare(params, sm)
+ if err != nil {
+ msg.Err("Could not set up solver: %s", err)
+ return
+ }
+
+ r, err := s.Solve()
+ if err != nil {
+ // TODO better error handling
+ msg.Err(err.Error())
+ return
+ }
+
+ gw := safeGroupWriter{
+ resultLock: r,
+ vendor: vend,
+ sm: sm,
+ stripVendor: sv,
+ }
+
+ err = gw.writeAllSafe()
+ if err != nil {
+ msg.Err(err.Error())
+ return
+ }
+ }
+}
+
+// locksAreEquivalent compares the fingerprints between two locks to determine
+// if they're equivalent.
+//
+// If the either of the locks are nil, the input hashes are different, the
+// fingerprints are different, or any error is returned from fingerprinting,
+// this function returns false.
+func locksAreEquivalent(l1, l2 *cfg.Lockfile) bool {
+ if l1 != nil && l2 != nil {
+ if l1.Hash != l2.Hash {
+ return false
+ }
+
+ f1, err := l1.Fingerprint()
+ f2, err2 := l2.Fingerprint()
+ if err == nil && err2 == nil && f1 == f2 {
+ return true
+ }
+ }
+ return false
+}
+
+// safeGroupWriter provides a slipshod-but-better-than-nothing approach to
+// grouping together yaml, lock, and vendor dir writes.
+type safeGroupWriter struct {
+ conf *cfg.Config
+ lock *cfg.Lockfile
+ resultLock gps.Lock
+ sm gps.SourceManager
+ glidefile, vendor string
+ stripVendor bool
+}
+
+// writeAllSafe writes out some combination of config yaml, lock, and a vendor
+// tree, to a temp dir, then moves them into place if and only if all the write
+// operations succeeded. It also does its best to roll back if any moves fail.
+//
+// This helps to ensure glide doesn't exit with a partial write, resulting in an
+// undefined disk state.
+//
+// - If a gw.conf is provided, it will be written to gw.glidefile
+// - If gw.lock is provided without a gw.resultLock, it will be written to
+// `glide.lock` in the parent dir of gw.vendor
+// - If gw.lock and gw.resultLock are both provided and are not equivalent,
+// the resultLock will be written to the same location as above, and a vendor
+// tree will be written to gw.vendor
+// - If gw.resultLock is provided and gw.lock is not, it will write both a lock
+// and vendor dir in the same way
+//
+// Any of the conf, lock, or result can be omitted; the grouped write operation
+// will continue for whichever inputs are present.
+func (gw safeGroupWriter) writeAllSafe() error {
+ // Decide which writes we need to do
+ var writeConf, writeLock, writeVendor bool
+
+ if gw.conf != nil {
+ writeConf = true
+ }
+
+ if gw.resultLock != nil {
+ if gw.lock == nil {
+ writeLock, writeVendor = true, true
+ } else {
+ rlf := cfg.LockfileFromSolverLock(gw.resultLock)
+ if !locksAreEquivalent(rlf, gw.lock) {
+ writeLock, writeVendor = true, true
+ }
+ }
+ } else if gw.lock != nil {
+ writeLock = true
+ }
+
+ if !writeConf && !writeLock && !writeVendor {
+ // nothing to do
+ return nil
+ }
+
+ if writeConf && gw.glidefile == "" {
+ return fmt.Errorf("Must provide a path if writing out a config yaml.")
+ }
+
+ if (writeLock || writeVendor) && gw.vendor == "" {
+ return fmt.Errorf("Must provide a vendor dir if writing out a lock or vendor dir.")
+ }
+
+ if writeVendor && gw.sm == nil {
+ return fmt.Errorf("Must provide a SourceManager if writing out a vendor dir.")
+ }
+
+ td, err := ioutil.TempDir(os.TempDir(), "glide")
+ if err != nil {
+ return fmt.Errorf("Error while creating temp dir for vendor directory: %s", err)
+ }
+ defer os.RemoveAll(td)
+
+ if writeConf {
+ if err := gw.conf.WriteFile(filepath.Join(td, "glide.yaml")); err != nil {
+ return fmt.Errorf("Failed to write glide YAML file: %s", err)
}
}
- if stripVendor {
- msg.Info("Removing nested vendor and Godeps/_workspace directories...")
- err := gpath.StripVendor()
- if err != nil {
- msg.Err("Unable to strip vendor directories: %s", err)
+ if writeLock {
+ if gw.resultLock == nil {
+ // the result lock is nil but the flag is on, so we must be writing
+ // the other one
+ if err := gw.lock.WriteFile(filepath.Join(td, gpath.LockFile)); err != nil {
+ return fmt.Errorf("Failed to write glide lock file: %s", err)
+ }
+ } else {
+ rlf := cfg.LockfileFromSolverLock(gw.resultLock)
+ if err := rlf.WriteFile(filepath.Join(td, gpath.LockFile)); err != nil {
+ return fmt.Errorf("Failed to write glide lock file: %s", err)
+ }
}
}
+
+ if writeVendor {
+ err = gps.CreateVendorTree(filepath.Join(td, "vendor"), gw.resultLock, gw.sm, gw.stripVendor)
+ if err != nil {
+ return fmt.Errorf("Error while generating vendor tree: %s", err)
+ }
+ }
+
+ // Move the existing files and dirs to the temp dir while we put the new
+ // ones in, to provide insurance against errors for as long as possible
+ var fail bool
+ var failerr error
+ type pathpair struct {
+ from, to string
+ }
+ var restore []pathpair
+
+ if writeConf {
+ if _, err := os.Stat(gw.glidefile); err == nil {
+ // move out the old one
+ tmploc := filepath.Join(td, "glide.yaml-old")
+ failerr = os.Rename(gw.glidefile, tmploc)
+ if failerr != nil {
+ fail = true
+ } else {
+ restore = append(restore, pathpair{from: tmploc, to: gw.glidefile})
+ }
+ }
+
+ // move in the new one
+ failerr = os.Rename(filepath.Join(td, "glide.yaml"), gw.glidefile)
+ if failerr != nil {
+ fail = true
+ }
+ }
+
+ if !fail && writeLock {
+ tgt := filepath.Join(filepath.Dir(gw.vendor), gpath.LockFile)
+ if _, err := os.Stat(tgt); err == nil {
+ // move out the old one
+ tmploc := filepath.Join(td, "glide.lock-old")
+
+ failerr = os.Rename(tgt, tmploc)
+ if failerr != nil {
+ fail = true
+ } else {
+ restore = append(restore, pathpair{from: tmploc, to: tgt})
+ }
+ }
+
+ // move in the new one
+ failerr = os.Rename(filepath.Join(td, gpath.LockFile), tgt)
+ if failerr != nil {
+ fail = true
+ }
+ }
+
+ // have to declare out here so it's present later
+ var vendorbak string
+ if !fail && writeVendor {
+ if _, err := os.Stat(gw.vendor); err == nil {
+ // move out the old vendor dir. just do it into an adjacent dir, in
+ // order to mitigate the possibility of a pointless cross-filesystem move
+ vendorbak = gw.vendor + "-old"
+ if _, err := os.Stat(vendorbak); err == nil {
+ // Just in case that happens to exist...
+ vendorbak = filepath.Join(td, "vendor-old")
+ }
+ failerr = os.Rename(gw.vendor, vendorbak)
+ if failerr != nil {
+ fail = true
+ } else {
+ restore = append(restore, pathpair{from: vendorbak, to: gw.vendor})
+ }
+ }
+
+ // move in the new one
+ failerr = os.Rename(filepath.Join(td, "vendor"), gw.vendor)
+ if failerr != nil {
+ fail = true
+ }
+ }
+
+ // If we failed at any point, move all the things back into place, then bail
+ if fail {
+ for _, pair := range restore {
+ // Nothing we can do on err here, we're already in recovery mode
+ os.Rename(pair.from, pair.to)
+ }
+ return failerr
+ }
+
+ // Renames all went smoothly. The deferred os.RemoveAll will get the temp
+ // dir, but if we wrote vendor, we have to clean that up directly
+
+ if writeVendor {
+ // Again, kinda nothing we can do about an error at this point
+ os.RemoveAll(vendorbak)
+ }
+
+ return nil
+}
+
+// loadLockfile loads the contents of a glide.lock file.
+func loadLockfile(base string, conf *cfg.Config) (*cfg.Lockfile, error) {
+ yml, err := ioutil.ReadFile(filepath.Join(base, gpath.LockFile))
+ if err != nil {
+ return nil, err
+ }
+ lock, err := cfg.LockfileFromYaml(yml)
+ if err != nil {
+ return nil, err
+ }
+
+ return lock, nil
}
diff --git a/action/name.go b/action/name.go
index 77972b3..7a67b7c 100644
--- a/action/name.go
+++ b/action/name.go
@@ -7,5 +7,5 @@
// Name prints the name of the package, according to the glide.yaml file.
func Name() {
conf := EnsureConfig()
- msg.Puts(conf.Name)
+ msg.Puts(conf.ProjectRoot)
}
diff --git a/action/project_info.go b/action/project_info.go
index 379026e..b82b41c 100644
--- a/action/project_info.go
+++ b/action/project_info.go
@@ -15,7 +15,7 @@
if varInit {
switch varfmt {
case 'n':
- buffer.WriteString(conf.Name)
+ buffer.WriteString(conf.ProjectRoot)
case 'd':
buffer.WriteString(conf.Description)
case 'h':
diff --git a/action/update.go b/action/update.go
index 9712ebb..c008f98 100644
--- a/action/update.go
+++ b/action/update.go
@@ -1,137 +1,97 @@
package action
import (
- "io/ioutil"
+ "log"
+ "os"
"path/filepath"
- "github.com/Masterminds/glide/cache"
"github.com/Masterminds/glide/cfg"
"github.com/Masterminds/glide/dependency"
- "github.com/Masterminds/glide/godep"
"github.com/Masterminds/glide/msg"
gpath "github.com/Masterminds/glide/path"
"github.com/Masterminds/glide/repo"
+ "github.com/sdboyer/gps"
)
// Update updates repos and the lock file from the main glide yaml.
-func Update(installer *repo.Installer, skipRecursive, strip, stripVendor bool) {
- if installer.UseCache {
- cache.SystemLock()
- }
-
+func Update(installer *repo.Installer, sv bool, projs []string) {
base := "."
EnsureGopath()
EnsureVendorDir()
conf := EnsureConfig()
- // Try to check out the initial dependencies.
- if err := installer.Checkout(conf); err != nil {
- msg.Die("Failed to do initial checkout of config: %s", err)
- }
-
- // Set the versions for the initial dependencies so that resolved dependencies
- // are rooted in the correct version of the base.
- if err := repo.SetReference(conf, installer.ResolveTest); err != nil {
- msg.Die("Failed to set initial config references: %s", err)
- }
-
- // Prior to resolving dependencies we need to start working with a clone
- // of the conf because we'll be making real changes to it.
- confcopy := conf.Clone()
-
- if !skipRecursive {
- // Get all repos and update them.
- err := installer.Update(confcopy)
- if err != nil {
- msg.Die("Could not update packages: %s", err)
- }
-
- // Set references. There may be no remaining references to set since the
- // installer set them as it went to make sure it parsed the right imports
- // from the right version of the package.
- msg.Info("Setting references for remaining imports")
- if err := repo.SetReference(confcopy, installer.ResolveTest); err != nil {
- msg.Err("Failed to set references: %s (Skip to cleanup)", err)
- }
- }
-
- // Delete unused packages
- if installer.DeleteUnused {
- dependency.DeleteUnused(confcopy)
- }
-
- // Vendored cleanup
- // VendoredCleanup. This should ONLY be run if UpdateVendored was specified.
- // When stripping VCS happens this will happen as well. No need for double
- // effort.
- if installer.UpdateVendored && !strip {
- repo.VendoredCleanup(confcopy)
- }
-
- // Write glide.yaml (Why? Godeps/GPM/GB?)
- // I think we don't need to write a new Glide file because update should not
- // change anything important. It will just generate information about
- // transative dependencies, all of which belongs exclusively in the lock
- // file, not the glide.yaml file.
// TODO(mattfarina): Detect when a new dependency has been added or removed
// from the project. A removed dependency should warn and an added dependency
// should be added to the glide.yaml file. See issue #193.
- if stripVendor {
- confcopy = godep.RemoveGodepSubpackages(confcopy)
+ // TODO might need a better way for discovering the root
+ vend, err := gpath.Vendor()
+ if err != nil {
+ msg.Die("Could not find the vendor dir: %s", err)
}
- if !skipRecursive {
- // Write lock
- hash, err := conf.Hash()
- if err != nil {
- msg.Die("Failed to generate config hash. Unable to generate lock file.")
- }
- lock, err := cfg.NewLockfile(confcopy.Imports, confcopy.DevImports, hash)
- if err != nil {
- msg.Die("Failed to generate lock file: %s", err)
- }
- wl := true
- if gpath.HasLock(base) {
- yml, err := ioutil.ReadFile(filepath.Join(base, gpath.LockFile))
- if err == nil {
- l2, err := cfg.LockfileFromYaml(yml)
- if err == nil {
- f1, err := l2.Fingerprint()
- f2, err2 := lock.Fingerprint()
- if err == nil && err2 == nil && f1 == f2 {
- wl = false
- }
- }
- }
- }
- if wl {
- if err := lock.WriteFile(filepath.Join(base, gpath.LockFile)); err != nil {
- msg.Err("Could not write lock file to %s: %s", base, err)
- return
- }
- } else {
- msg.Info("Versions did not change. Skipping glide.lock update.")
- }
+ params := gps.SolveParameters{
+ RootDir: filepath.Dir(vend),
+ ImportRoot: gps.ProjectRoot(conf.ProjectRoot),
+ Manifest: conf,
+ Ignore: conf.Ignore,
+ Trace: true,
+ TraceLogger: log.New(os.Stdout, "", 0),
+ }
- msg.Info("Project relies on %d dependencies.", len(confcopy.Imports))
+ if len(projs) == 0 {
+ params.ChangeAll = true
} else {
- msg.Warn("Skipping lockfile generation because full dependency tree is not being calculated")
- }
-
- if strip {
- msg.Info("Removing version control data from vendor directory...")
- err := gpath.StripVcs()
- if err != nil {
- msg.Err("Unable to strip version control data: %s", err)
+ params.ChangeAll = false
+ for _, p := range projs {
+ if !conf.HasDependency(p) {
+ msg.Die("Cannot update %s, as it is not listed as dependency in glide.yaml.", p)
+ }
+ params.ToChange = append(params.ToChange, gps.ProjectRoot(p))
}
}
- if stripVendor {
- msg.Info("Removing nested vendor and Godeps/_workspace directories...")
- err := gpath.StripVendor()
+ if gpath.HasLock(base) {
+ params.Lock, err = loadLockfile(base, conf)
if err != nil {
- msg.Err("Unable to strip vendor directories: %s", err)
+ msg.Err("Could not load lockfile, aborting: %s", err)
+ return
}
}
+
+ // Create the SourceManager for this run
+ sm, err := gps.NewSourceManager(dependency.Analyzer{}, filepath.Join(installer.Home, "cache"), false)
+ if err != nil {
+ msg.Err(err.Error())
+ return
+ }
+ defer sm.Release()
+
+ // Prepare a solver. This validates our params.
+ s, err := gps.Prepare(params, sm)
+ if err != nil {
+ msg.Err("Could not set up solver: %s", err)
+ return
+ }
+
+ r, err := s.Solve()
+ if err != nil {
+ // TODO better error handling
+ msg.Err(err.Error())
+ return
+ }
+
+ gw := safeGroupWriter{
+ lock: params.Lock.(*cfg.Lockfile),
+ resultLock: r,
+ sm: sm,
+ vendor: vend,
+ stripVendor: sv,
+ }
+
+ err = gw.writeAllSafe()
+ if err != nil {
+ msg.Err(err.Error())
+ return
+ }
}
diff --git a/cfg/config.go b/cfg/config.go
index 115c76d..a9e6930 100644
--- a/cfg/config.go
+++ b/cfg/config.go
@@ -2,6 +2,7 @@
import (
"crypto/sha256"
+ "encoding/hex"
"fmt"
"io/ioutil"
"reflect"
@@ -10,6 +11,7 @@
"github.com/Masterminds/glide/util"
"github.com/Masterminds/vcs"
+ "github.com/sdboyer/gps"
"gopkg.in/yaml.v2"
)
@@ -17,7 +19,7 @@
type Config struct {
// Name is the name of the package or application.
- Name string `yaml:"package"`
+ ProjectRoot string `yaml:"package"`
// Description is a short description for a package, application, or library.
// This description is similar but different to a Go package description as
@@ -56,6 +58,19 @@
}
// A transitive representation of a dependency for importing and exporting to yaml.
+type cf1 struct {
+ Name string `yaml:"package"`
+ Description string `yaml:"description,omitempty"`
+ Home string `yaml:"homepage,omitempty"`
+ License string `yaml:"license,omitempty"`
+ Owners Owners `yaml:"owners,omitempty"`
+ Ignore []string `yaml:"ignore,omitempty"`
+ Exclude []string `yaml:"excludeDirs,omitempty"`
+ Imports Dependencies `yaml:"dependencies"`
+ DevImports Dependencies `yaml:"testdependencies,omitempty"`
+}
+
+// Legacy representation of a glide.yaml file.
type cf struct {
Name string `yaml:"package"`
Description string `yaml:"description,omitempty"`
@@ -90,7 +105,7 @@
if err := unmarshal(&newConfig); err != nil {
return err
}
- c.Name = newConfig.Name
+ c.ProjectRoot = newConfig.Name
c.Description = newConfig.Description
c.Home = newConfig.Home
c.License = newConfig.License
@@ -109,7 +124,7 @@
// MarshalYAML is a hook for gopkg.in/yaml.v2 in the marshaling process
func (c *Config) MarshalYAML() (interface{}, error) {
newConfig := &cf{
- Name: c.Name,
+ Name: c.ProjectRoot,
Description: c.Description,
Home: c.Home,
License: c.License,
@@ -148,6 +163,64 @@
return false
}
+// DependencyConstraints lists all the non-test dependency constraints
+// described in a glide manifest in a way gps will understand.
+func (c *Config) DependencyConstraints() []gps.ProjectConstraint {
+ return depsToVSolver(c.Imports)
+}
+
+// TestDependencyConstraints lists all the test dependency constraints described
+// in a glide manifest in a way gps will understand.
+func (c *Config) TestDependencyConstraints() []gps.ProjectConstraint {
+ return depsToVSolver(c.DevImports)
+}
+
+func depsToVSolver(deps Dependencies) []gps.ProjectConstraint {
+ cp := make([]gps.ProjectConstraint, len(deps))
+ for k, d := range deps {
+ var c gps.Constraint
+ var err error
+
+ // Support both old and new. TODO handle this earlier
+ if d.Constraint != nil {
+ c = d.Constraint
+ } else {
+ // TODO need to differentiate types of constraints so that we don't have
+ // this ambiguity
+ // Try semver first
+ c, err = gps.NewSemverConstraint(d.Reference)
+ if err != nil {
+ // Not a semver constraint. Super crappy heuristic that'll cover hg
+ // and git revs, but not bzr (svn, you say? lol, madame. lol)
+ if len(d.Reference) == 40 {
+ c = gps.Revision(d.Reference)
+ } else {
+ // Otherwise, assume a branch. This also sucks, because it could
+ // very well be a shitty, non-semver tag.
+ c = gps.NewBranch(d.Reference)
+ }
+ }
+ }
+
+ id := gps.ProjectIdentifier{
+ ProjectRoot: gps.ProjectRoot(d.Name),
+ NetworkName: d.Repository,
+ }
+
+ cp[k] = gps.ProjectConstraint{
+ Ident: id,
+ Constraint: c,
+ }
+ }
+
+ return cp
+}
+
+// Name returns the name of the project given in the manifest.
+func (c *Config) Name() gps.ProjectRoot {
+ return gps.ProjectRoot(c.ProjectRoot)
+}
+
// HasIgnore returns true if the given name is listed on the ignore list.
func (c *Config) HasIgnore(name string) bool {
for _, v := range c.Ignore {
@@ -177,7 +250,7 @@
// Clone performs a deep clone of the Config instance
func (c *Config) Clone() *Config {
n := &Config{}
- n.Name = c.Name
+ n.ProjectRoot = c.ProjectRoot
n.Description = c.Description
n.Home = c.Home
n.License = c.License
@@ -218,7 +291,7 @@
// If the name on the config object is part of the imports remove it.
found := -1
for i, dep := range c.Imports {
- if dep.Name == c.Name {
+ if dep.Name == c.ProjectRoot {
found = i
}
}
@@ -228,7 +301,7 @@
found = -1
for i, dep := range c.DevImports {
- if dep.Name == c.Name {
+ if dep.Name == c.ProjectRoot {
found = i
}
}
@@ -368,21 +441,23 @@
// Dependency describes a package that the present package depends upon.
type Dependency struct {
- Name string `yaml:"package"`
- Reference string `yaml:"version,omitempty"`
- Pin string `yaml:"-"`
- Repository string `yaml:"repo,omitempty"`
- VcsType string `yaml:"vcs,omitempty"`
- Subpackages []string `yaml:"subpackages,omitempty"`
- Arch []string `yaml:"arch,omitempty"`
- Os []string `yaml:"os,omitempty"`
- UpdateAsVendored bool `yaml:"-"`
+ Name string `yaml:"package"`
+ Constraint gps.Constraint `yaml:"-"` // TODO temporary, for experimenting; reconcile with other data
+ Reference string `yaml:"version,omitempty"`
+ Pin string `yaml:"-"`
+ Repository string `yaml:"repo,omitempty"`
+ VcsType string `yaml:"vcs,omitempty"`
+ Subpackages []string `yaml:"subpackages,omitempty"`
+ Arch []string `yaml:"arch,omitempty"`
+ Os []string `yaml:"os,omitempty"`
+ UpdateAsVendored bool `yaml:"-"`
}
// A transitive representation of a dependency for importing and exploting to yaml.
type dep struct {
Name string `yaml:"package"`
Reference string `yaml:"version,omitempty"`
+ Branch string `yaml:"branch,omitempty"`
Ref string `yaml:"ref,omitempty"`
Repository string `yaml:"repo,omitempty"`
VcsType string `yaml:"vcs,omitempty"`
@@ -413,16 +488,45 @@
}
d.Name = newDep.Name
d.Reference = newDep.Reference
+
+ if d.Reference == "" && newDep.Ref != "" {
+ d.Reference = newDep.Ref
+ }
+
+ if d.Reference != "" {
+ r := d.Reference
+ // TODO this covers git & hg; bzr and svn (??) need love
+ if len(r) == 40 {
+ if _, err := hex.DecodeString(r); err == nil {
+ d.Constraint = gps.Revision(r)
+ }
+ } else {
+ d.Constraint, err = gps.NewSemverConstraint(r)
+ if err != nil {
+ d.Constraint = gps.NewVersion(r)
+ }
+ }
+
+ if err != nil {
+ return fmt.Errorf("Error on creating constraint for %q from %q: %s", d.Name, r, err)
+ }
+ } else if newDep.Branch != "" {
+ d.Constraint = gps.NewBranch(newDep.Branch)
+
+ if err != nil {
+ return fmt.Errorf("Error on creating constraint for %q from %q: %s", d.Name, newDep.Branch, err)
+ }
+ } else {
+ // TODO this is just for now - need a default branch constraint type
+ d.Constraint = gps.Any()
+ }
+
d.Repository = newDep.Repository
d.VcsType = newDep.VcsType
d.Subpackages = newDep.Subpackages
d.Arch = newDep.Arch
d.Os = newDep.Os
- if d.Reference == "" && newDep.Ref != "" {
- d.Reference = newDep.Ref
- }
-
// Make sure only legitimate VCS are listed.
d.VcsType = filterVcsType(d.VcsType)
@@ -447,9 +551,9 @@
// Make sure we only write the correct vcs type to file
t := filterVcsType(d.VcsType)
+
newDep := &dep{
Name: d.Name,
- Reference: d.Reference,
Repository: d.Repository,
VcsType: t,
Subpackages: d.Subpackages,
@@ -457,6 +561,27 @@
Os: d.Os,
}
+ // Pull out the correct type of constraint
+ if v, ok := d.Constraint.(gps.Version); ok {
+ switch v.Type() {
+ case "any":
+ // Do nothing; nothing here is taken as 'any'
+ case "branch":
+ newDep.Branch = v.String()
+ case "revision", "semver", "version":
+ newDep.Reference = v.String()
+ }
+ } else if gps.IsAny(d.Constraint) {
+ // We do nothing here, as the way any gets represented is with no
+ // constraint information at all
+ // TODO for now, probably until we add first-class 'default branch'
+ } else if d.Constraint != nil {
+ // The only other thing this could really be is a semver range. This
+ // will dump that up appropriately.
+ newDep.Reference = d.Constraint.String()
+ }
+ // Just ignore any other case
+
return newDep, nil
}
@@ -497,6 +622,7 @@
func (d *Dependency) Clone() *Dependency {
return &Dependency{
Name: d.Name,
+ Constraint: d.Constraint,
Reference: d.Reference,
Pin: d.Pin,
Repository: d.Repository,
diff --git a/cfg/config_test.go b/cfg/config_test.go
index 6313ff0..bf6a190 100644
--- a/cfg/config_test.go
+++ b/cfg/config_test.go
@@ -48,8 +48,8 @@
t.Errorf("Unable to Unmarshal config yaml")
}
- if cfg.Name != "fake/testing" {
- t.Errorf("Inaccurate name found %s", cfg.Name)
+ if cfg.ProjectRoot != "fake/testing" {
+ t.Errorf("Inaccurate name found %s", cfg.ProjectRoot)
}
if cfg.Description != "foo bar baz" {
@@ -98,15 +98,15 @@
}
cfg2 := cfg.Clone()
- if cfg2.Name != "fake/testing" {
+ if cfg2.ProjectRoot != "fake/testing" {
t.Error("Config cloning failed")
}
if cfg2.License != "MIT" {
t.Error("Config cloning failed to copy License")
}
- cfg.Name = "foo"
+ cfg.ProjectRoot = "foo"
- if cfg.Name == cfg2.Name {
+ if cfg.ProjectRoot == cfg2.ProjectRoot {
t.Error("Cloning Config name failed")
}
}
@@ -117,7 +117,7 @@
t.Error("ConfigFromYaml failed to parse yaml")
}
- if c.Name != "fake/testing" {
+ if c.ProjectRoot != "fake/testing" {
t.Error("ConfigFromYaml failed to properly parse yaml")
}
}
diff --git a/cfg/lock.go b/cfg/lock.go
index 62d08ef..b822f29 100644
--- a/cfg/lock.go
+++ b/cfg/lock.go
@@ -2,12 +2,16 @@
import (
"crypto/sha256"
+ "encoding/hex"
"fmt"
"io/ioutil"
"sort"
"strings"
"time"
+ "github.com/Masterminds/semver"
+ "github.com/sdboyer/gps"
+
"gopkg.in/yaml.v2"
)
@@ -19,6 +23,42 @@
DevImports Locks `yaml:"testImports"`
}
+// LockfileFromSolverLock transforms a gps.Lock into a glide *Lockfile.
+func LockfileFromSolverLock(r gps.Lock) *Lockfile {
+ if r == nil {
+ return nil
+ }
+
+ // Create and write out a new lock file from the result
+ lf := &Lockfile{
+ Hash: hex.EncodeToString(r.InputHash()),
+ Updated: time.Now(),
+ }
+
+ for _, p := range r.Projects() {
+ pi := p.Ident()
+ l := &Lock{
+ Name: string(pi.ProjectRoot),
+ VcsType: "", // TODO allow this to be extracted from sm
+ }
+
+ if l.Name != pi.NetworkName && pi.NetworkName != "" {
+ l.Repository = pi.NetworkName
+ }
+
+ v := p.Version()
+ if pv, ok := v.(gps.PairedVersion); ok {
+ l.Version = pv.Underlying().String()
+ } else {
+ l.Version = v.String()
+ }
+
+ lf.Imports = append(lf.Imports, l)
+ }
+
+ return lf
+}
+
// LockfileFromYaml returns an instance of Lockfile from YAML
func LockfileFromYaml(yml []byte) (*Lockfile, error) {
lock := &Lockfile{}
@@ -28,6 +68,8 @@
// Marshal converts a Config instance to YAML
func (lf *Lockfile) Marshal() ([]byte, error) {
+ sort.Sort(lf.Imports)
+ sort.Sort(lf.DevImports)
yml, err := yaml.Marshal(&lf)
if err != nil {
return []byte{}, err
@@ -80,6 +122,45 @@
return ioutil.WriteFile(lockpath, o, 0666)
}
+// InputHash returns the hash of the input arguments that resulted in this lock
+// file.
+func (lf *Lockfile) InputHash() []byte {
+ b, err := hex.DecodeString(lf.Hash)
+ if err != nil {
+ return nil
+ }
+ return b
+}
+
+// Projects returns the list of projects enumerated in the lock file.
+func (lf *Lockfile) Projects() []gps.LockedProject {
+ all := append(lf.Imports, lf.DevImports...)
+ lp := make([]gps.LockedProject, len(all))
+
+ for k, l := range all {
+ // TODO guess the version type. ugh
+ var v gps.Version
+
+ // semver first
+ _, err := semver.NewVersion(l.Version)
+ if err == nil {
+ v = gps.NewVersion(l.Version)
+ } else {
+ // Crappy heuristic to cover hg and git, but not bzr. Or (lol) svn
+ if len(l.Version) == 40 {
+ v = gps.Revision(l.Version)
+ } else {
+ // Otherwise, assume it's a branch
+ v = gps.NewBranch(l.Version)
+ }
+ }
+
+ lp[k] = gps.NewLockedProject(gps.ProjectRoot(l.Name), v, l.Repository, nil)
+ }
+
+ return lp
+}
+
// Clone returns a clone of Lockfile
func (lf *Lockfile) Clone() *Lockfile {
n := &Lockfile{}
diff --git a/dependency/analyzer.go b/dependency/analyzer.go
new file mode 100644
index 0000000..e4674fb
--- /dev/null
+++ b/dependency/analyzer.go
@@ -0,0 +1,169 @@
+package dependency
+
+import (
+ "fmt"
+ "io/ioutil"
+ "os"
+ "path/filepath"
+
+ "github.com/Masterminds/glide/cfg"
+ "github.com/Masterminds/glide/gb"
+ "github.com/Masterminds/glide/godep"
+ "github.com/Masterminds/glide/gom"
+ "github.com/Masterminds/glide/gpm"
+ gpath "github.com/Masterminds/glide/path"
+ "github.com/sdboyer/gps"
+)
+
+type notApplicable struct{}
+
+func (notApplicable) Error() string {
+ return ""
+}
+
+// Analyzer implements gps.ProjectAnalyzer. We inject the Analyzer into a
+// gps.SourceManager, and it reports manifest and lock information to the
+// SourceManager on request.
+type Analyzer struct{}
+
+func (a Analyzer) GetInfo(root string, pn gps.ProjectRoot) (gps.Manifest, gps.Lock, error) {
+ // this check should be unnecessary, but keeping it for now as a canary
+ if _, err := os.Lstat(root); err != nil {
+ return nil, nil, fmt.Errorf("No directory exists at %s; cannot produce ProjectInfo", root)
+ }
+
+ m, l, err := a.lookForGlide(root)
+ if err == nil {
+ // TODO verify project name is same as what SourceManager passed in?
+ return m, l, nil
+ } else if _, ok := err.(notApplicable); !ok {
+ return nil, nil, err
+ }
+
+ // The happy path of finding a glide manifest and/or lock file failed. Now,
+ // we begin our descent: we must attempt to divine just exactly *which*
+ // circle of hell we're in.
+
+ // Try godep first
+ m, l, err = a.lookForGodep(root)
+ if err == nil {
+ return m, l, nil
+ } else if _, ok := err.(notApplicable); !ok {
+ return nil, nil, err
+ }
+
+ // Next, gpm
+ m, l, err = a.lookForGPM(root)
+ if err == nil {
+ return m, l, nil
+ } else if _, ok := err.(notApplicable); !ok {
+ return nil, nil, err
+ }
+
+ // Next, gb
+ m, l, err = a.lookForGb(root)
+ if err == nil {
+ return m, l, nil
+ } else if _, ok := err.(notApplicable); !ok {
+ return nil, nil, err
+ }
+
+ // Next, gom
+ m, l, err = a.lookForGom(root)
+ if err == nil {
+ return m, l, nil
+ } else if _, ok := err.(notApplicable); !ok {
+ return nil, nil, err
+ }
+
+ // If none of our parsers matched, but none had actual errors, then we just
+ // go hands-off; gps itself will do the source analysis and use the Any
+ // constraint for all discovered package.
+ return nil, nil, nil
+}
+
+func (a Analyzer) lookForGlide(root string) (gps.Manifest, gps.Lock, error) {
+ mpath := filepath.Join(root, gpath.GlideFile)
+ if _, err := os.Lstat(mpath); err != nil {
+ return nil, nil, notApplicable{}
+ }
+ // Manifest found, so from here on, we're locked in - a returned error will
+ // make it back to the SourceManager
+
+ yml, err := ioutil.ReadFile(mpath)
+ if err != nil {
+ return nil, nil, fmt.Errorf("Error while reading glide manifest data: %s", root)
+ }
+
+ m, err := cfg.ConfigFromYaml(yml)
+ if err != nil {
+ return nil, nil, fmt.Errorf("Error while parsing glide manifest data: %s", root)
+ }
+
+ // Manifest found, read, and parsed - we're on the happy path. Whether we
+ // find a lock or not, we will produce a valid result back to the
+ // SourceManager.
+ lpath := filepath.Join(root, gpath.LockFile)
+ if _, err := os.Lstat(lpath); err != nil {
+ return m, nil, nil
+ }
+
+ yml, err = ioutil.ReadFile(mpath)
+ if err != nil {
+ return m, nil, nil
+ }
+
+ l, err := cfg.LockfileFromYaml(yml)
+ if err != nil {
+ return m, nil, nil
+ }
+
+ return m, l, nil
+}
+
+func (a Analyzer) lookForGodep(root string) (gps.Manifest, gps.Lock, error) {
+ if !godep.Has(root) {
+ return nil, nil, notApplicable{}
+ }
+
+ d, l, err := godep.AsMetadataPair(root)
+ if err != nil {
+ return nil, nil, err
+ }
+
+ return &cfg.Config{ProjectRoot: root, Imports: d}, l, nil
+}
+
+func (a Analyzer) lookForGPM(root string) (gps.Manifest, gps.Lock, error) {
+ if !gpm.Has(root) {
+ return nil, nil, notApplicable{}
+ }
+
+ d, l, err := gpm.AsMetadataPair(root)
+ if err != nil {
+ return nil, nil, err
+ }
+
+ return &cfg.Config{ProjectRoot: root, Imports: d}, l, nil
+}
+
+func (a Analyzer) lookForGb(root string) (gps.Manifest, gps.Lock, error) {
+ if !gpm.Has(root) {
+ return nil, nil, notApplicable{}
+ }
+
+ d, l, err := gb.AsMetadataPair(root)
+ if err != nil {
+ return nil, nil, err
+ }
+
+ return &cfg.Config{ProjectRoot: root, Imports: d}, l, nil
+}
+
+func (a Analyzer) lookForGom(root string) (gps.Manifest, gps.Lock, error) {
+ if !gpm.Has(root) {
+ return nil, nil, notApplicable{}
+ }
+
+ return gom.AsMetadataPair(root)
+}
diff --git a/gb/gb.go b/gb/gb.go
index 7837a42..ea64258 100644
--- a/gb/gb.go
+++ b/gb/gb.go
@@ -14,8 +14,8 @@
// Has returns true if this dir has a GB-flavored manifest file.
func Has(dir string) bool {
path := filepath.Join(dir, "vendor/manifest")
- _, err := os.Stat(path)
- return err == nil
+ fi, err := os.Stat(path)
+ return err == nil && !fi.IsDir()
}
// Parse parses a GB-flavored manifest file.
@@ -69,3 +69,42 @@
}
return buf, nil
}
+
+// AsMetadataPair attempts to extract manifest and lock data from gb metadata.
+func AsMetadataPair(dir string) (m []*cfg.Dependency, l *cfg.Lockfile, err error) {
+ path := filepath.Join(dir, "vendor/manifest")
+ if _, err = os.Stat(path); err != nil {
+ return
+ }
+
+ file, err := os.Open(path)
+ if err != nil {
+ return
+ }
+ defer file.Close()
+
+ man := Manifest{}
+
+ dec := json.NewDecoder(file)
+ if err = dec.Decode(&man); err != nil {
+ return
+ }
+
+ seen := map[string]bool{}
+
+ for _, d := range man.Dependencies {
+ pkg, _ := util.NormalizeName(d.Importpath)
+ if _, ok := seen[pkg]; ok {
+ seen[pkg] = true
+ dep := &cfg.Dependency{
+ Name: pkg,
+ // TODO we have the branch info here - maybe we should use that
+ Reference: "*",
+ Repository: d.Repository,
+ }
+ m = append(m, dep)
+ l.Imports = append(l.Imports, &cfg.Lock{Name: pkg, Version: d.Revision})
+ }
+ }
+ return
+}
diff --git a/glide.go b/glide.go
index 1190885..b7b2260 100644
--- a/glide.go
+++ b/glide.go
@@ -202,50 +202,18 @@
will be removed when most Godeps users have migrated to using the vendor
folder.`,
Flags: []cli.Flag{
- cli.BoolFlag{
- Name: "test",
- Usage: "Add test dependencies.",
- },
- cli.BoolFlag{
- Name: "insecure",
- Usage: "Use http:// rather than https:// to retrieve pacakges.",
- },
- cli.BoolFlag{
- Name: "no-recursive, quick",
- Usage: "Disable updating dependencies' dependencies.",
- },
- cli.BoolFlag{
- Name: "force",
- Usage: "If there was a change in the repo or VCS switch to new one. Warning, changes will be lost.",
- },
- cli.BoolFlag{
- Name: "all-dependencies",
- Usage: "This will resolve all dependencies for all packages, not just those directly used.",
- },
- cli.BoolFlag{
- Name: "update-vendored, u",
- Usage: "Update vendored packages (without local VCS repo). Warning, changes will be lost.",
- },
- cli.BoolFlag{
- Name: "cache",
- Usage: "When downloading dependencies attempt to cache them.",
- },
- cli.BoolFlag{
- Name: "cache-gopath",
- Usage: "When downloading dependencies attempt to put them in the GOPATH, too.",
- },
- cli.BoolFlag{
- Name: "use-gopath",
- Usage: "Copy dependencies from the GOPATH if they exist there.",
- },
- cli.BoolFlag{
- Name: "resolve-current",
- Usage: "Resolve dependencies for only the current system rather than all build modes.",
- },
- cli.BoolFlag{
- Name: "strip-vcs, s",
- Usage: "Removes version control metadata (e.g, .git directory) from the vendor folder.",
- },
+ //cli.BoolFlag{
+ //Name: "insecure",
+ //Usage: "Use http:// rather than https:// to retrieve packages.",
+ //},
+ //cli.BoolFlag{
+ //Name: "cache-gopath",
+ //Usage: "When downloading dependencies attempt to put them in the GOPATH, too.",
+ //},
+ //cli.BoolFlag{
+ //Name: "resolve-current",
+ //Usage: "Resolve dependencies for only the current system rather than all build modes.",
+ //},
cli.BoolFlag{
Name: "strip-vendor, v",
Usage: "Removes nested vendor and Godeps/_workspace directories. Requires --strip-vcs.",
@@ -254,37 +222,25 @@
Name: "non-interactive",
Usage: "Disable interactive prompts.",
},
- cli.BoolFlag{
- Name: "skip-test",
- Usage: "Resolve dependencies in test files.",
- },
},
Action: func(c *cli.Context) {
- if c.Bool("strip-vendor") && !c.Bool("strip-vcs") {
- msg.Die("--strip-vendor cannot be used without --strip-vcs")
- }
-
if len(c.Args()) < 1 {
fmt.Println("Oops! Package name is required.")
os.Exit(1)
}
- if c.Bool("resolve-current") {
- util.ResolveCurrent = true
- msg.Warn("Only resolving dependencies for the current OS/Arch")
- }
+ //if c.Bool("resolve-current") {
+ //util.ResolveCurrent = true
+ //msg.Warn("Only resolving dependencies for the current OS/Arch")
+ //}
inst := repo.NewInstaller()
- inst.Force = c.Bool("force")
- inst.UseCache = c.Bool("cache")
- inst.UseGopath = c.Bool("use-gopath")
- inst.UseCacheGopath = c.Bool("cache-gopath")
- inst.UpdateVendored = c.Bool("update-vendored")
- inst.ResolveAllFiles = c.Bool("all-dependencies")
- inst.ResolveTest = !c.Bool("skip-test")
+ inst.Home = gpath.Home()
+ //inst.UseCacheGopath = c.Bool("cache-gopath")
+ //inst.ResolveAllFiles = c.Bool("all-dependencies")
packages := []string(c.Args())
- insecure := c.Bool("insecure")
- action.Get(packages, inst, insecure, c.Bool("no-recursive"), c.Bool("strip-vcs"), c.Bool("strip-vendor"), c.Bool("non-interactive"), c.Bool("test"))
+ //insecure := c.Bool("insecure")
+ action.Get(packages, inst, c.Bool("strip-vendor"), c.Bool("non-interactive"))
},
},
{
@@ -421,49 +377,27 @@
Name: "install",
ShortName: "i",
Usage: "Install a project's dependencies",
- Description: `This uses the native VCS of each packages to install
- the appropriate version. There are two ways a projects dependencies can
- be installed. When there is a glide.yaml file defining the dependencies but
- no lock file (glide.lock) the dependencies are installed using the "update"
- command and a glide.lock file is generated pinning all dependencies. If a
- glide.lock file is already present the dependencies are installed or updated
- from the lock file.`,
+ Description: `This uses the native VCS of each package to install the appropriate version into
+ the vendor directory adjacent to glide.yaml. Installs are always performed
+ from a lock file, which contains pinned, immutable versions. If no lock file
+ exists, glide will compute one first, then run the install (unless
+ --install-only is passed).`,
Flags: []cli.Flag{
cli.BoolFlag{
- Name: "delete",
- Usage: "Delete vendor packages not specified in config.",
+ Name: "install-only",
+ Usage: "Install only if a glide.lock file already exists; otherwise, an error is thrown.",
},
cli.BoolFlag{
- Name: "force",
- Usage: "If there was a change in the repo or VCS switch to new one. Warning: changes will be lost.",
- },
- cli.BoolFlag{
- Name: "update-vendored, u",
- Usage: "Update vendored packages (without local VCS repo). Warning: this may destroy local modifications to vendor/.",
- },
- cli.StringFlag{
- Name: "file, f",
- Usage: "Save all of the discovered dependencies to a Glide YAML file. (DEPRECATED: This has no impact.)",
- },
- cli.BoolFlag{
- Name: "cache",
- Usage: "When downloading dependencies attempt to cache them.",
+ Name: "synced-only",
+ Usage: "Install only if the glide.lock file is in sync with the glide.yaml, otherwise exit with an error. (Implies --install-only)",
},
cli.BoolFlag{
Name: "cache-gopath",
Usage: "When downloading dependencies attempt to put them in the GOPATH, too.",
},
cli.BoolFlag{
- Name: "use-gopath",
- Usage: "Copy dependencies from the GOPATH if they exist there.",
- },
- cli.BoolFlag{
- Name: "strip-vcs, s",
- Usage: "Removes version control metadata (e.g, .git directory) from the vendor folder.",
- },
- cli.BoolFlag{
Name: "strip-vendor, v",
- Usage: "Removes nested vendor and Godeps/_workspace directories. Requires --strip-vcs.",
+ Usage: "Removes nested vendor and Godeps/_workspace directories.",
},
cli.BoolFlag{
Name: "skip-test",
@@ -471,21 +405,11 @@
},
},
Action: func(c *cli.Context) {
- if c.Bool("strip-vendor") && !c.Bool("strip-vcs") {
- msg.Die("--strip-vendor cannot be used without --strip-vcs")
- }
-
installer := repo.NewInstaller()
- installer.Force = c.Bool("force")
- installer.UseCache = c.Bool("cache")
- installer.UseGopath = c.Bool("use-gopath")
installer.UseCacheGopath = c.Bool("cache-gopath")
- installer.UpdateVendored = c.Bool("update-vendored")
- installer.Home = c.GlobalString("home")
- installer.DeleteUnused = c.Bool("delete")
- installer.ResolveTest = !c.Bool("skip-test")
+ installer.Home = gpath.Home()
- action.Install(installer, c.Bool("strip-vcs"), c.Bool("strip-vendor"))
+ action.Install(installer, c.Bool("install-only"), c.Bool("synced-only"), c.Bool("strip-vendor"))
},
},
{
@@ -493,9 +417,9 @@
ShortName: "up",
Usage: "Update a project's dependencies",
Description: `This uses the native VCS of each package to try to
- pull the most applicable updates. Packages with fixed refs (Versions or
- tags) will not be updated. Packages with no ref or with a branch ref will
- be updated as expected.
+ pull the most applicable updates. If no arguments are provided, then glide
+ will attempt to update all dependencies. If package names are provided, then
+ glide will attempt to find a solution where only those packages are changed.
If a dependency has a glide.yaml file, update will read that file and
update those dependencies accordingly. Those dependencies are maintained in
@@ -527,55 +451,24 @@
By default, packages that are discovered are considered transient, and are
not stored in the glide.yaml file. The --file=NAME.yaml flag allows you
- to save the discovered dependencies to a YAML file.`,
+ to save the discovered dependencies to a YAML file.
+ `,
Flags: []cli.Flag{
cli.BoolFlag{
- Name: "delete",
- Usage: "Delete vendor packages not specified in config.",
- },
- cli.BoolFlag{
- Name: "no-recursive, quick",
- Usage: "Disable updating dependencies' dependencies. Only update things in glide.yaml.",
- },
- cli.BoolFlag{
- Name: "force",
- Usage: "If there was a change in the repo or VCS switch to new one. Warning, changes will be lost.",
- },
- cli.BoolFlag{
Name: "all-dependencies",
Usage: "This will resolve all dependencies for all packages, not just those directly used.",
},
cli.BoolFlag{
- Name: "update-vendored, u",
- Usage: "Update vendored packages (without local VCS repo). Warning, changes will be lost.",
- },
- cli.StringFlag{
- Name: "file, f",
- Usage: "Save all of the discovered dependencies to a Glide YAML file.",
- },
- cli.BoolFlag{
- Name: "cache",
- Usage: "When downloading dependencies attempt to cache them.",
- },
- cli.BoolFlag{
Name: "cache-gopath",
Usage: "When downloading dependencies attempt to put them in the GOPATH, too.",
},
cli.BoolFlag{
- Name: "use-gopath",
- Usage: "Copy dependencies from the GOPATH if they exist there.",
- },
- cli.BoolFlag{
Name: "resolve-current",
Usage: "Resolve dependencies for only the current system rather than all build modes.",
},
cli.BoolFlag{
- Name: "strip-vcs, s",
- Usage: "Removes version control metadata (e.g, .git directory) from the vendor folder.",
- },
- cli.BoolFlag{
Name: "strip-vendor, v",
- Usage: "Removes nested vendor and Godeps/_workspace directories. Requires --strip-vcs.",
+ Usage: "Removes nested vendor and Godeps/_workspace directories.",
},
cli.BoolFlag{
Name: "skip-test",
@@ -583,27 +476,17 @@
},
},
Action: func(c *cli.Context) {
- if c.Bool("strip-vendor") && !c.Bool("strip-vcs") {
- msg.Die("--strip-vendor cannot be used without --strip-vcs")
- }
-
if c.Bool("resolve-current") {
util.ResolveCurrent = true
msg.Warn("Only resolving dependencies for the current OS/Arch")
}
installer := repo.NewInstaller()
- installer.Force = c.Bool("force")
- installer.UseCache = c.Bool("cache")
- installer.UseGopath = c.Bool("use-gopath")
installer.UseCacheGopath = c.Bool("cache-gopath")
- installer.UpdateVendored = c.Bool("update-vendored")
installer.ResolveAllFiles = c.Bool("all-dependencies")
- installer.Home = c.GlobalString("home")
- installer.DeleteUnused = c.Bool("delete")
- installer.ResolveTest = !c.Bool("skip-test")
+ installer.Home = gpath.Home()
- action.Update(installer, c.Bool("no-recursive"), c.Bool("strip-vcs"), c.Bool("strip-vendor"))
+ action.Update(installer, c.Bool("strip-vendor"), []string(c.Args()))
},
},
{
diff --git a/glide.lock b/glide.lock
index c869e2f..49bed7b 100644
--- a/glide.lock
+++ b/glide.lock
@@ -1,12 +1,18 @@
-hash: 0653c17bcbf6f1df79990f3d2211dbcbc920ca528c513b00f5cab0a508c984ab
-updated: 2016-06-30T10:51:49.633776379-04:00
+hash: 7b0d46d2b21d5d8ff24023a402285f87b14b9f554ae52913cc7ea08bfd17453d
+updated: 2016-07-13T23:09:11.03428654-04:00
imports:
+- name: github.com/armon/go-radix
+ version: 4239b77079c7b5d1243b7b4736304ce8ddb6f0f2
- name: github.com/codegangsta/cli
version: 71f57d300dd6a780ac1856c005c4b518cfd498ec
- name: github.com/Masterminds/semver
- version: 8d0431362b544d1a3536cca26684828866a7de09
+ version: b3ef6b1808e9889dfb8767ce7068db923a3d07de
- name: github.com/Masterminds/vcs
version: fbe9fb6ad5b5f35b3e82a7c21123cfc526cbf895
+- name: github.com/sdboyer/gps
+ version: a868c10855893c21ed05d0f50d6f9acb12b6366d
+- name: github.com/termie/go-shutil
+ version: bcacb06fecaeec8dc42af03c87c6949f4a05c74c
- name: gopkg.in/yaml.v2
version: a83829b6f1293c91addabc89d0571c246397bbf4
testImports: []
diff --git a/glide.yaml b/glide.yaml
index dfc97e9..cb185ed 100644
--- a/glide.yaml
+++ b/glide.yaml
@@ -10,9 +10,12 @@
homepage: https://www.mattfarina.com/
import:
- package: gopkg.in/yaml.v2
+ branch: v2
- package: github.com/Masterminds/vcs
version: ^1.8.0
- package: github.com/codegangsta/cli
version: ~1.14.0
- package: github.com/Masterminds/semver
- version: ^1.1.1
+ branch: 2.x
+- package: github.com/sdboyer/gps
+ branch: master
diff --git a/godep/godep.go b/godep/godep.go
index 71291b3..2b9ea41 100644
--- a/godep/godep.go
+++ b/godep/godep.go
@@ -99,6 +99,52 @@
return buf, nil
}
+func AsMetadataPair(dir string) ([]*cfg.Dependency, *cfg.Lockfile, error) {
+ path := filepath.Join(dir, "Godeps/Godeps.json")
+ if _, err := os.Stat(path); err != nil {
+ return nil, nil, err
+ }
+
+ var m []*cfg.Dependency
+ l := &cfg.Lockfile{}
+ godeps := &Godeps{}
+
+ // Get a handle to the file.
+ file, err := os.Open(path)
+ if err != nil {
+ return nil, nil, err
+ }
+ defer file.Close()
+
+ dec := json.NewDecoder(file)
+ if err := dec.Decode(godeps); err != nil {
+ return nil, nil, err
+ }
+
+ seen := map[string]bool{}
+ for _, d := range godeps.Deps {
+ pkg, _ := util.NormalizeName(d.ImportPath)
+ if _, ok := seen[pkg]; !ok {
+ seen[pkg] = true
+
+ // Place no real *actual* constraint on the project; instead, we
+ // rely on gps using the 'preferred' version mechanism by
+ // working from the lock file. Without this, users would end up with
+ // the same mind-numbing diamond dep problems as currently exist.
+ // This approach does make for an uncomfortably wide possibility
+ // space where deps aren't getting what they expect, but that's
+ // better than just having the solver give up completely.
+ m = append(m, &cfg.Dependency{Name: pkg, Reference: "*"})
+ l.Imports = append(l.Imports, &cfg.Lock{Name: pkg, Version: d.Rev})
+
+ // TODO this fails to differentiate between dev and non-dev imports;
+ // need static analysis for that
+ }
+ }
+
+ return m, l, nil
+}
+
// RemoveGodepSubpackages strips subpackages from a cfg.Config dependencies that
// contain "Godeps/_workspace/src" as part of the path.
func RemoveGodepSubpackages(c *cfg.Config) *cfg.Config {
diff --git a/gom/gom.go b/gom/gom.go
index 51910b0..05785e6 100644
--- a/gom/gom.go
+++ b/gom/gom.go
@@ -9,6 +9,7 @@
"github.com/Masterminds/glide/msg"
gpath "github.com/Masterminds/glide/path"
"github.com/Masterminds/glide/util"
+ "github.com/sdboyer/gps"
)
// Has returns true if this dir has a Gomfile.
@@ -90,6 +91,94 @@
return buf, nil
}
+// AsMetadataPair attempts to extract manifest and lock data from gom metadata.
+func AsMetadataPair(dir string) (gps.Manifest, gps.Lock, error) {
+ path := filepath.Join(dir, "Gomfile")
+ if _, err := os.Stat(path); err != nil {
+ return nil, nil, err
+ }
+
+ goms, err := parseGomfile(path)
+ if err != nil {
+ return nil, nil, err
+ }
+
+ var l gps.SimpleLock
+ m := gps.SimpleManifest{}
+
+ for _, gom := range goms {
+ // Do we need to skip this dependency?
+ if val, ok := gom.options["skipdep"]; ok && val.(string) == "true" {
+ continue
+ }
+
+ // Check for custom cloning command
+ if _, ok := gom.options["command"]; ok {
+ return nil, nil, errors.New("Glide does not support custom Gomfile commands")
+ }
+
+ // Check for groups/environments
+ if val, ok := gom.options["group"]; ok {
+ groups := toStringSlice(val)
+ if !stringsContain(groups, "development") && !stringsContain(groups, "production") {
+ // right now we only support development and production
+ continue
+ }
+ }
+
+ pkg, _ := util.NormalizeName(gom.name)
+
+ dep := gps.ProjectConstraint{
+ Ident: gps.ProjectIdentifier{
+ ProjectRoot: gps.ProjectRoot(pkg),
+ },
+ }
+
+ // Our order of preference for things to put in the manifest are
+ // - Semver
+ // - Version
+ // - Branch
+ // - Revision
+
+ var v gps.UnpairedVersion
+ if val, ok := gom.options["tag"]; ok {
+ body := val.(string)
+ v = gps.NewVersion(body)
+ c, err := gps.NewSemverConstraint(body)
+ if err != nil {
+ c = gps.NewVersion(body)
+ }
+ dep.Constraint = c
+ } else if val, ok := gom.options["branch"]; ok {
+ body := val.(string)
+ v = gps.NewBranch(body)
+ dep.Constraint = gps.NewBranch(body)
+ }
+
+ if val, ok := gom.options["commit"]; ok {
+ body := val.(string)
+ if v != nil {
+ v.Is(gps.Revision(body))
+ l = append(l, gps.NewLockedProject(gps.ProjectRoot(dir), v, dir, nil))
+ } else {
+ // As with the other third-party system integrations, we're
+ // going to choose not to put revisions into a manifest, even
+ // though gom has a lot more information than most and the
+ // argument could be made for it.
+ dep.Constraint = gps.Any()
+ l = append(l, gps.NewLockedProject(gps.ProjectRoot(dir), gps.Revision(body), dir, nil))
+ }
+ } else if v != nil {
+ // This is kinda uncomfortable - lock w/no immut - but OK
+ l = append(l, gps.NewLockedProject(gps.ProjectRoot(dir), v, dir, nil))
+ }
+
+ // TODO We ignore GOOS, GOARCH for now
+ }
+
+ return m, l, nil
+}
+
func stringsContain(v []string, key string) bool {
for _, s := range v {
if s == key {
diff --git a/gpm/gpm.go b/gpm/gpm.go
index e58a81d..00ca864 100644
--- a/gpm/gpm.go
+++ b/gpm/gpm.go
@@ -5,6 +5,7 @@
import (
"bufio"
+ "fmt"
"os"
"path/filepath"
"strings"
@@ -58,6 +59,41 @@
return buf, nil
}
+func AsMetadataPair(dir string) ([]*cfg.Dependency, *cfg.Lockfile, error) {
+ path := filepath.Join(dir, "Godeps")
+ if i, err := os.Stat(path); err != nil {
+ return nil, nil, err
+ } else if i.IsDir() {
+ return nil, nil, fmt.Errorf("Found a Godeps dir, rather than it being a file")
+ }
+
+ var m []*cfg.Dependency
+ l := &cfg.Lockfile{}
+
+ file, err := os.Open(path)
+ if err != nil {
+ return nil, nil, err
+ }
+ scanner := bufio.NewScanner(file)
+ for scanner.Scan() {
+ parts, ok := parseGodepsLine(scanner.Text())
+ if ok {
+ // Place no actual constraint on the project; rely instead on
+ // gps's 'preferred version' reasoning from deps' lock
+ // files...if we have one at all.
+ if len(parts) > 1 {
+ l.Imports = append(l.Imports, &cfg.Lock{Name: parts[0], Version: parts[1]})
+ }
+ m = append(m, &cfg.Dependency{Name: parts[0], Reference: "*"})
+ }
+ }
+ if err := scanner.Err(); err != nil {
+ return nil, nil, err
+ }
+
+ return m, l, nil
+}
+
func parseGodepsLine(line string) ([]string, bool) {
line = strings.TrimSpace(line)
diff --git a/repo/installer.go b/repo/installer.go
index 5fd8562..0d6a335 100644
--- a/repo/installer.go
+++ b/repo/installer.go
@@ -90,7 +90,7 @@
// Create a config setup based on the Lockfile data to process with
// existing commands.
newConf := &cfg.Config{}
- newConf.Name = conf.Name
+ newConf.ProjectRoot = conf.ProjectRoot
newConf.Imports = make(cfg.Dependencies, len(lock.Imports))
for k, v := range lock.Imports {
@@ -449,7 +449,7 @@
func (m *MissingPackageHandler) NotFound(pkg string, addTest bool) (bool, error) {
root := util.GetRootFromPackage(pkg)
// Skip any references to the root package.
- if root == m.Config.Name {
+ if root == m.Config.ProjectRoot {
return false, nil
}
@@ -516,7 +516,7 @@
root := util.GetRootFromPackage(pkg)
// Skip any references to the root package.
- if root == m.Config.Name {
+ if root == m.Config.ProjectRoot {
return false, nil
}
@@ -546,7 +546,7 @@
func (m *MissingPackageHandler) InVendor(pkg string, addTest bool) error {
root := util.GetRootFromPackage(pkg)
// Skip any references to the root package.
- if root == m.Config.Name {
+ if root == m.Config.ProjectRoot {
return nil
}
@@ -606,7 +606,7 @@
root := util.GetRootFromPackage(pkg)
// Skip any references to the root package.
- if root == d.Config.Name {
+ if root == d.Config.ProjectRoot {
return nil
}
@@ -643,7 +643,7 @@
root := util.GetRootFromPackage(pkg)
// Skip any references to the root package.
- if root == d.Config.Name {
+ if root == d.Config.ProjectRoot {
return nil
}
@@ -750,7 +750,7 @@
return v
}
- if con.Check(ver) {
+ if con.Matches(ver) == nil {
singleInfo("Keeping %s %s because it fits constraint '%s'", v.Name, v.Reference, dep.Reference)
return v
}
@@ -774,7 +774,7 @@
return v
}
- if con.Check(ver) {
+ if con.Matches(ver) == nil {
v.Reference = dep.Reference
singleInfo("Using %s %s because it fits constraint '%s'", v.Name, v.Reference, v.Reference)
return v
diff --git a/repo/vcs.go b/repo/vcs.go
index 3f5f80d..ba84ca2 100644
--- a/repo/vcs.go
+++ b/repo/vcs.go
@@ -234,7 +234,7 @@
sort.Sort(sort.Reverse(semver.Collection(semvers)))
found := false
for _, v := range semvers {
- if constraint.Check(v) {
+ if constraint.Matches(v) == nil {
found = true
// If the constrint passes get the original reference
ver = v.Original()
diff --git a/vendor/github.com/Masterminds/semver/CHANGELOG.md b/vendor/github.com/Masterminds/semver/CHANGELOG.md
index c3808ea..2555067 100644
--- a/vendor/github.com/Masterminds/semver/CHANGELOG.md
+++ b/vendor/github.com/Masterminds/semver/CHANGELOG.md
@@ -1,13 +1,9 @@
-# Release 1.1.1 (2016-06-30)
+# Release 1.x.x (xxxx-xx-xx)
-## Changed
- Issue #9: Speed up version comparison performance (thanks @sdboyer)
- Issue #8: Added benchmarks (thanks @sdboyer)
-- Updated Go Report Card URL to new location
-- Updated Readme to add code snippet formatting (thanks @mh-cbon)
-- Updating tagging to v[SemVer] structure for compatibility with other tools.
-# Release 1.1.0 (2016-03-11)
+# Release 1.1.0 (2015-03-11)
- Issue #2: Implemented validation to provide reasons a versions failed a
constraint.
diff --git a/vendor/github.com/Masterminds/semver/README.md b/vendor/github.com/Masterminds/semver/README.md
index 1edec7a..aa133ea 100644
--- a/vendor/github.com/Masterminds/semver/README.md
+++ b/vendor/github.com/Masterminds/semver/README.md
@@ -7,15 +7,13 @@
* Check if a semantic version fits within a set of constraints
* Optionally work with a `v` prefix
-[](https://travis-ci.org/Masterminds/semver) [](https://ci.appveyor.com/project/mattfarina/semver/branch/master) [](https://godoc.org/github.com/Masterminds/semver) [](https://goreportcard.com/report/github.com/Masterminds/semver)
+[](https://travis-ci.org/Masterminds/semver) [](https://ci.appveyor.com/project/mattfarina/semver/branch/master) [](https://godoc.org/github.com/Masterminds/semver) [](http://goreportcard.com/report/Masterminds/semver)
## Parsing Semantic Versions
To parse a semantic version use the `NewVersion` function. For example,
-```go
v, err := semver.NewVersion("1.2.3-beta.1+build345")
-```
If there is an error the version wasn't parseable. The version object has methods
to get the parts of the version, compare it to other versions, convert the
@@ -27,7 +25,6 @@
A set of versions can be sorted using the [`sort`](https://golang.org/pkg/sort/)
package from the standard library. For example,
-```go
raw := []string{"1.2.3", "1.0", "1.3", "2", "0.4.2",}
vs := make([]*semver.Version, len(raw))
for i, r := range raw {
@@ -40,14 +37,12 @@
}
sort.Sort(semver.Collection(vs))
-```
## Checking Version Constraints
Checking a version against version constraints is one of the most featureful
parts of the package.
-```go
c, err := semver.NewConstraint(">= 1.2.3")
if err != nil {
// Handle constraint not being parseable.
@@ -59,7 +54,6 @@
}
// Check if the version meets the constraints. The a variable will be true.
a := c.Check(v)
-```
## Basic Comparisons
@@ -125,7 +119,6 @@
against a constraint. When validation fails a slice of errors containing why a
version didn't meet the constraint is returned. For example,
-```go
c, err := semver.NewConstraint("<= 1.2.3, >= 1.4")
if err != nil {
// Handle constraint not being parseable.
@@ -146,7 +139,6 @@
// "1.3 is greater than 1.2.3"
// "1.3 is less than 1.4"
}
-```
# Contribute
diff --git a/vendor/github.com/Masterminds/semver/benchmark_test.go b/vendor/github.com/Masterminds/semver/benchmark_test.go
index 58a5c28..5a76f6a 100644
--- a/vendor/github.com/Masterminds/semver/benchmark_test.go
+++ b/vendor/github.com/Masterminds/semver/benchmark_test.go
@@ -1,16 +1,53 @@
-package semver_test
+package semver
-import (
- "testing"
+import "testing"
- "github.com/Masterminds/semver"
+func init() {
+ // disable constraint and version creation caching
+ CacheConstraints = false
+ CacheVersions = false
+}
+
+var (
+ rc1 = rangeConstraint{
+ min: newV(1, 5, 0),
+ max: newV(2, 0, 0),
+ includeMax: true,
+ }
+ rc2 = rangeConstraint{
+ min: newV(2, 0, 0),
+ max: newV(3, 0, 0),
+ }
+ rc3 = rangeConstraint{
+ min: newV(1, 5, 0),
+ max: newV(2, 0, 0),
+ }
+ rc4 = rangeConstraint{
+ min: newV(1, 7, 0),
+ max: newV(4, 0, 0),
+ }
+ rc5 = rangeConstraint{
+ min: newV(2, 7, 0),
+ max: newV(3, 0, 0),
+ }
+ rc6 = rangeConstraint{
+ min: newV(3, 0, 1),
+ max: newV(3, 0, 4),
+ }
+ rc7 = rangeConstraint{
+ min: newV(1, 0, 0),
+ max: newV(1, 2, 0),
+ }
+ // Two fully non-overlapping unions
+ u1 = rc1.Union(rc7)
+ u2 = rc5.Union(rc6)
)
/* Constraint creation benchmarks */
func benchNewConstraint(c string, b *testing.B) {
for i := 0; i < b.N; i++ {
- semver.NewConstraint(c)
+ NewConstraint(c)
}
}
@@ -38,52 +75,17 @@
benchNewConstraint("~2.0.0 || =3.1.0", b)
}
-/* Check benchmarks */
-
-func benchCheckVersion(c, v string, b *testing.B) {
- version, _ := semver.NewVersion(v)
- constraint, _ := semver.NewConstraint(c)
-
- for i := 0; i < b.N; i++ {
- constraint.Check(version)
- }
-}
-
-func BenchmarkCheckVersionUnary(b *testing.B) {
- benchCheckVersion("=2.0", "2.0.0", b)
-}
-
-func BenchmarkCheckVersionTilde(b *testing.B) {
- benchCheckVersion("~2.0.0", "2.0.5", b)
-}
-
-func BenchmarkCheckVersionCaret(b *testing.B) {
- benchCheckVersion("^2.0.0", "2.1.0", b)
-}
-
-func BenchmarkCheckVersionWildcard(b *testing.B) {
- benchCheckVersion("1.x", "1.4.0", b)
-}
-
-func BenchmarkCheckVersionRange(b *testing.B) {
- benchCheckVersion(">=2.1.x, <3.1.0", "2.4.5", b)
-}
-
-func BenchmarkCheckVersionUnion(b *testing.B) {
- benchCheckVersion("~2.0.0 || =3.1.0", "3.1.0", b)
-}
+/* Validate benchmarks, including fails */
func benchValidateVersion(c, v string, b *testing.B) {
- version, _ := semver.NewVersion(v)
- constraint, _ := semver.NewConstraint(c)
+ version, _ := NewVersion(v)
+ constraint, _ := NewConstraint(c)
for i := 0; i < b.N; i++ {
- constraint.Validate(version)
+ constraint.Matches(version)
}
}
-/* Validate benchmarks, including fails */
-
func BenchmarkValidateVersionUnary(b *testing.B) {
benchValidateVersion("=2.0", "2.0.0", b)
}
@@ -136,7 +138,7 @@
func benchNewVersion(v string, b *testing.B) {
for i := 0; i < b.N; i++ {
- semver.NewVersion(v)
+ NewVersion(v)
}
}
@@ -155,3 +157,103 @@
func BenchmarkNewVersionMetaDash(b *testing.B) {
benchNewVersion("1.0.0+metadata-dash", b)
}
+
+/* Union benchmarks */
+
+func BenchmarkAdjacentRangeUnion(b *testing.B) {
+ for i := 0; i < b.N; i++ {
+ Union(rc1, rc2)
+ }
+}
+
+func BenchmarkAdjacentRangeUnionMethod(b *testing.B) {
+ for i := 0; i < b.N; i++ {
+ rc1.Union(rc2)
+ }
+}
+
+func BenchmarkDisjointRangeUnion(b *testing.B) {
+ for i := 0; i < b.N; i++ {
+ Union(rc2, rc3)
+ }
+}
+
+func BenchmarkDisjointRangeUnionMethod(b *testing.B) {
+ for i := 0; i < b.N; i++ {
+ rc2.Union(rc3)
+ }
+}
+
+func BenchmarkOverlappingRangeUnion(b *testing.B) {
+ for i := 0; i < b.N; i++ {
+ Union(rc1, rc4)
+ }
+}
+
+func BenchmarkOverlappingRangeUnionMethod(b *testing.B) {
+ for i := 0; i < b.N; i++ {
+ rc1.Union(rc4)
+ }
+}
+
+func BenchmarkUnionUnion(b *testing.B) {
+ for i := 0; i < b.N; i++ {
+ Union(u1, u2)
+ }
+}
+
+func BenchmarkUnionUnionMethod(b *testing.B) {
+ for i := 0; i < b.N; i++ {
+ u1.Union(u2)
+ }
+}
+
+/* Intersection benchmarks */
+
+func BenchmarkSubsetRangeIntersection(b *testing.B) {
+ for i := 0; i < b.N; i++ {
+ Intersection(rc2, rc4)
+ }
+}
+
+func BenchmarkSubsetRangeIntersectionMethod(b *testing.B) {
+ for i := 0; i < b.N; i++ {
+ rc2.Intersect(rc4)
+ }
+}
+
+func BenchmarkDisjointRangeIntersection(b *testing.B) {
+ for i := 0; i < b.N; i++ {
+ Intersection(rc2, rc3)
+ }
+}
+
+func BenchmarkDisjointRangeIntersectionMethod(b *testing.B) {
+ for i := 0; i < b.N; i++ {
+ rc2.Intersect(rc3)
+ }
+}
+
+func BenchmarkOverlappingRangeIntersection(b *testing.B) {
+ for i := 0; i < b.N; i++ {
+ Intersection(rc1, rc4)
+ }
+}
+
+func BenchmarkOverlappingRangeIntersectionMethod(b *testing.B) {
+ for i := 0; i < b.N; i++ {
+ rc1.Intersect(rc4)
+ }
+}
+
+func BenchmarkUnionIntersection(b *testing.B) {
+ for i := 0; i < b.N; i++ {
+ Intersection(u1, u2)
+ }
+}
+
+func BenchmarkUnionIntersectionMethod(b *testing.B) {
+ for i := 0; i < b.N; i++ {
+ u1.Intersect(u2)
+ }
+}
diff --git a/vendor/github.com/Masterminds/semver/constraints.go b/vendor/github.com/Masterminds/semver/constraints.go
index b63f5f6..bf2f500 100644
--- a/vendor/github.com/Masterminds/semver/constraints.go
+++ b/vendor/github.com/Masterminds/semver/constraints.go
@@ -1,126 +1,39 @@
package semver
import (
- "errors"
"fmt"
"regexp"
+ "sort"
"strings"
+ "sync"
)
-// Constraints is one or more constraint that a semantic version can be
-// checked against.
-type Constraints struct {
- constraints [][]*constraint
-}
-
-// NewConstraint returns a Constraints instance that a Version instance can
-// be checked against. If there is a parse error it will be returned.
-func NewConstraint(c string) (*Constraints, error) {
-
- // Rewrite - ranges into a comparison operation.
- c = rewriteRange(c)
-
- ors := strings.Split(c, "||")
- or := make([][]*constraint, len(ors))
- for k, v := range ors {
- cs := strings.Split(v, ",")
- result := make([]*constraint, len(cs))
- for i, s := range cs {
- pc, err := parseConstraint(s)
- if err != nil {
- return nil, err
- }
-
- result[i] = pc
- }
- or[k] = result
- }
-
- o := &Constraints{constraints: or}
- return o, nil
-}
-
-// Check tests if a version satisfies the constraints.
-func (cs Constraints) Check(v *Version) bool {
- // loop over the ORs and check the inner ANDs
- for _, o := range cs.constraints {
- joy := true
- for _, c := range o {
- if !c.check(v) {
- joy = false
- break
- }
- }
-
- if joy {
- return true
- }
- }
-
- return false
-}
-
-// Validate checks if a version satisfies a constraint. If not a slice of
-// reasons for the failure are returned in addition to a bool.
-func (cs Constraints) Validate(v *Version) (bool, []error) {
- // loop over the ORs and check the inner ANDs
- var e []error
- for _, o := range cs.constraints {
- joy := true
- for _, c := range o {
- if !c.check(v) {
- em := fmt.Errorf(c.msg, v, c.orig)
- e = append(e, em)
- joy = false
- }
- }
-
- if joy {
- return true, []error{}
- }
- }
-
- return false, e
-}
-
-var constraintOps map[string]cfunc
-var constraintMsg map[string]string
var constraintRegex *regexp.Regexp
+var constraintRangeRegex *regexp.Regexp
+
+const cvRegex string = `v?([0-9|x|X|\*]+)(\.[0-9|x|X|\*]+)?(\.[0-9|x|X|\*]+)?` +
+ `(-([0-9A-Za-z\-]+(\.[0-9A-Za-z\-]+)*))?` +
+ `(\+([0-9A-Za-z\-]+(\.[0-9A-Za-z\-]+)*))?`
func init() {
- constraintOps = map[string]cfunc{
- "": constraintTildeOrEqual,
- "=": constraintTildeOrEqual,
- "!=": constraintNotEqual,
- ">": constraintGreaterThan,
- "<": constraintLessThan,
- ">=": constraintGreaterThanEqual,
- "=>": constraintGreaterThanEqual,
- "<=": constraintLessThanEqual,
- "=<": constraintLessThanEqual,
- "~": constraintTilde,
- "~>": constraintTilde,
- "^": constraintCaret,
- }
-
- constraintMsg = map[string]string{
- "": "%s is not equal to %s",
- "=": "%s is not equal to %s",
- "!=": "%s is equal to %s",
- ">": "%s is less than or equal to %s",
- "<": "%s is greater than or equal to %s",
- ">=": "%s is less than %s",
- "=>": "%s is less than %s",
- "<=": "%s is greater than %s",
- "=<": "%s is greater than %s",
- "~": "%s does not have same major and minor version as %s",
- "~>": "%s does not have same major and minor version as %s",
- "^": "%s does not have same major version as %s",
+ constraintOps := []string{
+ "",
+ "=",
+ "!=",
+ ">",
+ "<",
+ ">=",
+ "=>",
+ "<=",
+ "=<",
+ "~",
+ "~>",
+ "^",
}
ops := make([]string, 0, len(constraintOps))
- for k := range constraintOps {
- ops = append(ops, regexp.QuoteMeta(k))
+ for _, op := range constraintOps {
+ ops = append(ops, regexp.QuoteMeta(op))
}
constraintRegex = regexp.MustCompile(fmt.Sprintf(
@@ -133,210 +46,250 @@
cvRegex, cvRegex))
}
-// An individual constraint
-type constraint struct {
- // The callback function for the restraint. It performs the logic for
- // the constraint.
- function cfunc
+type Constraint interface {
+ // Constraints compose the fmt.Stringer interface. Printing a constraint
+ // will yield a string that, if passed to NewConstraint(), will produce the
+ // original constraint. (Bidirectional serialization)
+ fmt.Stringer
- msg string
+ // Matches checks that a version satisfies the constraint. If it does not,
+ // an error is returned indcating the problem; if it does, the error is nil.
+ Matches(v *Version) error
- // The version used in the constraint check. For example, if a constraint
- // is '<= 2.0.0' the con a version instance representing 2.0.0.
- con *Version
+ // Intersect computes the intersection between the receiving Constraint and
+ // passed Constraint, and returns a new Constraint representing the result.
+ Intersect(Constraint) Constraint
- // The original parsed version (e.g., 4.x from != 4.x)
- orig string
+ // Union computes the union between the receiving Constraint and the passed
+ // Constraint, and returns a new Constraint representing the result.
+ Union(Constraint) Constraint
- // When an x is used as part of the version (e.g., 1.x)
- minorDirty bool
- dirty bool
+ // MatchesAny returns a bool indicating whether there exists any version that
+ // satisfies both the receiver constraint, and the passed Constraint.
+ //
+ // In other words, this reports whether an intersection would be non-empty.
+ MatchesAny(Constraint) bool
+
+ // Restrict implementation of this interface to this package. We need the
+ // flexibility of an interface, but we cover all possibilities here; closing
+ // off the interface to external implementation lets us safely do tricks
+ // with types for magic types (none and any)
+ _private()
}
-// Check if a version meets the constraint
-func (c *constraint) check(v *Version) bool {
- return c.function(v, c)
+// realConstraint is used internally to differentiate between any, none, and
+// unionConstraints, vs. Version and rangeConstraints.
+type realConstraint interface {
+ Constraint
+ _real()
}
-type cfunc func(v *Version, c *constraint) bool
+// Controls whether or not parsed constraints are cached
+var CacheConstraints = true
+var constraintCache = make(map[string]ccache)
+var constraintCacheLock sync.RWMutex
-func parseConstraint(c string) (*constraint, error) {
- m := constraintRegex.FindStringSubmatch(c)
- if m == nil {
- return nil, fmt.Errorf("improper constraint: %s", c)
- }
-
- ver := m[2]
- orig := ver
- minorDirty := false
- dirty := false
- if isX(m[3]) {
- ver = "0.0.0"
- dirty = true
- } else if isX(strings.TrimPrefix(m[4], ".")) {
- minorDirty = true
- dirty = true
- ver = fmt.Sprintf("%s.0.0%s", m[3], m[6])
- } else if isX(strings.TrimPrefix(m[5], ".")) {
- dirty = true
- ver = fmt.Sprintf("%s%s.0%s", m[3], m[4], m[6])
- }
-
- con, err := NewVersion(ver)
- if err != nil {
-
- // The constraintRegex should catch any regex parsing errors. So,
- // we should never get here.
- return nil, errors.New("constraint Parser Error")
- }
-
- cs := &constraint{
- function: constraintOps[m[1]],
- msg: constraintMsg[m[1]],
- con: con,
- orig: orig,
- minorDirty: minorDirty,
- dirty: dirty,
- }
- return cs, nil
+type ccache struct {
+ c Constraint
+ err error
}
-// Constraint functions
-func constraintNotEqual(v *Version, c *constraint) bool {
- if c.dirty {
- if c.con.Major() != v.Major() {
- return true
+// NewConstraint takes a string representing a set of semver constraints, and
+// returns a corresponding Constraint object. Constraints are suitable
+// for checking Versions for admissibility, or combining with other Constraint
+// objects.
+//
+// If an invalid constraint string is passed, more information is provided in
+// the returned error string.
+func NewConstraint(in string) (Constraint, error) {
+ if CacheConstraints {
+ constraintCacheLock.RLock()
+ if final, exists := constraintCache[in]; exists {
+ constraintCacheLock.RUnlock()
+ return final.c, final.err
}
- if c.con.Minor() != v.Minor() && !c.minorDirty {
- return true
- } else if c.minorDirty {
- return false
+ constraintCacheLock.RUnlock()
+ }
+
+ // Rewrite - ranges into a comparison operation.
+ c := rewriteRange(in)
+
+ ors := strings.Split(c, "||")
+ or := make([]Constraint, len(ors))
+ for k, v := range ors {
+ cs := strings.Split(v, ",")
+ result := make([]Constraint, len(cs))
+ for i, s := range cs {
+ pc, err := parseConstraint(s)
+ if err != nil {
+ if CacheConstraints {
+ constraintCacheLock.Lock()
+ constraintCache[in] = ccache{err: err}
+ constraintCacheLock.Unlock()
+ }
+ return nil, err
+ }
+
+ result[i] = pc
+ }
+ or[k] = Intersection(result...)
+ }
+
+ final := Union(or...)
+
+ if CacheConstraints {
+ constraintCacheLock.Lock()
+ constraintCache[in] = ccache{c: final}
+ constraintCacheLock.Unlock()
+ }
+
+ return final, nil
+}
+
+// Intersection computes the intersection between N Constraints, returning as
+// compact a representation of the intersection as possible.
+//
+// No error is indicated if all the sets are collectively disjoint; you must inspect the
+// return value to see if the result is the empty set (by calling IsNone() on
+// it).
+func Intersection(cg ...Constraint) Constraint {
+ // If there's zero or one constraints in the group, we can quit fast
+ switch len(cg) {
+ case 0:
+ // Zero members, only sane thing to do is return none
+ return None()
+ case 1:
+ // Just one member means that's our final constraint
+ return cg[0]
+ }
+
+ car, cdr := cg[0], cg[1:]
+ for _, c := range cdr {
+ if IsNone(car) {
+ return None()
+ }
+ car = car.Intersect(c)
+ }
+
+ return car
+}
+
+// Union takes a variable number of constraints, and returns the most compact
+// possible representation of those constraints.
+//
+// This effectively ORs together all the provided constraints. If any of the
+// included constraints are the set of all versions (any), that supercedes
+// everything else.
+func Union(cg ...Constraint) Constraint {
+ // If there's zero or one constraints in the group, we can quit fast
+ switch len(cg) {
+ case 0:
+ // Zero members, only sane thing to do is return none
+ return None()
+ case 1:
+ // One member, so the result will just be that
+ return cg[0]
+ }
+
+ // Preliminary pass to look for 'any' in the current set (and bail out early
+ // if found), but also construct a []realConstraint for everything else
+ var real constraintList
+
+ for _, c := range cg {
+ switch tc := c.(type) {
+ case any:
+ return c
+ case none:
+ continue
+ case *Version:
+ //if tc != nil {
+ //heap.Push(&real, tc)
+ //}
+ real = append(real, tc)
+ case rangeConstraint:
+ //heap.Push(&real, tc)
+ real = append(real, tc)
+ case unionConstraint:
+ real = append(real, tc...)
+ //for _, c2 := range tc {
+ //heap.Push(&real, c2)
+ //}
+ default:
+ panic("unknown constraint type")
+ }
+ }
+ // TODO wtf why isn't heap working...so, ugh, have to do this
+
+ // Sort both the versions and ranges into ascending order
+ sort.Sort(real)
+
+ // Iteratively merge the constraintList elements
+ var nuc unionConstraint
+ for _, c := range real {
+ if len(nuc) == 0 {
+ nuc = append(nuc, c)
+ continue
}
- return false
+ last := nuc[len(nuc)-1]
+ switch lt := last.(type) {
+ case *Version:
+ switch ct := c.(type) {
+ case *Version:
+ // Two versions in a row; only append if they're not equal
+ if !lt.Equal(ct) {
+ nuc = append(nuc, ct)
+ }
+ case rangeConstraint:
+ // Last was version, current is range. constraintList sorts by
+ // min version, so it's guaranteed that the version will be less
+ // than the range's min, guaranteeing that these are disjoint.
+ //
+ // ...almost. If the min of the range is the same as the
+ // version, then a union should merge the two by making the
+ // range inclusive at the bottom.
+ if lt.Equal(ct.min) {
+ ct.includeMin = true
+ nuc[len(nuc)-1] = ct
+ } else {
+ nuc = append(nuc, c)
+ }
+ }
+ case rangeConstraint:
+ switch ct := c.(type) {
+ case *Version:
+ // Last was range, current is version. constraintList sort invariants guarantee
+ // that the version will be greater than the min, so we have to
+ // determine if the version is less than the max. If it is, we
+ // subsume it into the range with a Union call.
+ //
+ // Lazy version: just union them and let rangeConstraint figure
+ // it out, then switch on the result type.
+ c2 := lt.Union(ct)
+ if crc, ok := c2.(realConstraint); ok {
+ nuc[len(nuc)-1] = crc
+ } else {
+ // Otherwise, all it can be is a union constraint. First
+ // item in the union will be the same range, second will be the
+ // version, so append onto nuc from one back from the end
+ nuc = append(nuc[:len(nuc)-1], c2.(unionConstraint)...)
+ }
+ case rangeConstraint:
+ if lt.MatchesAny(ct) || areAdjacent(lt, ct) {
+ // If the previous range overlaps or is adjacent to the
+ // current range, we know they'll be able to merge together,
+ // so overwrite the last item in nuc with the result of that
+ // merge (which is what Union will produce)
+ nuc[len(nuc)-1] = lt.Union(ct).(realConstraint)
+ } else {
+ nuc = append(nuc, c)
+ }
+ }
+ }
}
- return !v.Equal(c.con)
-}
-
-func constraintGreaterThan(v *Version, c *constraint) bool {
- return v.Compare(c.con) == 1
-}
-
-func constraintLessThan(v *Version, c *constraint) bool {
- if !c.dirty {
- return v.Compare(c.con) < 0
+ if len(nuc) == 1 {
+ return nuc[0]
}
-
- if v.Major() > c.con.Major() {
- return false
- } else if v.Minor() > c.con.Minor() && !c.minorDirty {
- return false
- }
-
- return true
-}
-
-func constraintGreaterThanEqual(v *Version, c *constraint) bool {
- return v.Compare(c.con) >= 0
-}
-
-func constraintLessThanEqual(v *Version, c *constraint) bool {
- if !c.dirty {
- return v.Compare(c.con) <= 0
- }
-
- if v.Major() > c.con.Major() {
- return false
- } else if v.Minor() > c.con.Minor() && !c.minorDirty {
- return false
- }
-
- return true
-}
-
-// ~*, ~>* --> >= 0.0.0 (any)
-// ~2, ~2.x, ~2.x.x, ~>2, ~>2.x ~>2.x.x --> >=2.0.0, <3.0.0
-// ~2.0, ~2.0.x, ~>2.0, ~>2.0.x --> >=2.0.0, <2.1.0
-// ~1.2, ~1.2.x, ~>1.2, ~>1.2.x --> >=1.2.0, <1.3.0
-// ~1.2.3, ~>1.2.3 --> >=1.2.3, <1.3.0
-// ~1.2.0, ~>1.2.0 --> >=1.2.0, <1.3.0
-func constraintTilde(v *Version, c *constraint) bool {
- if v.LessThan(c.con) {
- return false
- }
-
- // ~0.0.0 is a special case where all constraints are accepted. It's
- // equivalent to >= 0.0.0.
- if c.con.Major() == 0 && c.con.Minor() == 0 && c.con.Patch() == 0 {
- return true
- }
-
- if v.Major() != c.con.Major() {
- return false
- }
-
- if v.Minor() != c.con.Minor() && !c.minorDirty {
- return false
- }
-
- return true
-}
-
-// When there is a .x (dirty) status it automatically opts in to ~. Otherwise
-// it's a straight =
-func constraintTildeOrEqual(v *Version, c *constraint) bool {
- if c.dirty {
- c.msg = constraintMsg["~"]
- return constraintTilde(v, c)
- }
-
- return v.Equal(c.con)
-}
-
-// ^* --> (any)
-// ^2, ^2.x, ^2.x.x --> >=2.0.0, <3.0.0
-// ^2.0, ^2.0.x --> >=2.0.0, <3.0.0
-// ^1.2, ^1.2.x --> >=1.2.0, <2.0.0
-// ^1.2.3 --> >=1.2.3, <2.0.0
-// ^1.2.0 --> >=1.2.0, <2.0.0
-func constraintCaret(v *Version, c *constraint) bool {
- if v.LessThan(c.con) {
- return false
- }
-
- if v.Major() != c.con.Major() {
- return false
- }
-
- return true
-}
-
-var constraintRangeRegex *regexp.Regexp
-
-const cvRegex string = `v?([0-9|x|X|\*]+)(\.[0-9|x|X|\*]+)?(\.[0-9|x|X|\*]+)?` +
- `(-([0-9A-Za-z\-]+(\.[0-9A-Za-z\-]+)*))?` +
- `(\+([0-9A-Za-z\-]+(\.[0-9A-Za-z\-]+)*))?`
-
-func isX(x string) bool {
- switch x {
- case "x", "*", "X":
- return true
- default:
- return false
- }
-}
-
-func rewriteRange(i string) string {
- m := constraintRangeRegex.FindAllStringSubmatch(i, -1)
- if m == nil {
- return i
- }
- o := i
- for _, v := range m {
- t := fmt.Sprintf(">= %s, <= %s", v[1], v[11])
- o = strings.Replace(o, v[0], t, 1)
- }
-
- return o
+ return nuc
}
diff --git a/vendor/github.com/Masterminds/semver/constraints_test.go b/vendor/github.com/Masterminds/semver/constraints_test.go
index 6dad455..6b09d73 100644
--- a/vendor/github.com/Masterminds/semver/constraints_test.go
+++ b/vendor/github.com/Masterminds/semver/constraints_test.go
@@ -1,27 +1,52 @@
package semver
-import (
- "reflect"
- "testing"
-)
+import "testing"
func TestParseConstraint(t *testing.T) {
tests := []struct {
in string
- f cfunc
- v string
+ c Constraint
err bool
}{
- {">= 1.2", constraintGreaterThanEqual, "1.2.0", false},
- {"1.0", constraintTildeOrEqual, "1.0.0", false},
- {"foo", nil, "", true},
- {"<= 1.2", constraintLessThanEqual, "1.2.0", false},
- {"=< 1.2", constraintLessThanEqual, "1.2.0", false},
- {"=> 1.2", constraintGreaterThanEqual, "1.2.0", false},
- {"v1.2", constraintTildeOrEqual, "1.2.0", false},
- {"=1.5", constraintTildeOrEqual, "1.5.0", false},
- {"> 1.3", constraintGreaterThan, "1.3.0", false},
- {"< 1.4.1", constraintLessThan, "1.4.1", false},
+ {"*", Any(), false},
+ {">= 1.2", rangeConstraint{
+ min: newV(1, 2, 0),
+ includeMin: true,
+ }, false},
+ {"1.0", newV(1, 0, 0), false},
+ {"foo", nil, true},
+ {"<= 1.2", rangeConstraint{
+ max: newV(1, 2, 0),
+ includeMax: true,
+ }, false},
+ {"=< 1.2", rangeConstraint{
+ max: newV(1, 2, 0),
+ includeMax: true,
+ }, false},
+ {"=> 1.2", rangeConstraint{
+ min: newV(1, 2, 0),
+ includeMin: true,
+ }, false},
+ {"v1.2", newV(1, 2, 0), false},
+ {"=1.5", newV(1, 5, 0), false},
+ {"> 1.3", rangeConstraint{
+ min: newV(1, 3, 0),
+ }, false},
+ {"< 1.4.1", rangeConstraint{
+ max: newV(1, 4, 1),
+ }, false},
+ {"~1.1.0", rangeConstraint{
+ min: newV(1, 1, 0),
+ max: newV(1, 2, 0),
+ includeMin: true,
+ includeMax: false,
+ }, false},
+ {"^1.1.0", rangeConstraint{
+ min: newV(1, 1, 0),
+ max: newV(2, 0, 0),
+ includeMin: true,
+ includeMax: false,
+ }, false},
}
for _, tc := range tests {
@@ -29,7 +54,7 @@
if tc.err && err == nil {
t.Errorf("Expected error for %s didn't occur", tc.in)
} else if !tc.err && err != nil {
- t.Errorf("Unexpected error for %s", tc.in)
+ t.Errorf("Unexpected error %q for %s", err, tc.in)
}
// If an error was expected continue the loop and don't try the other
@@ -38,15 +63,84 @@
continue
}
- if tc.v != c.con.String() {
+ if !constraintEq(tc.c, c) {
t.Errorf("Incorrect version found on %s", tc.in)
}
+ }
+}
- f1 := reflect.ValueOf(tc.f)
- f2 := reflect.ValueOf(c.function)
- if f1 != f2 {
- t.Errorf("Wrong constraint found for %s", tc.in)
+func constraintEq(c1, c2 Constraint) bool {
+ switch tc1 := c1.(type) {
+ case any:
+ if _, ok := c2.(any); !ok {
+ return false
}
+ return true
+ case none:
+ if _, ok := c2.(none); !ok {
+ return false
+ }
+ return true
+ case *Version:
+ if tc2, ok := c2.(*Version); ok {
+ return tc1.Equal(tc2)
+ }
+ return false
+ case rangeConstraint:
+ if tc2, ok := c2.(rangeConstraint); ok {
+ if len(tc1.excl) != len(tc2.excl) {
+ return false
+ }
+
+ if tc1.min != nil {
+ if !(tc1.includeMin == tc2.includeMin && tc1.min.Equal(tc2.min)) {
+ return false
+ }
+ } else if tc2.min != nil {
+ return false
+ }
+
+ if tc1.max != nil {
+ if !(tc1.includeMax == tc2.includeMax && tc1.max.Equal(tc2.max)) {
+ return false
+ }
+ } else if tc2.max != nil {
+ return false
+ }
+
+ for k, e := range tc1.excl {
+ if !e.Equal(tc2.excl[k]) {
+ return false
+ }
+ }
+ return true
+ }
+ return false
+ case unionConstraint:
+ if tc2, ok := c2.(unionConstraint); ok {
+ if len(tc1) != len(tc2) {
+ return false
+ }
+
+ for k, c := range tc1 {
+ if !constraintEq(c, tc2[k]) {
+ return false
+ }
+ }
+ return true
+ }
+ return false
+ }
+
+ panic("unknown type")
+}
+
+// newV is a helper to create a new Version object.
+func newV(major, minor, patch int64) *Version {
+ return &Version{
+ major: major,
+ minor: minor,
+ patch: patch,
}
}
@@ -72,9 +166,28 @@
{"<=1.1", "0.1.0", true},
{"<=1.1", "1.1.0", true},
{"<=1.1", "1.1.1", false},
+ {"<=1.1-alpha1", "1.1", false},
+ {"<=2.x", "3.0.0", false},
+ {"<=2.x", "2.9.9", true},
+ {"<2.x", "2.0.0", false},
+ {"<2.x", "1.9.9", true},
+ {">=2.x", "3.0.0", true},
+ {">=2.x", "2.9.9", true},
+ {">=2.x", "1.9.9", false},
+ {">2.x", "3.0.0", true},
+ {">2.x", "2.9.9", false},
+ {">2.x", "1.9.9", false},
+ // TODO these are all pending the changes in #10
+ //{"<=2.x-beta1", "3.0.0-alpha2", false},
+ //{">2.x-beta1", "3.0.0-alpha2", true},
+ //{"<2.0.0", "2.0.0-alpha1", false},
+ //{"<=2.0.0", "2.0.0-alpha1", true},
}
for _, tc := range tests {
+ if testing.Verbose() {
+ t.Logf("Testing if %q allows %q", tc.constraint, tc.version)
+ }
c, err := parseConstraint(tc.constraint)
if err != nil {
t.Errorf("err: %s", err)
@@ -87,9 +200,13 @@
continue
}
- a := c.check(v)
+ a := c.Matches(v) == nil
if a != tc.check {
- t.Errorf("Constraint '%s' failing", tc.constraint)
+ if tc.check {
+ t.Errorf("%q should have matched %q", tc.constraint, tc.version)
+ } else {
+ t.Errorf("%q should not have matched %q", tc.constraint, tc.version)
+ }
}
}
}
@@ -97,22 +214,74 @@
func TestNewConstraint(t *testing.T) {
tests := []struct {
input string
- ors int
- count int
+ c Constraint
err bool
}{
- {">= 1.1", 1, 1, false},
- {"2.0", 1, 1, false},
- {">= bar", 0, 0, true},
- {">= 1.2.3, < 2.0", 1, 2, false},
- {">= 1.2.3, < 2.0 || => 3.0, < 4", 2, 2, false},
-
- // The 3-4 should be broken into 2 by the range rewriting
- {"3-4 || => 3.0, < 4", 2, 2, false},
+ {">= 1.1", rangeConstraint{
+ min: newV(1, 1, 0),
+ includeMin: true,
+ }, false},
+ {"2.0", newV(2, 0, 0), false},
+ {">= bar", nil, true},
+ {"^1.1.0", rangeConstraint{
+ min: newV(1, 1, 0),
+ max: newV(2, 0, 0),
+ includeMin: true,
+ }, false},
+ {">= 1.2.3, < 2.0 || => 3.0, < 4", unionConstraint{
+ rangeConstraint{
+ min: newV(1, 2, 3),
+ max: newV(2, 0, 0),
+ includeMin: true,
+ },
+ rangeConstraint{
+ min: newV(3, 0, 0),
+ max: newV(4, 0, 0),
+ includeMin: true,
+ },
+ }, false},
+ {"3-4 || => 1.0, < 2", Union(
+ rangeConstraint{
+ min: newV(3, 0, 0),
+ max: newV(4, 0, 0),
+ includeMin: true,
+ includeMax: true,
+ },
+ rangeConstraint{
+ min: newV(1, 0, 0),
+ max: newV(2, 0, 0),
+ includeMin: true,
+ },
+ ), false},
+ // demonstrates union compression
+ {"3-4 || => 3.0, < 4", rangeConstraint{
+ min: newV(3, 0, 0),
+ max: newV(4, 0, 0),
+ includeMin: true,
+ includeMax: true,
+ }, false},
+ {">=1.1.0, <2.0.0", rangeConstraint{
+ min: newV(1, 1, 0),
+ max: newV(2, 0, 0),
+ includeMin: true,
+ includeMax: false,
+ }, false},
+ {"!=1.4.0", rangeConstraint{
+ excl: []*Version{
+ newV(1, 4, 0),
+ },
+ }, false},
+ {">=1.1.0, !=1.4.0", rangeConstraint{
+ min: newV(1, 1, 0),
+ includeMin: true,
+ excl: []*Version{
+ newV(1, 4, 0),
+ },
+ }, false},
}
for _, tc := range tests {
- v, err := NewConstraint(tc.input)
+ c, err := NewConstraint(tc.input)
if tc.err && err == nil {
t.Errorf("expected but did not get error for: %s", tc.input)
continue
@@ -124,16 +293,8 @@
continue
}
- l := len(v.constraints)
- if tc.ors != l {
- t.Errorf("Expected %s to have %d ORs but got %d",
- tc.input, tc.ors, l)
- }
-
- l = len(v.constraints[0])
- if tc.count != l {
- t.Errorf("Expected %s to have %d constraints but got %d",
- tc.input, tc.count, l)
+ if !constraintEq(tc.c, c) {
+ t.Errorf("%q produced constraint %q, but expected %q", tc.input, c, tc.c)
}
}
}
@@ -145,7 +306,9 @@
check bool
}{
{"*", "1.2.3", true},
- {"~0.0.0", "1.2.3", true},
+ {"~0.0.0", "1.2.3", false}, // npm allows this weird thing, but we don't
+ {"~0.0.0", "0.1.9", false},
+ {"~0.0.0", "0.0.9", true},
{"= 2.0", "1.2.3", false},
{"= 2.0", "2.0.0", true},
{"4.1", "4.1.0", true},
@@ -162,10 +325,12 @@
{"<1.1", "0.1.0", true},
{"<1.1", "1.1.0", false},
{"<1.1", "1.1.1", false},
- {"<1.x", "1.1.1", true},
+ {"<1.x", "1.1.1", false},
+ {"<1.x", "0.9.1", true},
{"<1.x", "2.1.1", false},
{"<1.1.x", "1.2.1", false},
- {"<1.1.x", "1.1.500", true},
+ {"<1.1.x", "1.1.500", false},
+ {"<1.1.x", "1.0.500", true},
{"<1.2.x", "1.1.1", true},
{">=1.1", "4.1.0", true},
{">=1.1", "1.1.0", true},
@@ -215,9 +380,52 @@
continue
}
- a := c.Check(v)
+ a := c.Matches(v) == nil
if a != tc.check {
- t.Errorf("Constraint '%s' failing with '%s'", tc.constraint, tc.version)
+ if a {
+ t.Errorf("Input %q produced constraint %q; should not have admitted %q, but did", tc.constraint, c, tc.version)
+ } else {
+ t.Errorf("Input %q produced constraint %q; should have admitted %q, but did not", tc.constraint, c, tc.version)
+ }
+ }
+ }
+}
+
+func TestBidirectionalSerialization(t *testing.T) {
+ tests := []struct {
+ io string
+ eq bool
+ }{
+ {"*", true}, // any
+ {"~0.0.0", false}, // tildes expand into ranges
+ {"^2.0", false}, // carets expand into ranges
+ {"=2.0", false}, // abbreviated versions print as full
+ {"4.1.x", false}, // wildcards expand into ranges
+ {">= 1.1.0", false}, // does not produce spaces on ranges
+ {"4.1.0", true},
+ {"!=4.1.0", true},
+ {">=1.1.0", true},
+ {">=1.1.0, <2.0.0", true},
+ {">1.0.0, <=1.1.0", true},
+ {"<=1.1.0", true},
+ {">=1.1.0, <2.0.0, !=1.2.3", true},
+ {">=1.1.0, <2.0.0, !=1.2.3 || >3.0.0", true},
+ {">=1.1.0, <2.0.0, !=1.2.3 || >=3.0.0", true},
+ }
+
+ for _, fix := range tests {
+ c, err := NewConstraint(fix.io)
+ if err != nil {
+ t.Errorf("Valid constraint string produced unexpected error: %s", err)
+ }
+
+ eq := fix.io == c.String()
+ if eq != fix.eq {
+ if eq {
+ t.Errorf("Constraint %q should not have reproduced input string %q, but did", c, fix.io)
+ } else {
+ t.Errorf("Constraint should have reproduced input string %q, but instead produced %q", fix.io, c)
+ }
}
}
}
@@ -261,168 +469,119 @@
}
}
-func TestConstraintsValidate(t *testing.T) {
- tests := []struct {
- constraint string
- version string
- check bool
- }{
- {"*", "1.2.3", true},
- {"~0.0.0", "1.2.3", true},
- {"= 2.0", "1.2.3", false},
- {"= 2.0", "2.0.0", true},
- {"4.1", "4.1.0", true},
- {"4.1.x", "4.1.3", true},
- {"1.x", "1.4", true},
- {"!=4.1", "4.1.0", false},
- {"!=4.1", "5.1.0", true},
- {"!=4.x", "5.1.0", true},
- {"!=4.x", "4.1.0", false},
- {"!=4.1.x", "4.2.0", true},
- {"!=4.2.x", "4.2.3", false},
- {">1.1", "4.1.0", true},
- {">1.1", "1.1.0", false},
- {"<1.1", "0.1.0", true},
- {"<1.1", "1.1.0", false},
- {"<1.1", "1.1.1", false},
- {"<1.x", "1.1.1", true},
- {"<1.x", "2.1.1", false},
- {"<1.1.x", "1.2.1", false},
- {"<1.1.x", "1.1.500", true},
- {"<1.2.x", "1.1.1", true},
- {">=1.1", "4.1.0", true},
- {">=1.1", "1.1.0", true},
- {">=1.1", "0.0.9", false},
- {"<=1.1", "0.1.0", true},
- {"<=1.1", "1.1.0", true},
- {"<=1.x", "1.1.0", true},
- {"<=2.x", "3.1.0", false},
- {"<=1.1", "1.1.1", false},
- {"<=1.1.x", "1.2.500", false},
- {">1.1, <2", "1.1.1", true},
- {">1.1, <3", "4.3.2", false},
- {">=1.1, <2, !=1.2.3", "1.2.3", false},
- {">=1.1, <2, !=1.2.3 || > 3", "3.1.2", true},
- {">=1.1, <2, !=1.2.3 || >= 3", "3.0.0", true},
- {">=1.1, <2, !=1.2.3 || > 3", "3.0.0", false},
- {">=1.1, <2, !=1.2.3 || > 3", "1.2.3", false},
- {"1.1 - 2", "1.1.1", true},
- {"1.1-3", "4.3.2", false},
- {"^1.1", "1.1.1", true},
- {"^1.1", "4.3.2", false},
- {"^1.x", "1.1.1", true},
- {"^2.x", "1.1.1", false},
- {"^1.x", "2.1.1", false},
- {"~*", "2.1.1", true},
- {"~1.x", "2.1.1", false},
- {"~1.x", "1.3.5", true},
- {"~1.x", "1.4", true},
- {"~1.1", "1.1.1", true},
- {"~1.2.3", "1.2.5", true},
- {"~1.2.3", "1.2.2", false},
- {"~1.2.3", "1.3.2", false},
- {"~1.1", "1.2.3", false},
- {"~1.3", "2.4.5", false},
+func TestUnionErr(t *testing.T) {
+ u1 := Union(
+ rangeConstraint{
+ min: newV(3, 0, 0),
+ max: newV(4, 0, 0),
+ includeMin: true,
+ includeMax: true,
+ },
+ rangeConstraint{
+ min: newV(1, 0, 0),
+ max: newV(2, 0, 0),
+ includeMin: true,
+ },
+ )
+ fail := u1.Matches(newV(2, 5, 0))
+ failstr := `2.5.0 is greater than or equal to the maximum of >=1.0.0, <2.0.0
+2.5.0 is less than the minimum of >=3.0.0, <=4.0.0`
+ if fail.Error() != failstr {
+ t.Errorf("Did not get expected failure message from union, got %q", fail)
+ }
+}
+
+func TestIsSuperset(t *testing.T) {
+ rc := []rangeConstraint{
+ rangeConstraint{
+ min: newV(1, 2, 0),
+ max: newV(2, 0, 0),
+ includeMin: true,
+ },
+ rangeConstraint{
+ min: newV(1, 2, 0),
+ max: newV(2, 1, 0),
+ },
+ rangeConstraint{
+ max: newV(1, 10, 0),
+ },
+ rangeConstraint{
+ min: newV(2, 0, 0),
+ },
+ rangeConstraint{
+ min: newV(1, 2, 0),
+ max: newV(2, 0, 0),
+ includeMax: true,
+ },
}
- for _, tc := range tests {
- c, err := NewConstraint(tc.constraint)
- if err != nil {
- t.Errorf("err: %s", err)
- continue
+ for _, c := range rc {
+
+ // Superset comparison is not strict, so a range should always be a superset
+ // of itself.
+ if !c.isSupersetOf(c) {
+ t.Errorf("Ranges should be supersets of themselves; %s indicated it was not", c)
}
+ }
- v, err := NewVersion(tc.version)
- if err != nil {
- t.Errorf("err: %s", err)
- continue
+ pairs := []struct{ l, r rangeConstraint }{
+ {
+ // ensures lte is handled correctly (min side)
+ l: rc[0],
+ r: rc[1],
+ },
+ {
+ // ensures nil on min side works well
+ l: rc[0],
+ r: rc[2],
+ },
+ {
+ // ensures nil on max side works well
+ l: rc[0],
+ r: rc[3],
+ },
+ {
+ // ensures nils on both sides work well
+ l: rc[2],
+ r: rc[3],
+ },
+ {
+ // ensures gte is handled correctly (max side)
+ l: rc[2],
+ r: rc[4],
+ },
+ }
+
+ for _, p := range pairs {
+ if p.l.isSupersetOf(p.r) {
+ t.Errorf("%s is not a superset of %s", p.l, p.r)
}
-
- a, msgs := c.Validate(v)
- if a != tc.check {
- t.Errorf("Constraint '%s' failing with '%s'", tc.constraint, tc.version)
- } else if a == false && len(msgs) == 0 {
- t.Errorf("%q failed with %q but no errors returned", tc.constraint, tc.version)
+ if p.r.isSupersetOf(p.l) {
+ t.Errorf("%s is not a superset of %s", p.r, p.l)
}
-
- // if a == false {
- // for _, m := range msgs {
- // t.Errorf("%s", m)
- // }
- // }
}
- v, err := NewVersion("1.2.3")
- if err != nil {
- t.Errorf("err: %s", err)
+ rc[1].max.minor = 0
+
+ if !rc[0].isSupersetOf(rc[1]) {
+ t.Errorf("%s is a superset of %s", rc[0], rc[1])
+ }
+ rc[1].includeMax = true
+ if rc[1].isSupersetOf(rc[0]) {
+ t.Errorf("%s is not a superset of %s", rc[1], rc[0])
+ }
+ rc[0].includeMin = false
+ if !rc[1].isSupersetOf(rc[0]) {
+ t.Errorf("%s is a superset of %s", rc[1], rc[0])
}
- c, err := NewConstraint("!= 1.2.5, ^2, <= 1.1.x")
- if err != nil {
- t.Errorf("err: %s", err)
+ // isSupersetOf ignores excludes, so even though this would make rc[1] not a
+ // superset of rc[0] anymore, it should still say it is.
+ rc[1].excl = []*Version{
+ newV(1, 5, 0),
}
- _, msgs := c.Validate(v)
- if len(msgs) != 2 {
- t.Error("Invalid number of validations found")
- }
- e := msgs[0].Error()
- if e != "1.2.3 does not have same major version as 2" {
- t.Error("Did not get expected message: 1.2.3 does not have same major version as 2")
- }
- e = msgs[1].Error()
- if e != "1.2.3 is greater than 1.1.x" {
- t.Error("Did not get expected message: 1.2.3 is greater than 1.1.x")
- }
-
- tests2 := []struct {
- constraint, version, msg string
- }{
- {"= 2.0", "1.2.3", "1.2.3 is not equal to 2.0"},
- {"!=4.1", "4.1.0", "4.1.0 is equal to 4.1"},
- {"!=4.x", "4.1.0", "4.1.0 is equal to 4.x"},
- {"!=4.2.x", "4.2.3", "4.2.3 is equal to 4.2.x"},
- {">1.1", "1.1.0", "1.1.0 is less than or equal to 1.1"},
- {"<1.1", "1.1.0", "1.1.0 is greater than or equal to 1.1"},
- {"<1.1", "1.1.1", "1.1.1 is greater than or equal to 1.1"},
- {"<1.x", "2.1.1", "2.1.1 is greater than or equal to 1.x"},
- {"<1.1.x", "1.2.1", "1.2.1 is greater than or equal to 1.1.x"},
- {">=1.1", "0.0.9", "0.0.9 is less than 1.1"},
- {"<=2.x", "3.1.0", "3.1.0 is greater than 2.x"},
- {"<=1.1", "1.1.1", "1.1.1 is greater than 1.1"},
- {"<=1.1.x", "1.2.500", "1.2.500 is greater than 1.1.x"},
- {">1.1, <3", "4.3.2", "4.3.2 is greater than or equal to 3"},
- {">=1.1, <2, !=1.2.3", "1.2.3", "1.2.3 is equal to 1.2.3"},
- {">=1.1, <2, !=1.2.3 || > 3", "3.0.0", "3.0.0 is greater than or equal to 2"},
- {">=1.1, <2, !=1.2.3 || > 3", "1.2.3", "1.2.3 is equal to 1.2.3"},
- {"1.1-3", "4.3.2", "4.3.2 is greater than 3"},
- {"^1.1", "4.3.2", "4.3.2 does not have same major version as 1.1"},
- {"^2.x", "1.1.1", "1.1.1 does not have same major version as 2.x"},
- {"^1.x", "2.1.1", "2.1.1 does not have same major version as 1.x"},
- {"~1.x", "2.1.1", "2.1.1 does not have same major and minor version as 1.x"},
- {"~1.2.3", "1.2.2", "1.2.2 does not have same major and minor version as 1.2.3"},
- {"~1.2.3", "1.3.2", "1.3.2 does not have same major and minor version as 1.2.3"},
- {"~1.1", "1.2.3", "1.2.3 does not have same major and minor version as 1.1"},
- {"~1.3", "2.4.5", "2.4.5 does not have same major and minor version as 1.3"},
- }
-
- for _, tc := range tests2 {
- c, err := NewConstraint(tc.constraint)
- if err != nil {
- t.Errorf("err: %s", err)
- continue
- }
-
- v, err := NewVersion(tc.version)
- if err != nil {
- t.Errorf("err: %s", err)
- continue
- }
-
- _, msgs := c.Validate(v)
- e := msgs[0].Error()
- if e != tc.msg {
- t.Errorf("Did not get expected message %q: %s", tc.msg, e)
- }
+ if !rc[1].isSupersetOf(rc[0]) {
+ t.Errorf("%s is still a superset of %s, because isSupersetOf is supposed to ignore excluded versions", rc[1], rc[0])
}
}
diff --git a/vendor/github.com/Masterminds/semver/error.go b/vendor/github.com/Masterminds/semver/error.go
new file mode 100644
index 0000000..4fb7345
--- /dev/null
+++ b/vendor/github.com/Masterminds/semver/error.go
@@ -0,0 +1,69 @@
+package semver
+
+import (
+ "bytes"
+ "fmt"
+)
+
+var rangeErrs = [...]string{
+ "%s is less than the minimum of %s",
+ "%s is less than or equal to the minimum of %s",
+ "%s is greater than the maximum of %s",
+ "%s is greater than or equal to the maximum of %s",
+ "%s is specifically disallowed in %s",
+}
+
+const (
+ rerrLT = iota
+ rerrLTE
+ rerrGT
+ rerrGTE
+ rerrNE
+)
+
+type MatchFailure interface {
+ error
+ Pair() (v *Version, c Constraint)
+}
+
+type RangeMatchFailure struct {
+ v *Version
+ rc rangeConstraint
+ typ int8
+}
+
+func (rce RangeMatchFailure) Error() string {
+ return fmt.Sprintf(rangeErrs[rce.typ], rce.v, rce.rc)
+}
+
+func (rce RangeMatchFailure) Pair() (v *Version, r Constraint) {
+ return rce.v, rce.rc
+}
+
+type VersionMatchFailure struct {
+ v, other *Version
+}
+
+func (vce VersionMatchFailure) Error() string {
+ return fmt.Sprintf("%s is not equal to %s", vce.v, vce.other)
+}
+
+func (vce VersionMatchFailure) Pair() (v *Version, r Constraint) {
+ return vce.v, vce.other
+}
+
+type MultiMatchFailure []MatchFailure
+
+func (mmf MultiMatchFailure) Error() string {
+ var buf bytes.Buffer
+
+ for k, e := range mmf {
+ if k < len(mmf)-1 {
+ fmt.Fprintf(&buf, "%s\n", e)
+ } else {
+ fmt.Fprintf(&buf, e.Error())
+ }
+ }
+
+ return buf.String()
+}
diff --git a/vendor/github.com/Masterminds/semver/magic.go b/vendor/github.com/Masterminds/semver/magic.go
new file mode 100644
index 0000000..9a8d353
--- /dev/null
+++ b/vendor/github.com/Masterminds/semver/magic.go
@@ -0,0 +1,99 @@
+package semver
+
+import "errors"
+
+var noneErr = errors.New("The 'None' constraint admits no versions.")
+
+// Any is a constraint that is satisfied by any valid semantic version.
+type any struct{}
+
+// Any creates a constraint that will match any version.
+func Any() Constraint {
+ return any{}
+}
+
+func (any) String() string {
+ return "*"
+}
+
+// Matches checks that a version satisfies the constraint. As all versions
+// satisfy Any, this always returns nil.
+func (any) Matches(v *Version) error {
+ return nil
+}
+
+// Intersect computes the intersection between two constraints.
+//
+// As Any is the set of all possible versions, any intersection with that
+// infinite set will necessarily be the entirety of the second set. Thus, this
+// simply returns the passed constraint.
+func (any) Intersect(c Constraint) Constraint {
+ return c
+}
+
+// MatchesAny indicates whether there exists any version that can satisfy both
+// this constraint, and the passed constraint. As all versions
+// satisfy Any, this is always true - unless none is passed.
+func (any) MatchesAny(c Constraint) bool {
+ if _, ok := c.(none); ok {
+ return false
+ }
+ return true
+}
+
+func (any) Union(c Constraint) Constraint {
+ return Any()
+}
+
+func (any) _private() {}
+
+// None is an unsatisfiable constraint - it represents the empty set.
+type none struct{}
+
+// None creates a constraint that matches no versions (the empty set).
+func None() Constraint {
+ return none{}
+}
+
+func (none) String() string {
+ return ""
+}
+
+// Matches checks that a version satisfies the constraint. As no version can
+// satisfy None, this always fails (returns an error).
+func (none) Matches(v *Version) error {
+ return noneErr
+}
+
+// Intersect computes the intersection between two constraints.
+//
+// None is the empty set of versions, and any intersection with the empty set is
+// necessarily the empty set. Thus, this always returns None.
+func (none) Intersect(Constraint) Constraint {
+ return None()
+}
+
+func (none) Union(c Constraint) Constraint {
+ return c
+}
+
+// MatchesAny indicates whether there exists any version that can satisfy the
+// constraint. As no versions satisfy None, this is always false.
+func (none) MatchesAny(c Constraint) bool {
+ return false
+}
+
+func (none) _private() {}
+
+// IsNone indicates if a constraint will match no versions - that is, the
+// constraint represents the empty set.
+func IsNone(c Constraint) bool {
+ _, ok := c.(none)
+ return ok
+}
+
+// IsAny indicates if a constraint will match any and all versions.
+func IsAny(c Constraint) bool {
+ _, ok := c.(any)
+ return ok
+}
diff --git a/vendor/github.com/Masterminds/semver/parse.go b/vendor/github.com/Masterminds/semver/parse.go
new file mode 100644
index 0000000..a6e6a97
--- /dev/null
+++ b/vendor/github.com/Masterminds/semver/parse.go
@@ -0,0 +1,217 @@
+package semver
+
+import (
+ "errors"
+ "fmt"
+ "strings"
+)
+
+func rewriteRange(i string) string {
+ m := constraintRangeRegex.FindAllStringSubmatch(i, -1)
+ if m == nil {
+ return i
+ }
+ o := i
+ for _, v := range m {
+ t := fmt.Sprintf(">= %s, <= %s", v[1], v[11])
+ o = strings.Replace(o, v[0], t, 1)
+ }
+
+ return o
+}
+
+func parseConstraint(c string) (Constraint, error) {
+ m := constraintRegex.FindStringSubmatch(c)
+ if m == nil {
+ return nil, fmt.Errorf("Malformed constraint: %s", c)
+ }
+
+ // Handle the full wildcard case first - easy!
+ if isX(m[3]) {
+ return any{}, nil
+ }
+
+ ver := m[2]
+ var wildPatch, wildMinor bool
+ if isX(strings.TrimPrefix(m[4], ".")) {
+ wildPatch = true
+ wildMinor = true
+ ver = fmt.Sprintf("%s.0.0%s", m[3], m[6])
+ } else if isX(strings.TrimPrefix(m[5], ".")) {
+ wildPatch = true
+ ver = fmt.Sprintf("%s%s.0%s", m[3], m[4], m[6])
+ }
+
+ v, err := NewVersion(ver)
+ if err != nil {
+ // The constraintRegex should catch any regex parsing errors. So,
+ // we should never get here.
+ return nil, errors.New("constraint Parser Error")
+ }
+
+ switch m[1] {
+ case "^":
+ // Caret always expands to a range
+ return expandCaret(v), nil
+ case "~":
+ // Tilde always expands to a range
+ return expandTilde(v, wildMinor), nil
+ case "!=":
+ // Not equals expands to a range if no element isX(); otherwise expands
+ // to a union of ranges
+ return expandNeq(v, wildMinor, wildPatch), nil
+ case "", "=":
+ if wildPatch || wildMinor {
+ // Equalling a wildcard has the same behavior as expanding tilde
+ return expandTilde(v, wildMinor), nil
+ }
+ return v, nil
+ case ">":
+ return expandGreater(v, wildMinor, wildPatch, false), nil
+ case ">=", "=>":
+ return expandGreater(v, wildMinor, wildPatch, true), nil
+ case "<":
+ return expandLess(v, wildMinor, wildPatch, false), nil
+ case "<=", "=<":
+ return expandLess(v, wildMinor, wildPatch, true), nil
+ default:
+ // Shouldn't be possible to get here, unless the regex is allowing
+ // predicate we don't know about...
+ return nil, fmt.Errorf("Unrecognized predicate %q", m[1])
+ }
+}
+
+func expandCaret(v *Version) Constraint {
+ maxv := &Version{
+ major: v.major + 1,
+ minor: 0,
+ patch: 0,
+ }
+
+ return rangeConstraint{
+ min: v,
+ max: maxv,
+ includeMin: true,
+ includeMax: false,
+ }
+}
+
+func expandTilde(v *Version, wildMinor bool) Constraint {
+ if wildMinor {
+ // When minor is wild on a tilde, behavior is same as caret
+ return expandCaret(v)
+ }
+
+ maxv := &Version{
+ major: v.major,
+ minor: v.minor + 1,
+ patch: 0,
+ }
+
+ return rangeConstraint{
+ min: v,
+ max: maxv,
+ includeMin: true,
+ includeMax: false,
+ }
+}
+
+// expandNeq expands a "not-equals" constraint.
+//
+// If the constraint has any wildcards, it will expand into a unionConstraint
+// (which is how we represent a disjoint set). If there are no wildcards, it
+// will expand to a rangeConstraint with no min or max, but having the one
+// exception.
+func expandNeq(v *Version, wildMinor, wildPatch bool) Constraint {
+ if !(wildMinor || wildPatch) {
+ return rangeConstraint{
+ excl: []*Version{v},
+ }
+ }
+
+ // Create the low range with no min, and the max as the floor admitted by
+ // the wildcard
+ lr := rangeConstraint{
+ max: v,
+ includeMax: false,
+ }
+
+ // The high range uses the derived version (bumped depending on where the
+ // wildcards were) as the min, and is inclusive
+ minv := &Version{
+ major: v.major,
+ minor: v.minor,
+ patch: v.patch,
+ }
+
+ if wildMinor {
+ minv.major++
+ } else {
+ minv.minor++
+ }
+
+ hr := rangeConstraint{
+ min: minv,
+ includeMin: true,
+ }
+
+ return Union(lr, hr)
+}
+
+func expandGreater(v *Version, wildMinor, wildPatch, eq bool) Constraint {
+ if (wildMinor || wildPatch) && !eq {
+ // wildcards negate the meaning of prerelease and other info
+ v = &Version{
+ major: v.major,
+ minor: v.minor,
+ patch: v.patch,
+ }
+
+ // Not equal but with wildcards is the weird case - we have to bump up
+ // the next version AND make it equal
+ if wildMinor {
+ v.major++
+ } else {
+ v.minor++
+ }
+ return rangeConstraint{
+ min: v,
+ includeMin: true,
+ }
+ }
+
+ return rangeConstraint{
+ min: v,
+ includeMin: eq,
+ }
+}
+
+func expandLess(v *Version, wildMinor, wildPatch, eq bool) Constraint {
+ if eq && (wildMinor || wildPatch) {
+ // wildcards negate the meaning of prerelease and other info
+ v = &Version{
+ major: v.major,
+ minor: v.minor,
+ patch: v.patch,
+ }
+ if wildMinor {
+ v.major++
+ } else if wildPatch {
+ v.minor++
+ }
+ return rangeConstraint{
+ max: v,
+ includeMax: false,
+ }
+ }
+
+ return rangeConstraint{
+ max: v,
+ includeMax: eq,
+ }
+}
+
+func isX(x string) bool {
+ l := strings.ToLower(x)
+ return l == "x" || l == "*"
+}
diff --git a/vendor/github.com/Masterminds/semver/range.go b/vendor/github.com/Masterminds/semver/range.go
new file mode 100644
index 0000000..0e0c6a8
--- /dev/null
+++ b/vendor/github.com/Masterminds/semver/range.go
@@ -0,0 +1,452 @@
+package semver
+
+import (
+ "fmt"
+ "sort"
+ "strings"
+)
+
+type rangeConstraint struct {
+ min, max *Version
+ includeMin, includeMax bool
+ excl []*Version
+}
+
+func (rc rangeConstraint) Matches(v *Version) error {
+ var fail bool
+
+ rce := RangeMatchFailure{
+ v: v,
+ rc: rc,
+ }
+
+ if rc.min != nil {
+ // TODO ensure sane handling of prerelease versions (which are strictly
+ // less than the normal version, but should be admitted in a geq range)
+ cmp := rc.min.Compare(v)
+ if rc.includeMin {
+ rce.typ = rerrLT
+ fail = cmp == 1
+ } else {
+ rce.typ = rerrLTE
+ fail = cmp != -1
+ }
+
+ if fail {
+ return rce
+ }
+ }
+
+ if rc.max != nil {
+ // TODO ensure sane handling of prerelease versions (which are strictly
+ // less than the normal version, but should be admitted in a geq range)
+ cmp := rc.max.Compare(v)
+ if rc.includeMax {
+ rce.typ = rerrGT
+ fail = cmp == -1
+ } else {
+ rce.typ = rerrGTE
+ fail = cmp != 1
+ }
+
+ if fail {
+ return rce
+ }
+ }
+
+ for _, excl := range rc.excl {
+ if excl.Equal(v) {
+ rce.typ = rerrNE
+ return rce
+ }
+ }
+
+ return nil
+}
+
+func (rc rangeConstraint) dup() rangeConstraint {
+ // Only need to do anything if there are some excludes
+ if len(rc.excl) == 0 {
+ return rc
+ }
+
+ var excl []*Version
+ excl = make([]*Version, len(rc.excl))
+ copy(excl, rc.excl)
+
+ return rangeConstraint{
+ min: rc.min,
+ max: rc.max,
+ includeMin: rc.includeMin,
+ includeMax: rc.includeMax,
+ excl: excl,
+ }
+}
+
+func (rc rangeConstraint) Intersect(c Constraint) Constraint {
+ switch oc := c.(type) {
+ case any:
+ return rc
+ case none:
+ return None()
+ case unionConstraint:
+ return oc.Intersect(rc)
+ case *Version:
+ if err := rc.Matches(oc); err != nil {
+ return None()
+ } else {
+ return c
+ }
+ case rangeConstraint:
+ nr := rangeConstraint{
+ min: rc.min,
+ max: rc.max,
+ includeMin: rc.includeMin,
+ includeMax: rc.includeMax,
+ }
+
+ if oc.min != nil {
+ if nr.min == nil || nr.min.LessThan(oc.min) {
+ nr.min = oc.min
+ nr.includeMin = oc.includeMin
+ } else if oc.min.Equal(nr.min) && !oc.includeMin {
+ // intersection means we must follow the least inclusive
+ nr.includeMin = false
+ }
+ }
+
+ if oc.max != nil {
+ if nr.max == nil || nr.max.GreaterThan(oc.max) {
+ nr.max = oc.max
+ nr.includeMax = oc.includeMax
+ } else if oc.max.Equal(nr.max) && !oc.includeMax {
+ // intersection means we must follow the least inclusive
+ nr.includeMax = false
+ }
+ }
+
+ // Ensure any applicable excls from oc are included in nc
+ for _, e := range append(rc.excl, oc.excl...) {
+ if nr.Matches(e) == nil {
+ nr.excl = append(nr.excl, e)
+ }
+ }
+
+ if nr.min == nil || nr.max == nil {
+ return nr
+ }
+
+ if nr.min.Equal(nr.max) {
+ // min and max are equal. if range is inclusive, return that
+ // version; otherwise, none
+ if nr.includeMin && nr.includeMax {
+ return nr.min
+ }
+ return None()
+ }
+
+ if nr.min.GreaterThan(nr.max) {
+ // min is greater than max - not possible, so we return none
+ return None()
+ }
+
+ // range now fully validated, return what we have
+ return nr
+
+ default:
+ panic("unknown type")
+ }
+}
+
+func (rc rangeConstraint) Union(c Constraint) Constraint {
+ switch oc := c.(type) {
+ case any:
+ return Any()
+ case none:
+ return rc
+ case unionConstraint:
+ return Union(rc, oc)
+ case *Version:
+ if err := rc.Matches(oc); err == nil {
+ return rc
+ } else if len(rc.excl) > 0 { // TODO (re)checking like this is wasteful
+ // ensure we don't have an excl-specific mismatch; if we do, remove
+ // it and return that
+ for k, e := range rc.excl {
+ if e.Equal(oc) {
+ excl := make([]*Version, len(rc.excl)-1)
+
+ if k == len(rc.excl)-1 {
+ copy(excl, rc.excl[:k])
+ } else {
+ copy(excl, append(rc.excl[:k], rc.excl[k+1:]...))
+ }
+
+ return rangeConstraint{
+ min: rc.min,
+ max: rc.max,
+ includeMin: rc.includeMin,
+ includeMax: rc.includeMax,
+ excl: excl,
+ }
+ }
+ }
+ }
+
+ if oc.LessThan(rc.min) {
+ return unionConstraint{oc, rc.dup()}
+ }
+ if areEq(oc, rc.min) {
+ ret := rc.dup()
+ ret.includeMin = true
+ return ret
+ }
+ if areEq(oc, rc.max) {
+ ret := rc.dup()
+ ret.includeMax = true
+ return ret
+ }
+ // Only possibility left is gt
+ return unionConstraint{rc.dup(), oc}
+ case rangeConstraint:
+ if (rc.min == nil && oc.max == nil) || (rc.max == nil && oc.min == nil) {
+ rcl, ocl := len(rc.excl), len(oc.excl)
+ // Quick check for open case
+ if rcl == 0 && ocl == 0 {
+ return Any()
+ }
+
+ // This is inefficient, but it's such an absurdly corner case...
+ if len(dedupeExcls(rc.excl, oc.excl)) == rcl+ocl {
+ // If deduped excludes are the same length as the individual
+ // excludes, then they have no overlapping elements, so the
+ // union knocks out the excludes and we're back to Any.
+ return Any()
+ }
+
+ // There's at least some dupes, which are all we need to include
+ nc := rangeConstraint{}
+ for _, e1 := range rc.excl {
+ for _, e2 := range oc.excl {
+ if e1.Equal(e2) {
+ nc.excl = append(nc.excl, e1)
+ }
+ }
+ }
+
+ return nc
+ } else if areAdjacent(rc, oc) {
+ // Receiver adjoins the input from below
+ nc := rc.dup()
+
+ nc.max = oc.max
+ nc.includeMax = oc.includeMax
+ nc.excl = append(nc.excl, oc.excl...)
+
+ return nc
+ } else if areAdjacent(oc, rc) {
+ // Input adjoins the receiver from below
+ nc := oc.dup()
+
+ nc.max = rc.max
+ nc.includeMax = rc.includeMax
+ nc.excl = append(nc.excl, rc.excl...)
+
+ return nc
+
+ } else if rc.MatchesAny(oc) {
+ // Receiver and input overlap; form a new range accordingly.
+ nc := rangeConstraint{}
+
+ // For efficiency, we simultaneously determine if either of the
+ // ranges are supersets of the other, while also selecting the min
+ // and max of the new range
+ var info uint8
+
+ const (
+ lminlt uint8 = 1 << iota // left (rc) min less than right
+ rminlt // right (oc) min less than left
+ lmaxgt // left max greater than right
+ rmaxgt // right max greater than left
+ lsupr = lminlt | lmaxgt // left is superset of right
+ rsupl = rminlt | rmaxgt // right is superset of left
+ )
+
+ // Pick the min
+ if rc.min != nil {
+ if oc.min == nil || rc.min.GreaterThan(oc.min) || (rc.min.Equal(oc.min) && !rc.includeMin && oc.includeMin) {
+ info |= rminlt
+ nc.min = oc.min
+ nc.includeMin = oc.includeMin
+ } else {
+ info |= lminlt
+ nc.min = rc.min
+ nc.includeMin = rc.includeMin
+ }
+ } else if oc.min != nil {
+ info |= lminlt
+ nc.min = rc.min
+ nc.includeMin = rc.includeMin
+ }
+
+ // Pick the max
+ if rc.max != nil {
+ if oc.max == nil || rc.max.LessThan(oc.max) || (rc.max.Equal(oc.max) && !rc.includeMax && oc.includeMax) {
+ info |= rmaxgt
+ nc.max = oc.max
+ nc.includeMax = oc.includeMax
+ } else {
+ info |= lmaxgt
+ nc.max = rc.max
+ nc.includeMax = rc.includeMax
+ }
+ } else if oc.max != nil {
+ info |= lmaxgt
+ nc.max = rc.max
+ nc.includeMax = rc.includeMax
+ }
+
+ // Reincorporate any excluded versions
+ if info&lsupr != lsupr {
+ // rc is not superset of oc, so must walk oc.excl
+ for _, e := range oc.excl {
+ if rc.Matches(e) != nil {
+ nc.excl = append(nc.excl, e)
+ }
+ }
+ }
+
+ if info&rsupl != rsupl {
+ // oc is not superset of rc, so must walk rc.excl
+ for _, e := range rc.excl {
+ if oc.Matches(e) != nil {
+ nc.excl = append(nc.excl, e)
+ }
+ }
+ }
+
+ return nc
+ } else {
+ // Don't call Union() here b/c it would duplicate work
+ uc := constraintList{rc, oc}
+ sort.Sort(uc)
+ return unionConstraint(uc)
+ }
+ }
+
+ panic("unknown type")
+}
+
+// isSupersetOf computes whether the receiver rangeConstraint is a superset of
+// the passed rangeConstraint.
+//
+// This is NOT a strict superset comparison, so identical ranges will both
+// report being supersets of each other.
+//
+// Note also that this does *not* compare excluded versions - it only compares
+// range endpoints.
+func (rc rangeConstraint) isSupersetOf(rc2 rangeConstraint) bool {
+ if rc.min != nil {
+ if rc2.min == nil || rc.min.GreaterThan(rc2.min) || (rc.min.Equal(rc2.min) && !rc.includeMin && rc2.includeMin) {
+ return false
+ }
+ }
+
+ if rc.max != nil {
+ if rc2.max == nil || rc.max.LessThan(rc2.max) || (rc.max.Equal(rc2.max) && !rc.includeMax && rc2.includeMax) {
+ return false
+ }
+ }
+
+ return true
+}
+
+func (rc rangeConstraint) String() string {
+ // TODO express using caret or tilde, where applicable
+ var pieces []string
+ if rc.min != nil {
+ if rc.includeMin {
+ pieces = append(pieces, fmt.Sprintf(">=%s", rc.min))
+ } else {
+ pieces = append(pieces, fmt.Sprintf(">%s", rc.min))
+ }
+ }
+
+ if rc.max != nil {
+ if rc.includeMax {
+ pieces = append(pieces, fmt.Sprintf("<=%s", rc.max))
+ } else {
+ pieces = append(pieces, fmt.Sprintf("<%s", rc.max))
+ }
+ }
+
+ for _, e := range rc.excl {
+ pieces = append(pieces, fmt.Sprintf("!=%s", e))
+ }
+
+ return strings.Join(pieces, ", ")
+}
+
+// areAdjacent tests two constraints to determine if they are adjacent,
+// but non-overlapping.
+//
+// If either constraint is not a range, returns false. We still allow it at the
+// type level, however, to make the check convenient elsewhere.
+//
+// Assumes the first range is less than the second; it is incumbent on the
+// caller to arrange the inputs appropriately.
+func areAdjacent(c1, c2 Constraint) bool {
+ var rc1, rc2 rangeConstraint
+ var ok bool
+ if rc1, ok = c1.(rangeConstraint); !ok {
+ return false
+ }
+ if rc2, ok = c2.(rangeConstraint); !ok {
+ return false
+ }
+
+ if !areEq(rc1.max, rc2.min) {
+ return false
+ }
+
+ return (rc1.includeMax && !rc2.includeMin) ||
+ (!rc1.includeMax && rc2.includeMin)
+}
+
+func (rc rangeConstraint) MatchesAny(c Constraint) bool {
+ if _, ok := rc.Intersect(c).(none); ok {
+ return false
+ }
+ return true
+}
+
+func dedupeExcls(ex1, ex2 []*Version) []*Version {
+ // TODO stupid inefficient, but these are really only ever going to be
+ // small, so not worth optimizing right now
+ var ret []*Version
+oloop:
+ for _, e1 := range ex1 {
+ for _, e2 := range ex2 {
+ if e1.Equal(e2) {
+ continue oloop
+ }
+ }
+ ret = append(ret, e1)
+ }
+
+ return append(ret, ex2...)
+}
+
+func (rangeConstraint) _private() {}
+func (rangeConstraint) _real() {}
+
+func areEq(v1, v2 *Version) bool {
+ if v1 == nil && v2 == nil {
+ return true
+ }
+
+ if v1 != nil && v2 != nil {
+ return v1.Equal(v2)
+ }
+ return false
+}
diff --git a/vendor/github.com/Masterminds/semver/set_ops_test.go b/vendor/github.com/Masterminds/semver/set_ops_test.go
new file mode 100644
index 0000000..363e848
--- /dev/null
+++ b/vendor/github.com/Masterminds/semver/set_ops_test.go
@@ -0,0 +1,914 @@
+package semver
+
+import "testing"
+
+func TestIntersection(t *testing.T) {
+ var actual Constraint
+ rc1 := rangeConstraint{
+ min: newV(1, 0, 0),
+ max: newV(2, 0, 0),
+ }
+
+ if actual = Intersection(); !IsNone(actual) {
+ t.Errorf("Intersection of nothing should always produce None; got %q", actual)
+ }
+
+ if actual = Intersection(rc1); !constraintEq(actual, rc1) {
+ t.Errorf("Intersection of one item should always return that item; got %q")
+ }
+
+ if actual = Intersection(rc1, None()); !IsNone(actual) {
+ t.Errorf("Intersection of anything with None should always produce None; got %q", actual)
+ }
+
+ if actual = Intersection(rc1, Any()); !constraintEq(actual, rc1) {
+ t.Errorf("Intersection of anything with Any should return self; got %q", actual)
+ }
+
+ v1 := newV(1, 5, 0)
+ if actual = Intersection(rc1, v1); !constraintEq(actual, v1) {
+ t.Errorf("Got constraint %q, but expected %q", actual, v1)
+ }
+
+ rc2 := rangeConstraint{
+ min: newV(1, 2, 0),
+ max: newV(2, 2, 0),
+ }
+ result := rangeConstraint{
+ min: newV(1, 2, 0),
+ max: newV(2, 0, 0),
+ }
+
+ if actual = Intersection(rc1, rc2); !constraintEq(actual, result) {
+ t.Errorf("Got constraint %q, but expected %q", actual, result)
+ }
+
+ u1 := unionConstraint{
+ rangeConstraint{
+ min: newV(1, 2, 0),
+ max: newV(3, 0, 0),
+ },
+ newV(3, 1, 0),
+ }
+
+ if actual = Intersection(u1, rc1); !constraintEq(actual, result) {
+ t.Errorf("Got constraint %q, but expected %q", actual, result)
+ }
+ if actual = Intersection(rc1, newV(2, 0, 5), u1); !IsNone(actual) {
+ t.Errorf("First two are disjoint, should have gotten None but got %q", actual)
+ }
+}
+
+func TestRangeIntersection(t *testing.T) {
+ var actual Constraint
+ // Test magic cases
+ rc1 := rangeConstraint{
+ min: newV(1, 0, 0),
+ max: newV(2, 0, 0),
+ }
+ if actual = rc1.Intersect(Any()); !constraintEq(actual, rc1) {
+ t.Errorf("Intersection of anything with Any should return self; got %q", actual)
+ }
+ if actual = rc1.Intersect(None()); !IsNone(actual) {
+ t.Errorf("Intersection of anything with None should always produce None; got %q", actual)
+ }
+
+ // Test single version cases
+
+ // single v, in range
+ v1 := newV(1, 5, 0)
+
+ if actual = rc1.Intersect(v1); !constraintEq(actual, v1) {
+ t.Errorf("Intersection of version with matching range should return the version; got %q", actual)
+ }
+
+ // now exclude just that version
+ rc1.excl = []*Version{v1}
+ if actual = rc1.Intersect(v1); !IsNone(actual) {
+ t.Errorf("Intersection of version with range having specific exclude for that version should produce None; got %q", actual)
+ }
+
+ // and, of course, none if the version is out of range
+ v2 := newV(0, 5, 0)
+ if actual = rc1.Intersect(v2); !IsNone(actual) {
+ t.Errorf("Intersection of version with non-matching range should produce None; got %q", actual)
+ }
+
+ // Test basic overlap case
+ rc1 = rangeConstraint{
+ min: newV(1, 0, 0),
+ max: newV(2, 0, 0),
+ }
+ rc2 := rangeConstraint{
+ min: newV(1, 2, 0),
+ max: newV(2, 2, 0),
+ }
+ result := rangeConstraint{
+ min: newV(1, 2, 0),
+ max: newV(2, 0, 0),
+ }
+
+ if actual = rc1.Intersect(rc2); !constraintEq(actual, result) {
+ t.Errorf("Got constraint %q, but expected %q", actual, result)
+ }
+ if actual = rc2.Intersect(rc1); !constraintEq(actual, result) {
+ t.Errorf("Got constraint %q, but expected %q", actual, result)
+ }
+
+ // And with includes
+ rc1.includeMin = true
+ rc1.includeMax = true
+ rc2.includeMin = true
+ rc2.includeMax = true
+ result.includeMin = true
+ result.includeMax = true
+
+ if actual = rc1.Intersect(rc2); !constraintEq(actual, result) {
+ t.Errorf("Got constraint %q, but expected %q", actual, result)
+ }
+ if actual = rc2.Intersect(rc1); !constraintEq(actual, result) {
+ t.Errorf("Got constraint %q, but expected %q", actual, result)
+ }
+
+ // Overlaps with nils
+ rc1 = rangeConstraint{
+ min: newV(1, 0, 0),
+ }
+ rc2 = rangeConstraint{
+ max: newV(2, 2, 0),
+ }
+ result = rangeConstraint{
+ min: newV(1, 0, 0),
+ max: newV(2, 2, 0),
+ }
+
+ if actual = rc1.Intersect(rc2); !constraintEq(actual, result) {
+ t.Errorf("Got constraint %q, but expected %q", actual, result)
+ }
+ if actual = rc2.Intersect(rc1); !constraintEq(actual, result) {
+ t.Errorf("Got constraint %q, but expected %q", actual, result)
+ }
+
+ // And with includes
+ rc1.includeMin = true
+ rc2.includeMax = true
+ result.includeMin = true
+ result.includeMax = true
+
+ if actual = rc1.Intersect(rc2); !constraintEq(actual, result) {
+ t.Errorf("Got constraint %q, but expected %q", actual, result)
+ }
+ if actual = rc2.Intersect(rc1); !constraintEq(actual, result) {
+ t.Errorf("Got constraint %q, but expected %q", actual, result)
+ }
+
+ // Test superset overlap case
+ rc1 = rangeConstraint{
+ min: newV(1, 5, 0),
+ max: newV(2, 0, 0),
+ }
+ rc2 = rangeConstraint{
+ min: newV(1, 0, 0),
+ max: newV(3, 0, 0),
+ }
+ result = rangeConstraint{
+ min: newV(1, 5, 0),
+ max: newV(2, 0, 0),
+ }
+
+ if actual = rc1.Intersect(rc2); !constraintEq(actual, result) {
+ t.Errorf("Got constraint %q, but expected %q", actual, result)
+ }
+ if actual = rc2.Intersect(rc1); !constraintEq(actual, result) {
+ t.Errorf("Got constraint %q, but expected %q", actual, result)
+ }
+
+ // Make sure irrelevant includes don't leak in
+ rc2.includeMin = true
+ rc2.includeMax = true
+
+ if actual = rc1.Intersect(rc2); !constraintEq(actual, result) {
+ t.Errorf("Got constraint %q, but expected %q", actual, result)
+ }
+ if actual = rc2.Intersect(rc1); !constraintEq(actual, result) {
+ t.Errorf("Got constraint %q, but expected %q", actual, result)
+ }
+
+ // But relevant includes get used
+ rc1.includeMin = true
+ rc1.includeMax = true
+ result.includeMin = true
+ result.includeMax = true
+
+ if actual = rc1.Intersect(rc2); !constraintEq(actual, result) {
+ t.Errorf("Got constraint %q, but expected %q", actual, result)
+ }
+ if actual = rc2.Intersect(rc1); !constraintEq(actual, result) {
+ t.Errorf("Got constraint %q, but expected %q", actual, result)
+ }
+
+ // Test disjoint case
+ rc1 = rangeConstraint{
+ min: newV(1, 5, 0),
+ max: newV(1, 6, 0),
+ }
+ rc2 = rangeConstraint{
+ min: newV(2, 0, 0),
+ max: newV(3, 0, 0),
+ }
+
+ if actual = rc1.Intersect(rc2); !constraintEq(actual, None()) {
+ t.Errorf("Got constraint %q, but expected %q", actual, None())
+ }
+ if actual = rc2.Intersect(rc1); !constraintEq(actual, None()) {
+ t.Errorf("Got constraint %q, but expected %q", actual, None())
+ }
+
+ // Test disjoint at gt/lt boundary (non-adjacent)
+ rc1 = rangeConstraint{
+ min: newV(1, 5, 0),
+ max: newV(2, 0, 0),
+ }
+ rc2 = rangeConstraint{
+ min: newV(2, 0, 0),
+ max: newV(3, 0, 0),
+ }
+
+ if actual = rc1.Intersect(rc2); !constraintEq(actual, None()) {
+ t.Errorf("Got constraint %q, but expected %q", actual, None())
+ }
+ if actual = rc2.Intersect(rc1); !constraintEq(actual, None()) {
+ t.Errorf("Got constraint %q, but expected %q", actual, None())
+ }
+
+ // Now, just have them touch at a single version
+ rc1.includeMax = true
+ rc2.includeMin = true
+
+ vresult := newV(2, 0, 0)
+ if actual = rc1.Intersect(rc2); !constraintEq(actual, vresult) {
+ t.Errorf("Got constraint %q, but expected %q", actual, vresult)
+ }
+ if actual = rc2.Intersect(rc1); !constraintEq(actual, vresult) {
+ t.Errorf("Got constraint %q, but expected %q", actual, vresult)
+ }
+
+ // Test excludes in intersection range
+ rc1 = rangeConstraint{
+ min: newV(1, 5, 0),
+ max: newV(2, 0, 0),
+ excl: []*Version{
+ newV(1, 6, 0),
+ },
+ }
+ rc2 = rangeConstraint{
+ min: newV(1, 0, 0),
+ max: newV(3, 0, 0),
+ }
+
+ if actual = rc1.Intersect(rc2); !constraintEq(actual, rc1) {
+ t.Errorf("Got constraint %q, but expected %q", actual, rc1)
+ }
+ if actual = rc2.Intersect(rc1); !constraintEq(actual, rc1) {
+ t.Errorf("Got constraint %q, but expected %q", actual, rc1)
+ }
+
+ // Test excludes not in intersection range
+ rc1 = rangeConstraint{
+ min: newV(1, 5, 0),
+ max: newV(2, 0, 0),
+ }
+ rc2 = rangeConstraint{
+ min: newV(1, 0, 0),
+ max: newV(3, 0, 0),
+ excl: []*Version{
+ newV(1, 1, 0),
+ },
+ }
+
+ if actual = rc1.Intersect(rc2); !constraintEq(actual, rc1) {
+ t.Errorf("Got constraint %q, but expected %q", actual, rc1)
+ }
+ if actual = rc2.Intersect(rc1); !constraintEq(actual, rc1) {
+ t.Errorf("Got constraint %q, but expected %q", actual, rc1)
+ }
+
+ // Test min, and greater min
+ rc1 = rangeConstraint{
+ min: newV(1, 0, 0),
+ }
+ rc2 = rangeConstraint{
+ min: newV(1, 5, 0),
+ includeMin: true,
+ }
+
+ if actual = rc1.Intersect(rc2); !constraintEq(actual, rc2) {
+ t.Errorf("Got constraint %q, but expected %q", actual, result)
+ }
+ if actual = rc2.Intersect(rc1); !constraintEq(actual, rc2) {
+ t.Errorf("Got constraint %q, but expected %q", actual, result)
+ }
+
+ // Test max, and lesser max
+ rc1 = rangeConstraint{
+ max: newV(1, 0, 0),
+ }
+ rc2 = rangeConstraint{
+ max: newV(1, 5, 0),
+ }
+ result = rangeConstraint{
+ max: newV(1, 0, 0),
+ }
+
+ if actual = rc1.Intersect(rc2); !constraintEq(actual, result) {
+ t.Errorf("Got constraint %q, but expected %q", actual, result)
+ }
+ if actual = rc2.Intersect(rc1); !constraintEq(actual, result) {
+ t.Errorf("Got constraint %q, but expected %q", actual, result)
+ }
+
+ // Ensure pure excludes come through as they should
+ rc1 = rangeConstraint{
+ excl: []*Version{
+ newV(1, 6, 0),
+ },
+ }
+
+ rc2 = rangeConstraint{
+ excl: []*Version{
+ newV(1, 6, 0),
+ newV(1, 7, 0),
+ },
+ }
+
+ if actual = Any().Intersect(rc1); !constraintEq(actual, rc1) {
+ t.Errorf("Got constraint %q, but expected %q", actual, rc1)
+ }
+ if actual = rc1.Intersect(Any()); !constraintEq(actual, rc1) {
+ t.Errorf("Got constraint %q, but expected %q", actual, rc1)
+ }
+ if actual = rc1.Intersect(rc2); !constraintEq(actual, rc2) {
+ t.Errorf("Got constraint %q, but expected %q", actual, rc2)
+ }
+
+ // TODO test the pre-release special range stuff
+}
+
+func TestRangeUnion(t *testing.T) {
+ var actual Constraint
+ // Test magic cases
+ rc1 := rangeConstraint{
+ min: newV(1, 0, 0),
+ max: newV(2, 0, 0),
+ }
+ if actual = rc1.Union(Any()); !IsAny(actual) {
+ t.Errorf("Union of anything with Any should always produce Any; got %q", actual)
+ }
+ if actual = rc1.Union(None()); !constraintEq(actual, rc1) {
+ t.Errorf("Union of anything with None should return self; got %q", actual)
+ }
+
+ // Test single version cases
+
+ // single v, in range
+ v1 := newV(1, 5, 0)
+
+ if actual = rc1.Union(v1); !constraintEq(actual, rc1) {
+ t.Errorf("Union of version with matching range should return the range; got %q", actual)
+ }
+
+ // now exclude just that version
+ rc2 := rc1.dup()
+ rc2.excl = []*Version{v1}
+ if actual = rc2.Union(v1); !constraintEq(actual, rc1) {
+ t.Errorf("Union of version with range having specific exclude for that version should produce the range without that exclude; got %q", actual)
+ }
+
+ // and a union if the version is not within the range
+ v2 := newV(0, 5, 0)
+ uresult := unionConstraint{v2, rc1}
+ if actual = rc1.Union(v2); !constraintEq(actual, uresult) {
+ t.Errorf("Union of version with non-matching range should produce a unionConstraint with those two; got %q", actual)
+ }
+
+ // union with version at the min should ensure "oreq"
+ v2 = newV(1, 0, 0)
+ rc3 := rc1
+ rc3.includeMin = true
+
+ if actual = rc1.Union(v2); !constraintEq(actual, rc3) {
+ t.Errorf("Union of range with version at min end should add includeMin (%q), but got %q", rc3, actual)
+ }
+ if actual = v2.Union(rc1); !constraintEq(actual, rc3) {
+ t.Errorf("Union of range with version at min end should add includeMin (%q), but got %q", rc3, actual)
+ }
+
+ // same at max end
+ v2 = newV(2, 0, 0)
+ rc3.includeMin = false
+ rc3.includeMax = true
+
+ if actual = rc1.Union(v2); !constraintEq(actual, rc3) {
+ t.Errorf("Union of range with version at max end should add includeMax (%q), but got %q", rc3, actual)
+ }
+ if actual = v2.Union(rc1); !constraintEq(actual, rc3) {
+ t.Errorf("Union of range with version at max end should add includeMax (%q), but got %q", rc3, actual)
+ }
+
+ // Test basic overlap case
+ rc1 = rangeConstraint{
+ min: newV(1, 0, 0),
+ max: newV(2, 0, 0),
+ }
+ rc2 = rangeConstraint{
+ min: newV(1, 2, 0),
+ max: newV(2, 2, 0),
+ }
+ result := rangeConstraint{
+ min: newV(1, 0, 0),
+ max: newV(2, 2, 0),
+ }
+
+ if actual = rc1.Union(rc2); !constraintEq(actual, result) {
+ t.Errorf("Got constraint %q, but expected %q", actual, result)
+ }
+ if actual = rc2.Union(rc1); !constraintEq(actual, result) {
+ t.Errorf("Got constraint %q, but expected %q", actual, result)
+ }
+
+ // And with includes
+ rc1.includeMin = true
+ rc1.includeMax = true
+ rc2.includeMin = true
+ rc2.includeMax = true
+ result.includeMin = true
+ result.includeMax = true
+
+ if actual = rc1.Union(rc2); !constraintEq(actual, result) {
+ t.Errorf("Got constraint %q, but expected %q", actual, result)
+ }
+ if actual = rc2.Union(rc1); !constraintEq(actual, result) {
+ t.Errorf("Got constraint %q, but expected %q", actual, result)
+ }
+
+ // Overlaps with nils
+ rc1 = rangeConstraint{
+ min: newV(1, 0, 0),
+ }
+ rc2 = rangeConstraint{
+ max: newV(2, 2, 0),
+ }
+
+ if actual = rc1.Union(rc2); !constraintEq(actual, Any()) {
+ t.Errorf("Got constraint %q, but expected %q", actual, Any())
+ }
+ if actual = rc2.Union(rc1); !constraintEq(actual, Any()) {
+ t.Errorf("Got constraint %q, but expected %q", actual, Any())
+ }
+
+ // Just one nil in overlap
+ rc1.max = newV(2, 0, 0)
+ result = rangeConstraint{
+ max: newV(2, 2, 0),
+ }
+
+ if actual = rc1.Union(rc2); !constraintEq(actual, result) {
+ t.Errorf("Got constraint %q, but expected %q", actual, result)
+ }
+ if actual = rc2.Union(rc1); !constraintEq(actual, result) {
+ t.Errorf("Got constraint %q, but expected %q", actual, result)
+ }
+
+ rc1.max = nil
+ rc2.min = newV(1, 5, 0)
+ result = rangeConstraint{
+ min: newV(1, 0, 0),
+ }
+
+ if actual = rc1.Union(rc2); !constraintEq(actual, result) {
+ t.Errorf("Got constraint %q, but expected %q", actual, result)
+ }
+ if actual = rc2.Union(rc1); !constraintEq(actual, result) {
+ t.Errorf("Got constraint %q, but expected %q", actual, result)
+ }
+
+ // Test superset overlap case
+ rc1 = rangeConstraint{
+ min: newV(1, 5, 0),
+ max: newV(2, 0, 0),
+ }
+ rc2 = rangeConstraint{
+ min: newV(1, 0, 0),
+ max: newV(3, 0, 0),
+ }
+
+ if actual = rc1.Union(rc2); !constraintEq(actual, rc2) {
+ t.Errorf("Got constraint %q, but expected %q", actual, rc2)
+ }
+ if actual = rc2.Union(rc1); !constraintEq(actual, rc2) {
+ t.Errorf("Got constraint %q, but expected %q", actual, rc2)
+ }
+
+ // Test disjoint case
+ rc1 = rangeConstraint{
+ min: newV(1, 5, 0),
+ max: newV(1, 6, 0),
+ }
+ rc2 = rangeConstraint{
+ min: newV(2, 0, 0),
+ max: newV(3, 0, 0),
+ }
+ uresult = unionConstraint{rc1, rc2}
+
+ if actual = rc1.Union(rc2); !constraintEq(actual, uresult) {
+ t.Errorf("Got constraint %q, but expected %q", actual, uresult)
+ }
+ if actual = rc2.Union(rc1); !constraintEq(actual, uresult) {
+ t.Errorf("Got constraint %q, but expected %q", actual, uresult)
+ }
+
+ // Test disjoint at gt/lt boundary (non-adjacent)
+ rc1 = rangeConstraint{
+ min: newV(1, 5, 0),
+ max: newV(2, 0, 0),
+ }
+ rc2 = rangeConstraint{
+ min: newV(2, 0, 0),
+ max: newV(3, 0, 0),
+ }
+ uresult = unionConstraint{rc1, rc2}
+
+ if actual = rc1.Union(rc2); !constraintEq(actual, uresult) {
+ t.Errorf("Got constraint %q, but expected %q", actual, uresult)
+ }
+ if actual = rc2.Union(rc1); !constraintEq(actual, uresult) {
+ t.Errorf("Got constraint %q, but expected %q", actual, uresult)
+ }
+
+ // Now, just have them touch at a single version
+ rc1.includeMax = true
+ rc2.includeMin = true
+ result = rangeConstraint{
+ min: newV(1, 5, 0),
+ max: newV(3, 0, 0),
+ }
+
+ if actual = rc1.Union(rc2); !constraintEq(actual, result) {
+ t.Errorf("Got constraint %q, but expected %q", actual, result)
+ }
+ if actual = rc2.Union(rc1); !constraintEq(actual, result) {
+ t.Errorf("Got constraint %q, but expected %q", actual, result)
+ }
+
+ // And top-adjacent at that version
+ rc2.includeMin = false
+ if actual = rc1.Union(rc2); !constraintEq(actual, result) {
+ t.Errorf("Got constraint %q, but expected %q", actual, result)
+ }
+ if actual = rc2.Union(rc1); !constraintEq(actual, result) {
+ t.Errorf("Got constraint %q, but expected %q", actual, result)
+ }
+ // And bottom-adjacent at that version
+ rc1.includeMax = false
+ rc2.includeMin = true
+ if actual = rc1.Union(rc2); !constraintEq(actual, result) {
+ t.Errorf("Got constraint %q, but expected %q", actual, result)
+ }
+ if actual = rc2.Union(rc1); !constraintEq(actual, result) {
+ t.Errorf("Got constraint %q, but expected %q", actual, result)
+ }
+
+ // Test excludes in overlapping range
+ rc1 = rangeConstraint{
+ min: newV(1, 5, 0),
+ max: newV(2, 0, 0),
+ excl: []*Version{
+ newV(1, 6, 0),
+ },
+ }
+ rc2 = rangeConstraint{
+ min: newV(1, 0, 0),
+ max: newV(3, 0, 0),
+ }
+
+ if actual = rc1.Union(rc2); !constraintEq(actual, rc2) {
+ t.Errorf("Got constraint %q, but expected %q", actual, rc2)
+ }
+ if actual = rc2.Union(rc1); !constraintEq(actual, rc2) {
+ t.Errorf("Got constraint %q, but expected %q", actual, rc2)
+ }
+
+ // Test excludes not in non-overlapping range
+ rc1 = rangeConstraint{
+ min: newV(1, 5, 0),
+ max: newV(2, 0, 0),
+ }
+ rc2 = rangeConstraint{
+ min: newV(1, 0, 0),
+ max: newV(3, 0, 0),
+ excl: []*Version{
+ newV(1, 1, 0),
+ },
+ }
+
+ if actual = rc1.Union(rc2); !constraintEq(actual, rc2) {
+ t.Errorf("Got constraint %q, but expected %q", actual, rc2)
+ }
+ if actual = rc2.Union(rc1); !constraintEq(actual, rc2) {
+ t.Errorf("Got constraint %q, but expected %q", actual, rc2)
+ }
+
+ // Ensure pure excludes come through as they should
+ rc1 = rangeConstraint{
+ excl: []*Version{
+ newV(1, 6, 0),
+ },
+ }
+
+ rc2 = rangeConstraint{
+ excl: []*Version{
+ newV(1, 6, 0),
+ newV(1, 7, 0),
+ },
+ }
+
+ if actual = rc1.Union(rc2); !constraintEq(actual, rc1) {
+ t.Errorf("Got constraint %q, but expected %q", actual, rc1)
+ }
+ if actual = rc2.Union(rc1); !constraintEq(actual, rc1) {
+ t.Errorf("Got constraint %q, but expected %q", actual, rc1)
+ }
+
+ rc1 = rangeConstraint{
+ excl: []*Version{
+ newV(1, 5, 0),
+ },
+ }
+
+ if actual = rc1.Union(rc2); !constraintEq(actual, Any()) {
+ t.Errorf("Got constraint %q, but expected %q", actual, Any())
+ }
+ if actual = rc2.Union(rc1); !constraintEq(actual, Any()) {
+ t.Errorf("Got constraint %q, but expected %q", actual, Any())
+ }
+
+ // TODO test the pre-release special range stuff
+}
+
+func TestUnionIntersection(t *testing.T) {
+ var actual Constraint
+ // magic first
+ u1 := unionConstraint{
+ newV(1, 1, 0),
+ newV(1, 2, 0),
+ newV(1, 3, 0),
+ }
+ if actual = u1.Intersect(Any()); !constraintEq(actual, u1) {
+ t.Errorf("Intersection of anything with Any should return self; got %s", actual)
+ }
+ if actual = u1.Intersect(None()); !IsNone(actual) {
+ t.Errorf("Intersection of anything with None should always produce None; got %s", actual)
+ }
+ if u1.MatchesAny(None()) {
+ t.Errorf("Can't match any when intersected with None")
+ }
+
+ // intersect of unions with single versions
+ v1 := newV(1, 1, 0)
+ if actual = u1.Intersect(v1); !constraintEq(actual, v1) {
+ t.Errorf("Got constraint %q, but expected %q", actual, v1)
+ }
+ if actual = v1.Intersect(u1); !constraintEq(actual, v1) {
+ t.Errorf("Got constraint %q, but expected %q", actual, v1)
+ }
+
+ // intersect of range with union of versions
+ u1 = unionConstraint{
+ newV(1, 1, 0),
+ newV(1, 2, 0),
+ newV(1, 3, 0),
+ }
+ rc1 := rangeConstraint{
+ min: newV(1, 0, 0),
+ max: newV(2, 0, 0),
+ }
+
+ if actual = u1.Intersect(rc1); !constraintEq(actual, u1) {
+ t.Errorf("Got constraint %q, but expected %q", actual, u1)
+ }
+ if actual = rc1.Intersect(u1); !constraintEq(actual, u1) {
+ t.Errorf("Got constraint %q, but expected %q", actual, u1)
+ }
+
+ u2 := unionConstraint{
+ newV(1, 1, 0),
+ newV(1, 2, 0),
+ }
+
+ if actual = u1.Intersect(u2); !constraintEq(actual, u2) {
+ t.Errorf("Got constraint %q, but expected %q", actual, u2)
+ }
+
+ // Overlapping sub/supersets
+ rc1 = rangeConstraint{
+ min: newV(1, 5, 0),
+ max: newV(1, 6, 0),
+ }
+ rc2 := rangeConstraint{
+ min: newV(2, 0, 0),
+ max: newV(3, 0, 0),
+ }
+ rc3 = rangeConstraint{
+ min: newV(1, 0, 0),
+ max: newV(2, 0, 0),
+ }
+ rc4 := rangeConstraint{
+ min: newV(2, 5, 0),
+ max: newV(2, 6, 0),
+ }
+ u1 = unionConstraint{rc1, rc2}
+ u2 = unionConstraint{rc3, rc4}
+ ur := unionConstraint{rc1, rc4}
+
+ if actual = u1.Intersect(u2); !constraintEq(actual, ur) {
+ t.Errorf("Got constraint %q, but expected %q", actual, ur)
+ }
+ if actual = u2.Intersect(u1); !constraintEq(actual, ur) {
+ t.Errorf("Got constraint %q, but expected %q", actual, ur)
+ }
+
+ // Ensure excludes carry as they should
+ rc1.excl = []*Version{newV(1, 5, 5)}
+ u1 = unionConstraint{rc1, rc2}
+ ur = unionConstraint{rc1, rc4}
+
+ if actual = u1.Intersect(u2); !constraintEq(actual, ur) {
+ t.Errorf("Got constraint %q, but expected %q", actual, ur)
+ }
+ if actual = u2.Intersect(u1); !constraintEq(actual, ur) {
+ t.Errorf("Got constraint %q, but expected %q", actual, ur)
+ }
+}
+
+func TestUnionUnion(t *testing.T) {
+ var actual Constraint
+ // magic first
+ u1 := unionConstraint{
+ newV(1, 1, 0),
+ newV(1, 2, 0),
+ newV(1, 3, 0),
+ }
+ if actual = u1.Union(Any()); !IsAny(actual) {
+ t.Errorf("Union of anything with Any should always return Any; got %s", actual)
+ }
+ if actual = u1.Union(None()); !constraintEq(actual, u1) {
+ t.Errorf("Union of anything with None should always return self; got %s", actual)
+ }
+
+ // union of uc with single versions
+ // already present
+ v1 := newV(1, 2, 0)
+ if actual = u1.Union(v1); !constraintEq(actual, u1) {
+ t.Errorf("Got constraint %q, but expected %q", actual, u1)
+ }
+ if actual = v1.Union(u1); !constraintEq(actual, u1) {
+ t.Errorf("Got constraint %q, but expected %q", actual, u1)
+ }
+
+ // not present
+ v2 := newV(1, 4, 0)
+ ur := append(u1, v2)
+ if actual = u1.Union(v2); !constraintEq(actual, ur) {
+ t.Errorf("Got constraint %q, but expected %q", actual, ur)
+ }
+ if actual = v2.Union(u1); !constraintEq(actual, ur) {
+ t.Errorf("Got constraint %q, but expected %q", actual, ur)
+ }
+
+ // union of uc with uc, all versions
+ u2 := unionConstraint{
+ newV(1, 3, 0),
+ newV(1, 4, 0),
+ newV(1, 5, 0),
+ }
+ ur = unionConstraint{
+ newV(1, 1, 0),
+ newV(1, 2, 0),
+ newV(1, 3, 0),
+ newV(1, 4, 0),
+ newV(1, 5, 0),
+ }
+
+ if actual = u1.Union(u2); !constraintEq(actual, ur) {
+ t.Errorf("Got constraint %q, but expected %q", actual, ur)
+ }
+ if actual = u2.Union(u1); !constraintEq(actual, ur) {
+ t.Errorf("Got constraint %q, but expected %q", actual, ur)
+ }
+
+ // union that should compress versions into range
+ rc1 := rangeConstraint{
+ min: newV(1, 0, 0),
+ max: newV(2, 0, 0),
+ }
+
+ if actual = u1.Union(rc1); !constraintEq(actual, rc1) {
+ t.Errorf("Got constraint %q, but expected %q", actual, rc1)
+ }
+ if actual = rc1.Union(u1); !constraintEq(actual, rc1) {
+ t.Errorf("Got constraint %q, but expected %q", actual, rc1)
+ }
+
+ rc1.max = newV(1, 4, 5)
+ u3 := append(u2, newV(1, 7, 0))
+ ur = unionConstraint{
+ rc1,
+ newV(1, 5, 0),
+ newV(1, 7, 0),
+ }
+
+ if actual = u3.Union(rc1); !constraintEq(actual, ur) {
+ t.Errorf("Got constraint %q, but expected %q", actual, ur)
+ }
+ if actual = rc1.Union(u3); !constraintEq(actual, ur) {
+ t.Errorf("Got constraint %q, but expected %q", actual, ur)
+ }
+}
+
+// Most version stuff got tested by range and/or union b/c most tests were
+// repeated bidirectionally (set operations are commutative; testing in pairs
+// helps us catch any situation where we fail to maintain that invariant)
+func TestVersionSetOps(t *testing.T) {
+ var actual Constraint
+
+ v1 := newV(1, 0, 0)
+
+ if actual = v1.Intersect(v1); !constraintEq(actual, v1) {
+ t.Errorf("Version intersected with itself should be itself, got %q", actual)
+ }
+ if !v1.MatchesAny(v1) {
+ t.Errorf("MatchesAny should work with a version against itself")
+ }
+
+ v2 := newV(2, 0, 0)
+ if actual = v1.Intersect(v2); !IsNone(actual) {
+ t.Errorf("Versions should only intersect with themselves, got %q", actual)
+ }
+ if v1.MatchesAny(v2) {
+ t.Errorf("MatchesAny should not work when combined with anything other than itself")
+ }
+
+ result := unionConstraint{v1, v2}
+
+ if actual = v1.Union(v1); !constraintEq(actual, v1) {
+ t.Errorf("Version union with itself should return self, got %q", actual)
+ }
+
+ if actual = v1.Union(v2); !constraintEq(actual, result) {
+ t.Errorf("Got constraint %q, but expected %q", actual, result)
+ }
+ if actual = v1.Union(v2); !constraintEq(actual, result) {
+ // Duplicate just to make sure ordering works right
+ t.Errorf("Got constraint %q, but expected %q", actual, result)
+ }
+}
+
+func TestAreAdjacent(t *testing.T) {
+ rc1 := rangeConstraint{
+ min: newV(1, 0, 0),
+ max: newV(2, 0, 0),
+ }
+ rc2 := rangeConstraint{
+ min: newV(1, 2, 0),
+ max: newV(2, 2, 0),
+ }
+
+ if areAdjacent(rc1, rc2) {
+ t.Errorf("Ranges overlap, should not indicate as adjacent")
+ }
+
+ rc2 = rangeConstraint{
+ min: newV(2, 0, 0),
+ }
+
+ if areAdjacent(rc1, rc2) {
+ t.Errorf("Ranges are non-overlapping and non-adjacent, but reported as adjacent")
+ }
+
+ rc2.includeMin = true
+
+ if !areAdjacent(rc1, rc2) {
+ t.Errorf("Ranges are non-overlapping and adjacent, but reported as non-adjacent")
+ }
+
+ rc1.includeMax = true
+
+ if areAdjacent(rc1, rc2) {
+ t.Errorf("Ranges are overlapping at a single version, but reported as adjacent")
+ }
+
+ rc2.includeMin = false
+ if !areAdjacent(rc1, rc2) {
+ t.Errorf("Ranges are non-overlapping and adjacent, but reported as non-adjacent")
+ }
+}
diff --git a/vendor/github.com/Masterminds/semver/union.go b/vendor/github.com/Masterminds/semver/union.go
new file mode 100644
index 0000000..2659828
--- /dev/null
+++ b/vendor/github.com/Masterminds/semver/union.go
@@ -0,0 +1,141 @@
+package semver
+
+import "strings"
+
+type unionConstraint []realConstraint
+
+func (uc unionConstraint) Matches(v *Version) error {
+ var uce MultiMatchFailure
+ for _, c := range uc {
+ if err := c.Matches(v); err == nil {
+ return nil
+ } else {
+ uce = append(uce, err.(MatchFailure))
+ }
+ }
+
+ return uce
+}
+
+func (uc unionConstraint) Intersect(c2 Constraint) Constraint {
+ var other []realConstraint
+
+ switch tc2 := c2.(type) {
+ case none:
+ return None()
+ case any:
+ return uc
+ case *Version:
+ return c2
+ case rangeConstraint:
+ other = append(other, tc2)
+ case unionConstraint:
+ other = c2.(unionConstraint)
+ default:
+ panic("unknown type")
+ }
+
+ var newc []Constraint
+ // TODO there's a smarter way to do this than NxN, but...worth it?
+ for _, c := range uc {
+ for _, oc := range other {
+ i := c.Intersect(oc)
+ if !IsNone(i) {
+ newc = append(newc, i)
+ }
+ }
+ }
+
+ return Union(newc...)
+}
+
+func (uc unionConstraint) MatchesAny(c Constraint) bool {
+ for _, ic := range uc {
+ if ic.MatchesAny(c) {
+ return true
+ }
+ }
+ return false
+}
+
+func (uc unionConstraint) Union(c Constraint) Constraint {
+ return Union(uc, c)
+}
+
+func (uc unionConstraint) String() string {
+ var pieces []string
+ for _, c := range uc {
+ pieces = append(pieces, c.String())
+ }
+
+ return strings.Join(pieces, " || ")
+}
+func (unionConstraint) _private() {}
+
+type constraintList []realConstraint
+
+func (cl constraintList) Len() int {
+ return len(cl)
+}
+
+func (cl constraintList) Swap(i, j int) {
+ cl[i], cl[j] = cl[j], cl[i]
+}
+
+func (cl constraintList) Less(i, j int) bool {
+ ic, jc := cl[i], cl[j]
+
+ switch tic := ic.(type) {
+ case *Version:
+ switch tjc := jc.(type) {
+ case *Version:
+ return tic.LessThan(tjc)
+ case rangeConstraint:
+ if tjc.min == nil {
+ return false
+ }
+
+ // Because we don't assume stable sort, always put versions ahead of
+ // range mins if they're equal and includeMin is on
+ if tjc.includeMin && tic.Equal(tjc.min) {
+ return false
+ }
+ return tic.LessThan(tjc.min)
+ }
+ case rangeConstraint:
+ switch tjc := jc.(type) {
+ case *Version:
+ if tic.min == nil {
+ return true
+ }
+
+ // Because we don't assume stable sort, always put versions ahead of
+ // range mins if they're equal and includeMin is on
+ if tic.includeMin && tjc.Equal(tic.min) {
+ return false
+ }
+ return tic.min.LessThan(tjc)
+ case rangeConstraint:
+ if tic.min == nil {
+ return true
+ }
+ if tjc.min == nil {
+ return false
+ }
+ return tic.min.LessThan(tjc.min)
+ }
+ }
+
+ panic("unreachable")
+}
+
+func (cl *constraintList) Push(x interface{}) {
+ *cl = append(*cl, x.(realConstraint))
+}
+
+func (cl *constraintList) Pop() interface{} {
+ o := *cl
+ c := o[len(o)-1]
+ *cl = o[:len(o)-1]
+ return c
+}
diff --git a/vendor/github.com/Masterminds/semver/version.go b/vendor/github.com/Masterminds/semver/version.go
index dbb93f8..e9261ca 100644
--- a/vendor/github.com/Masterminds/semver/version.go
+++ b/vendor/github.com/Masterminds/semver/version.go
@@ -7,6 +7,7 @@
"regexp"
"strconv"
"strings"
+ "sync"
)
// The compiled version of the regex created at init() is cached here so it
@@ -19,6 +20,25 @@
ErrInvalidSemVer = errors.New("Invalid Semantic Version")
)
+// Error type; lets us defer string interpolation
+type badVersionSegment struct {
+ e error
+}
+
+func (b badVersionSegment) Error() string {
+ return fmt.Sprintf("Error parsing version segment: %s", b.e)
+}
+
+// Controls whether or not parsed constraints are cached
+var CacheVersions = true
+var versionCache = make(map[string]vcache)
+var versionCacheLock sync.RWMutex
+
+type vcache struct {
+ v *Version
+ err error
+}
+
// SemVerRegex id the regular expression used to parse a semantic version.
const SemVerRegex string = `v?([0-9]+)(\.[0-9]+)?(\.[0-9]+)?` +
`(-([0-9A-Za-z\-]+(\.[0-9A-Za-z\-]+)*))?` +
@@ -39,8 +59,22 @@
// NewVersion parses a given version and returns an instance of Version or
// an error if unable to parse the version.
func NewVersion(v string) (*Version, error) {
+ if CacheVersions {
+ versionCacheLock.RLock()
+ if sv, exists := versionCache[v]; exists {
+ versionCacheLock.RUnlock()
+ return sv.v, sv.err
+ }
+ versionCacheLock.RUnlock()
+ }
+
m := versionRegex.FindStringSubmatch(v)
if m == nil {
+ if CacheVersions {
+ versionCacheLock.Lock()
+ versionCache[v] = vcache{err: ErrInvalidSemVer}
+ versionCacheLock.Unlock()
+ }
return nil, ErrInvalidSemVer
}
@@ -53,14 +87,28 @@
var temp int64
temp, err := strconv.ParseInt(m[1], 10, 32)
if err != nil {
- return nil, fmt.Errorf("Error parsing version segment: %s", err)
+ bvs := badVersionSegment{e: err}
+ if CacheVersions {
+ versionCacheLock.Lock()
+ versionCache[v] = vcache{err: bvs}
+ versionCacheLock.Unlock()
+ }
+
+ return nil, bvs
}
sv.major = temp
if m[2] != "" {
temp, err = strconv.ParseInt(strings.TrimPrefix(m[2], "."), 10, 32)
if err != nil {
- return nil, fmt.Errorf("Error parsing version segment: %s", err)
+ bvs := badVersionSegment{e: err}
+ if CacheVersions {
+ versionCacheLock.Lock()
+ versionCache[v] = vcache{err: bvs}
+ versionCacheLock.Unlock()
+ }
+
+ return nil, bvs
}
sv.minor = temp
} else {
@@ -70,13 +118,26 @@
if m[3] != "" {
temp, err = strconv.ParseInt(strings.TrimPrefix(m[3], "."), 10, 32)
if err != nil {
- return nil, fmt.Errorf("Error parsing version segment: %s", err)
+ bvs := badVersionSegment{e: err}
+ if CacheVersions {
+ versionCacheLock.Lock()
+ versionCache[v] = vcache{err: bvs}
+ versionCacheLock.Unlock()
+ }
+
+ return nil, bvs
}
sv.patch = temp
} else {
sv.patch = 0
}
+ if CacheVersions {
+ versionCacheLock.Lock()
+ versionCache[v] = vcache{v: sv}
+ versionCacheLock.Unlock()
+ }
+
return sv, nil
}
@@ -131,11 +192,21 @@
// LessThan tests if one version is less than another one.
func (v *Version) LessThan(o *Version) bool {
+ // If a nil version was passed, fail and bail out early.
+ if o == nil {
+ return false
+ }
+
return v.Compare(o) < 0
}
// GreaterThan tests if one version is greater than another one.
func (v *Version) GreaterThan(o *Version) bool {
+ // If a nil version was passed, fail and bail out early.
+ if o == nil {
+ return false
+ }
+
return v.Compare(o) > 0
}
@@ -143,6 +214,11 @@
// Note, versions can be equal with different metadata since metadata
// is not considered part of the comparable version.
func (v *Version) Equal(o *Version) bool {
+ // If a nil version was passed, fail and bail out early.
+ if o == nil {
+ return false
+ }
+
return v.Compare(o) == 0
}
@@ -181,6 +257,46 @@
return comparePrerelease(ps, po)
}
+func (v *Version) Matches(v2 *Version) error {
+ if v.Equal(v2) {
+ return nil
+ }
+
+ return VersionMatchFailure{v: v, other: v2}
+}
+
+func (v *Version) MatchesAny(c Constraint) bool {
+ if v2, ok := c.(*Version); ok {
+ return v.Equal(v2)
+ } else {
+ // The other implementations all have specific handling for this; fall
+ // back on theirs.
+ return c.MatchesAny(v)
+ }
+}
+
+func (v *Version) Intersect(c Constraint) Constraint {
+ if v2, ok := c.(*Version); ok {
+ if v.Equal(v2) {
+ return v
+ }
+ return none{}
+ }
+
+ return c.Intersect(v)
+}
+
+func (v *Version) Union(c Constraint) Constraint {
+ if v2, ok := c.(*Version); ok && v.Equal(v2) {
+ return v
+ } else {
+ return Union(v, c)
+ }
+}
+
+func (Version) _private() {}
+func (Version) _real() {}
+
func compareSegment(v, o int64) int {
if v < o {
return -1
diff --git a/vendor/github.com/armon/go-radix/.gitignore b/vendor/github.com/armon/go-radix/.gitignore
new file mode 100644
index 0000000..0026861
--- /dev/null
+++ b/vendor/github.com/armon/go-radix/.gitignore
@@ -0,0 +1,22 @@
+# Compiled Object files, Static and Dynamic libs (Shared Objects)
+*.o
+*.a
+*.so
+
+# Folders
+_obj
+_test
+
+# Architecture specific extensions/prefixes
+*.[568vq]
+[568vq].out
+
+*.cgo1.go
+*.cgo2.c
+_cgo_defun.c
+_cgo_gotypes.go
+_cgo_export.*
+
+_testmain.go
+
+*.exe
diff --git a/vendor/github.com/armon/go-radix/.travis.yml b/vendor/github.com/armon/go-radix/.travis.yml
new file mode 100644
index 0000000..1a0bbea
--- /dev/null
+++ b/vendor/github.com/armon/go-radix/.travis.yml
@@ -0,0 +1,3 @@
+language: go
+go:
+ - tip
diff --git a/vendor/github.com/armon/go-radix/LICENSE b/vendor/github.com/armon/go-radix/LICENSE
new file mode 100644
index 0000000..a5df10e
--- /dev/null
+++ b/vendor/github.com/armon/go-radix/LICENSE
@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Armon Dadgar
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/vendor/github.com/armon/go-radix/README.md b/vendor/github.com/armon/go-radix/README.md
new file mode 100644
index 0000000..26f42a2
--- /dev/null
+++ b/vendor/github.com/armon/go-radix/README.md
@@ -0,0 +1,38 @@
+go-radix [](https://travis-ci.org/armon/go-radix)
+=========
+
+Provides the `radix` package that implements a [radix tree](http://en.wikipedia.org/wiki/Radix_tree).
+The package only provides a single `Tree` implementation, optimized for sparse nodes.
+
+As a radix tree, it provides the following:
+ * O(k) operations. In many cases, this can be faster than a hash table since
+ the hash function is an O(k) operation, and hash tables have very poor cache locality.
+ * Minimum / Maximum value lookups
+ * Ordered iteration
+
+For an immutable variant, see [go-immutable-radix](https://github.com/hashicorp/go-immutable-radix).
+
+Documentation
+=============
+
+The full documentation is available on [Godoc](http://godoc.org/github.com/armon/go-radix).
+
+Example
+=======
+
+Below is a simple example of usage
+
+```go
+// Create a tree
+r := radix.New()
+r.Insert("foo", 1)
+r.Insert("bar", 2)
+r.Insert("foobar", 2)
+
+// Find the longest prefix match
+m, _, _ := r.LongestPrefix("foozip")
+if m != "foo" {
+ panic("should be foo")
+}
+```
+
diff --git a/vendor/github.com/armon/go-radix/radix.go b/vendor/github.com/armon/go-radix/radix.go
new file mode 100644
index 0000000..d2914c1
--- /dev/null
+++ b/vendor/github.com/armon/go-radix/radix.go
@@ -0,0 +1,496 @@
+package radix
+
+import (
+ "sort"
+ "strings"
+)
+
+// WalkFn is used when walking the tree. Takes a
+// key and value, returning if iteration should
+// be terminated.
+type WalkFn func(s string, v interface{}) bool
+
+// leafNode is used to represent a value
+type leafNode struct {
+ key string
+ val interface{}
+}
+
+// edge is used to represent an edge node
+type edge struct {
+ label byte
+ node *node
+}
+
+type node struct {
+ // leaf is used to store possible leaf
+ leaf *leafNode
+
+ // prefix is the common prefix we ignore
+ prefix string
+
+ // Edges should be stored in-order for iteration.
+ // We avoid a fully materialized slice to save memory,
+ // since in most cases we expect to be sparse
+ edges edges
+}
+
+func (n *node) isLeaf() bool {
+ return n.leaf != nil
+}
+
+func (n *node) addEdge(e edge) {
+ n.edges = append(n.edges, e)
+ n.edges.Sort()
+}
+
+func (n *node) replaceEdge(e edge) {
+ num := len(n.edges)
+ idx := sort.Search(num, func(i int) bool {
+ return n.edges[i].label >= e.label
+ })
+ if idx < num && n.edges[idx].label == e.label {
+ n.edges[idx].node = e.node
+ return
+ }
+ panic("replacing missing edge")
+}
+
+func (n *node) getEdge(label byte) *node {
+ num := len(n.edges)
+ idx := sort.Search(num, func(i int) bool {
+ return n.edges[i].label >= label
+ })
+ if idx < num && n.edges[idx].label == label {
+ return n.edges[idx].node
+ }
+ return nil
+}
+
+func (n *node) delEdge(label byte) {
+ num := len(n.edges)
+ idx := sort.Search(num, func(i int) bool {
+ return n.edges[i].label >= label
+ })
+ if idx < num && n.edges[idx].label == label {
+ copy(n.edges[idx:], n.edges[idx+1:])
+ n.edges[len(n.edges)-1] = edge{}
+ n.edges = n.edges[:len(n.edges)-1]
+ }
+}
+
+type edges []edge
+
+func (e edges) Len() int {
+ return len(e)
+}
+
+func (e edges) Less(i, j int) bool {
+ return e[i].label < e[j].label
+}
+
+func (e edges) Swap(i, j int) {
+ e[i], e[j] = e[j], e[i]
+}
+
+func (e edges) Sort() {
+ sort.Sort(e)
+}
+
+// Tree implements a radix tree. This can be treated as a
+// Dictionary abstract data type. The main advantage over
+// a standard hash map is prefix-based lookups and
+// ordered iteration,
+type Tree struct {
+ root *node
+ size int
+}
+
+// New returns an empty Tree
+func New() *Tree {
+ return NewFromMap(nil)
+}
+
+// NewFromMap returns a new tree containing the keys
+// from an existing map
+func NewFromMap(m map[string]interface{}) *Tree {
+ t := &Tree{root: &node{}}
+ for k, v := range m {
+ t.Insert(k, v)
+ }
+ return t
+}
+
+// Len is used to return the number of elements in the tree
+func (t *Tree) Len() int {
+ return t.size
+}
+
+// longestPrefix finds the length of the shared prefix
+// of two strings
+func longestPrefix(k1, k2 string) int {
+ max := len(k1)
+ if l := len(k2); l < max {
+ max = l
+ }
+ var i int
+ for i = 0; i < max; i++ {
+ if k1[i] != k2[i] {
+ break
+ }
+ }
+ return i
+}
+
+// Insert is used to add a newentry or update
+// an existing entry. Returns if updated.
+func (t *Tree) Insert(s string, v interface{}) (interface{}, bool) {
+ var parent *node
+ n := t.root
+ search := s
+ for {
+ // Handle key exhaution
+ if len(search) == 0 {
+ if n.isLeaf() {
+ old := n.leaf.val
+ n.leaf.val = v
+ return old, true
+ }
+
+ n.leaf = &leafNode{
+ key: s,
+ val: v,
+ }
+ t.size++
+ return nil, false
+ }
+
+ // Look for the edge
+ parent = n
+ n = n.getEdge(search[0])
+
+ // No edge, create one
+ if n == nil {
+ e := edge{
+ label: search[0],
+ node: &node{
+ leaf: &leafNode{
+ key: s,
+ val: v,
+ },
+ prefix: search,
+ },
+ }
+ parent.addEdge(e)
+ t.size++
+ return nil, false
+ }
+
+ // Determine longest prefix of the search key on match
+ commonPrefix := longestPrefix(search, n.prefix)
+ if commonPrefix == len(n.prefix) {
+ search = search[commonPrefix:]
+ continue
+ }
+
+ // Split the node
+ t.size++
+ child := &node{
+ prefix: search[:commonPrefix],
+ }
+ parent.replaceEdge(edge{
+ label: search[0],
+ node: child,
+ })
+
+ // Restore the existing node
+ child.addEdge(edge{
+ label: n.prefix[commonPrefix],
+ node: n,
+ })
+ n.prefix = n.prefix[commonPrefix:]
+
+ // Create a new leaf node
+ leaf := &leafNode{
+ key: s,
+ val: v,
+ }
+
+ // If the new key is a subset, add to to this node
+ search = search[commonPrefix:]
+ if len(search) == 0 {
+ child.leaf = leaf
+ return nil, false
+ }
+
+ // Create a new edge for the node
+ child.addEdge(edge{
+ label: search[0],
+ node: &node{
+ leaf: leaf,
+ prefix: search,
+ },
+ })
+ return nil, false
+ }
+}
+
+// Delete is used to delete a key, returning the previous
+// value and if it was deleted
+func (t *Tree) Delete(s string) (interface{}, bool) {
+ var parent *node
+ var label byte
+ n := t.root
+ search := s
+ for {
+ // Check for key exhaution
+ if len(search) == 0 {
+ if !n.isLeaf() {
+ break
+ }
+ goto DELETE
+ }
+
+ // Look for an edge
+ parent = n
+ label = search[0]
+ n = n.getEdge(label)
+ if n == nil {
+ break
+ }
+
+ // Consume the search prefix
+ if strings.HasPrefix(search, n.prefix) {
+ search = search[len(n.prefix):]
+ } else {
+ break
+ }
+ }
+ return nil, false
+
+DELETE:
+ // Delete the leaf
+ leaf := n.leaf
+ n.leaf = nil
+ t.size--
+
+ // Check if we should delete this node from the parent
+ if parent != nil && len(n.edges) == 0 {
+ parent.delEdge(label)
+ }
+
+ // Check if we should merge this node
+ if n != t.root && len(n.edges) == 1 {
+ n.mergeChild()
+ }
+
+ // Check if we should merge the parent's other child
+ if parent != nil && parent != t.root && len(parent.edges) == 1 && !parent.isLeaf() {
+ parent.mergeChild()
+ }
+
+ return leaf.val, true
+}
+
+func (n *node) mergeChild() {
+ e := n.edges[0]
+ child := e.node
+ n.prefix = n.prefix + child.prefix
+ n.leaf = child.leaf
+ n.edges = child.edges
+}
+
+// Get is used to lookup a specific key, returning
+// the value and if it was found
+func (t *Tree) Get(s string) (interface{}, bool) {
+ n := t.root
+ search := s
+ for {
+ // Check for key exhaution
+ if len(search) == 0 {
+ if n.isLeaf() {
+ return n.leaf.val, true
+ }
+ break
+ }
+
+ // Look for an edge
+ n = n.getEdge(search[0])
+ if n == nil {
+ break
+ }
+
+ // Consume the search prefix
+ if strings.HasPrefix(search, n.prefix) {
+ search = search[len(n.prefix):]
+ } else {
+ break
+ }
+ }
+ return nil, false
+}
+
+// LongestPrefix is like Get, but instead of an
+// exact match, it will return the longest prefix match.
+func (t *Tree) LongestPrefix(s string) (string, interface{}, bool) {
+ var last *leafNode
+ n := t.root
+ search := s
+ for {
+ // Look for a leaf node
+ if n.isLeaf() {
+ last = n.leaf
+ }
+
+ // Check for key exhaution
+ if len(search) == 0 {
+ break
+ }
+
+ // Look for an edge
+ n = n.getEdge(search[0])
+ if n == nil {
+ break
+ }
+
+ // Consume the search prefix
+ if strings.HasPrefix(search, n.prefix) {
+ search = search[len(n.prefix):]
+ } else {
+ break
+ }
+ }
+ if last != nil {
+ return last.key, last.val, true
+ }
+ return "", nil, false
+}
+
+// Minimum is used to return the minimum value in the tree
+func (t *Tree) Minimum() (string, interface{}, bool) {
+ n := t.root
+ for {
+ if n.isLeaf() {
+ return n.leaf.key, n.leaf.val, true
+ }
+ if len(n.edges) > 0 {
+ n = n.edges[0].node
+ } else {
+ break
+ }
+ }
+ return "", nil, false
+}
+
+// Maximum is used to return the maximum value in the tree
+func (t *Tree) Maximum() (string, interface{}, bool) {
+ n := t.root
+ for {
+ if num := len(n.edges); num > 0 {
+ n = n.edges[num-1].node
+ continue
+ }
+ if n.isLeaf() {
+ return n.leaf.key, n.leaf.val, true
+ }
+ break
+ }
+ return "", nil, false
+}
+
+// Walk is used to walk the tree
+func (t *Tree) Walk(fn WalkFn) {
+ recursiveWalk(t.root, fn)
+}
+
+// WalkPrefix is used to walk the tree under a prefix
+func (t *Tree) WalkPrefix(prefix string, fn WalkFn) {
+ n := t.root
+ search := prefix
+ for {
+ // Check for key exhaution
+ if len(search) == 0 {
+ recursiveWalk(n, fn)
+ return
+ }
+
+ // Look for an edge
+ n = n.getEdge(search[0])
+ if n == nil {
+ break
+ }
+
+ // Consume the search prefix
+ if strings.HasPrefix(search, n.prefix) {
+ search = search[len(n.prefix):]
+
+ } else if strings.HasPrefix(n.prefix, search) {
+ // Child may be under our search prefix
+ recursiveWalk(n, fn)
+ return
+ } else {
+ break
+ }
+ }
+
+}
+
+// WalkPath is used to walk the tree, but only visiting nodes
+// from the root down to a given leaf. Where WalkPrefix walks
+// all the entries *under* the given prefix, this walks the
+// entries *above* the given prefix.
+func (t *Tree) WalkPath(path string, fn WalkFn) {
+ n := t.root
+ search := path
+ for {
+ // Visit the leaf values if any
+ if n.leaf != nil && fn(n.leaf.key, n.leaf.val) {
+ return
+ }
+
+ // Check for key exhaution
+ if len(search) == 0 {
+ return
+ }
+
+ // Look for an edge
+ n = n.getEdge(search[0])
+ if n == nil {
+ return
+ }
+
+ // Consume the search prefix
+ if strings.HasPrefix(search, n.prefix) {
+ search = search[len(n.prefix):]
+ } else {
+ break
+ }
+ }
+}
+
+// recursiveWalk is used to do a pre-order walk of a node
+// recursively. Returns true if the walk should be aborted
+func recursiveWalk(n *node, fn WalkFn) bool {
+ // Visit the leaf values if any
+ if n.leaf != nil && fn(n.leaf.key, n.leaf.val) {
+ return true
+ }
+
+ // Recurse on the children
+ for _, e := range n.edges {
+ if recursiveWalk(e.node, fn) {
+ return true
+ }
+ }
+ return false
+}
+
+// ToMap is used to walk the tree and convert it into a map
+func (t *Tree) ToMap() map[string]interface{} {
+ out := make(map[string]interface{}, t.size)
+ t.Walk(func(k string, v interface{}) bool {
+ out[k] = v
+ return false
+ })
+ return out
+}
diff --git a/vendor/github.com/armon/go-radix/radix_test.go b/vendor/github.com/armon/go-radix/radix_test.go
new file mode 100644
index 0000000..300f0d4
--- /dev/null
+++ b/vendor/github.com/armon/go-radix/radix_test.go
@@ -0,0 +1,319 @@
+package radix
+
+import (
+ crand "crypto/rand"
+ "fmt"
+ "reflect"
+ "sort"
+ "testing"
+)
+
+func TestRadix(t *testing.T) {
+ var min, max string
+ inp := make(map[string]interface{})
+ for i := 0; i < 1000; i++ {
+ gen := generateUUID()
+ inp[gen] = i
+ if gen < min || i == 0 {
+ min = gen
+ }
+ if gen > max || i == 0 {
+ max = gen
+ }
+ }
+
+ r := NewFromMap(inp)
+ if r.Len() != len(inp) {
+ t.Fatalf("bad length: %v %v", r.Len(), len(inp))
+ }
+
+ r.Walk(func(k string, v interface{}) bool {
+ println(k)
+ return false
+ })
+
+ for k, v := range inp {
+ out, ok := r.Get(k)
+ if !ok {
+ t.Fatalf("missing key: %v", k)
+ }
+ if out != v {
+ t.Fatalf("value mis-match: %v %v", out, v)
+ }
+ }
+
+ // Check min and max
+ outMin, _, _ := r.Minimum()
+ if outMin != min {
+ t.Fatalf("bad minimum: %v %v", outMin, min)
+ }
+ outMax, _, _ := r.Maximum()
+ if outMax != max {
+ t.Fatalf("bad maximum: %v %v", outMax, max)
+ }
+
+ for k, v := range inp {
+ out, ok := r.Delete(k)
+ if !ok {
+ t.Fatalf("missing key: %v", k)
+ }
+ if out != v {
+ t.Fatalf("value mis-match: %v %v", out, v)
+ }
+ }
+ if r.Len() != 0 {
+ t.Fatalf("bad length: %v", r.Len())
+ }
+}
+
+func TestRoot(t *testing.T) {
+ r := New()
+ _, ok := r.Delete("")
+ if ok {
+ t.Fatalf("bad")
+ }
+ _, ok = r.Insert("", true)
+ if ok {
+ t.Fatalf("bad")
+ }
+ val, ok := r.Get("")
+ if !ok || val != true {
+ t.Fatalf("bad: %v", val)
+ }
+ val, ok = r.Delete("")
+ if !ok || val != true {
+ t.Fatalf("bad: %v", val)
+ }
+}
+
+func TestDelete(t *testing.T) {
+
+ r := New()
+
+ s := []string{"", "A", "AB"}
+
+ for _, ss := range s {
+ r.Insert(ss, true)
+ }
+
+ for _, ss := range s {
+ _, ok := r.Delete(ss)
+ if !ok {
+ t.Fatalf("bad %q", ss)
+ }
+ }
+}
+
+func TestLongestPrefix(t *testing.T) {
+ r := New()
+
+ keys := []string{
+ "",
+ "foo",
+ "foobar",
+ "foobarbaz",
+ "foobarbazzip",
+ "foozip",
+ }
+ for _, k := range keys {
+ r.Insert(k, nil)
+ }
+ if r.Len() != len(keys) {
+ t.Fatalf("bad len: %v %v", r.Len(), len(keys))
+ }
+
+ type exp struct {
+ inp string
+ out string
+ }
+ cases := []exp{
+ {"a", ""},
+ {"abc", ""},
+ {"fo", ""},
+ {"foo", "foo"},
+ {"foob", "foo"},
+ {"foobar", "foobar"},
+ {"foobarba", "foobar"},
+ {"foobarbaz", "foobarbaz"},
+ {"foobarbazzi", "foobarbaz"},
+ {"foobarbazzip", "foobarbazzip"},
+ {"foozi", "foo"},
+ {"foozip", "foozip"},
+ {"foozipzap", "foozip"},
+ }
+ for _, test := range cases {
+ m, _, ok := r.LongestPrefix(test.inp)
+ if !ok {
+ t.Fatalf("no match: %v", test)
+ }
+ if m != test.out {
+ t.Fatalf("mis-match: %v %v", m, test)
+ }
+ }
+}
+
+func TestWalkPrefix(t *testing.T) {
+ r := New()
+
+ keys := []string{
+ "foobar",
+ "foo/bar/baz",
+ "foo/baz/bar",
+ "foo/zip/zap",
+ "zipzap",
+ }
+ for _, k := range keys {
+ r.Insert(k, nil)
+ }
+ if r.Len() != len(keys) {
+ t.Fatalf("bad len: %v %v", r.Len(), len(keys))
+ }
+
+ type exp struct {
+ inp string
+ out []string
+ }
+ cases := []exp{
+ {
+ "f",
+ []string{"foobar", "foo/bar/baz", "foo/baz/bar", "foo/zip/zap"},
+ },
+ {
+ "foo",
+ []string{"foobar", "foo/bar/baz", "foo/baz/bar", "foo/zip/zap"},
+ },
+ {
+ "foob",
+ []string{"foobar"},
+ },
+ {
+ "foo/",
+ []string{"foo/bar/baz", "foo/baz/bar", "foo/zip/zap"},
+ },
+ {
+ "foo/b",
+ []string{"foo/bar/baz", "foo/baz/bar"},
+ },
+ {
+ "foo/ba",
+ []string{"foo/bar/baz", "foo/baz/bar"},
+ },
+ {
+ "foo/bar",
+ []string{"foo/bar/baz"},
+ },
+ {
+ "foo/bar/baz",
+ []string{"foo/bar/baz"},
+ },
+ {
+ "foo/bar/bazoo",
+ []string{},
+ },
+ {
+ "z",
+ []string{"zipzap"},
+ },
+ }
+
+ for _, test := range cases {
+ out := []string{}
+ fn := func(s string, v interface{}) bool {
+ out = append(out, s)
+ return false
+ }
+ r.WalkPrefix(test.inp, fn)
+ sort.Strings(out)
+ sort.Strings(test.out)
+ if !reflect.DeepEqual(out, test.out) {
+ t.Fatalf("mis-match: %v %v", out, test.out)
+ }
+ }
+}
+
+func TestWalkPath(t *testing.T) {
+ r := New()
+
+ keys := []string{
+ "foo",
+ "foo/bar",
+ "foo/bar/baz",
+ "foo/baz/bar",
+ "foo/zip/zap",
+ "zipzap",
+ }
+ for _, k := range keys {
+ r.Insert(k, nil)
+ }
+ if r.Len() != len(keys) {
+ t.Fatalf("bad len: %v %v", r.Len(), len(keys))
+ }
+
+ type exp struct {
+ inp string
+ out []string
+ }
+ cases := []exp{
+ {
+ "f",
+ []string{},
+ },
+ {
+ "foo",
+ []string{"foo"},
+ },
+ {
+ "foo/",
+ []string{"foo"},
+ },
+ {
+ "foo/ba",
+ []string{"foo"},
+ },
+ {
+ "foo/bar",
+ []string{"foo", "foo/bar"},
+ },
+ {
+ "foo/bar/baz",
+ []string{"foo", "foo/bar", "foo/bar/baz"},
+ },
+ {
+ "foo/bar/bazoo",
+ []string{"foo", "foo/bar", "foo/bar/baz"},
+ },
+ {
+ "z",
+ []string{},
+ },
+ }
+
+ for _, test := range cases {
+ out := []string{}
+ fn := func(s string, v interface{}) bool {
+ out = append(out, s)
+ return false
+ }
+ r.WalkPath(test.inp, fn)
+ sort.Strings(out)
+ sort.Strings(test.out)
+ if !reflect.DeepEqual(out, test.out) {
+ t.Fatalf("mis-match: %v %v", out, test.out)
+ }
+ }
+}
+
+// generateUUID is used to generate a random UUID
+func generateUUID() string {
+ buf := make([]byte, 16)
+ if _, err := crand.Read(buf); err != nil {
+ panic(fmt.Errorf("failed to read random bytes: %v", err))
+ }
+
+ return fmt.Sprintf("%08x-%04x-%04x-%04x-%12x",
+ buf[0:4],
+ buf[4:6],
+ buf[6:8],
+ buf[8:10],
+ buf[10:16])
+}
diff --git a/vendor/github.com/sdboyer/gps/.gitignore b/vendor/github.com/sdboyer/gps/.gitignore
new file mode 100644
index 0000000..22d0d82
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/.gitignore
@@ -0,0 +1 @@
+vendor
diff --git a/vendor/github.com/sdboyer/gps/CODE_OF_CONDUCT.md b/vendor/github.com/sdboyer/gps/CODE_OF_CONDUCT.md
new file mode 100644
index 0000000..660ee84
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/CODE_OF_CONDUCT.md
@@ -0,0 +1,74 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of
+experience, nationality, personal appearance, race, religion, or sexual identity
+and orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+ advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+ address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+ professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, or to ban temporarily or permanently any
+contributor for other behaviors that they deem inappropriate, threatening,
+offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at sam (at) samboyer.org. All complaints
+will be reviewed and investigated and will result in a response that is deemed
+necessary and appropriate to the circumstances. The project team is obligated to
+maintain confidentiality with regard to the reporter of an incident. Further
+details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 1.4, available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/
diff --git a/vendor/github.com/sdboyer/gps/CONTRIBUTING.md b/vendor/github.com/sdboyer/gps/CONTRIBUTING.md
new file mode 100644
index 0000000..3ff03b3
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/CONTRIBUTING.md
@@ -0,0 +1,58 @@
+# Contributing to `gps`
+
+:+1::tada: First, we're thrilled you're thinking about contributing! :tada::+1:
+
+As a library trying to cover all the bases in Go package management, it's
+crucial that we incorporate a broad range of experiences and use cases. There is
+a strong, motivating design behind `gps`, but we are always open to discussion
+on ways we can improve the library, particularly if it allows `gps` to cover
+more of the Go package management possibility space.
+
+`gps` has no CLA, but we do have a [Code of Conduct](https://github.com/sdboyer/gps/blob/master/CODE_OF_CONDUCT.md). By
+participating, you are expected to uphold this code.
+
+## How can I contribute?
+
+It may be best to start by getting a handle on what `gps` actually is. Our
+wiki has a [general introduction](https://github.com/sdboyer/gps/wiki/Introduction-to-gps), a
+[guide for tool implementors](https://github.com/sdboyer/gps/wiki/gps-for-Implementors), and
+a [guide for contributors](https://github.com/sdboyer/gps/wiki/gps-for-contributors).
+There's also a [discursive essay](https://medium.com/@sdboyer/so-you-want-to-write-a-package-manager-4ae9c17d9527)
+that lays out the big-picture goals and considerations driving the `gps` design.
+
+There are a number of ways to contribute, all highly valuable and deeply
+appreciated:
+
+* **Helping "translate" existing issues:** as `gps` exits its larval stage, it still
+ has a number of issues that may be incomprehensible to everyone except
+ @sdboyer. Simply asking clarifying questions on these issues is helpful!
+* **Identifying missed use cases:** the loose `gps` rule of thumb is, "if you can do
+ it in Go, we support it in `gps`." Posting issues about cases we've missed
+ helps us reach that goal.
+* **Writing tests:** in the same vein, `gps` has a [large suite](https://github.com/sdboyer/gps/blob/master/CODE_OF_CONDUCT.md) of solving tests, but
+ they still only scratch the surface. Writing tests is not only helpful, but is
+ also a great way to get a feel for how `gps` works.
+* **Suggesting enhancements:** `gps` has plenty of missing chunks. Help fill them in!
+* **Reporting bugs**: `gps` being a library means this isn't always the easiest.
+ However, you could always compile the [example](https://github.com/sdboyer/gps/blob/master/example.go), run that against some of
+ your projects, and report problems you encounter.
+* **Building experimental tools with `gps`:** probably the best and fastest ways to
+ kick the tires!
+
+`gps` is still beta-ish software. There are plenty of bugs to squash! APIs are
+stabilizing, but are still subject to change.
+
+## Issues and Pull Requests
+
+Pull requests are the preferred way to submit changes to 'gps'. Unless the
+changes are quite small, pull requests should generally reference an
+already-opened issue. Make sure to explain clearly in the body of the PR what
+the reasoning behind the change is.
+
+The changes themselves should generally conform to the following guidelines:
+
+* Git commit messages should be [well-written](http://chris.beams.io/posts/git-commit/#seven-rules).
+* Code should be `gofmt`-ed.
+* New or changed logic should be accompanied by tests.
+* Maintainable, table-based tests are strongly preferred, even if it means
+ writing a new testing harness to execute them.
diff --git a/vendor/github.com/sdboyer/gps/LICENSE b/vendor/github.com/sdboyer/gps/LICENSE
new file mode 100644
index 0000000..d4a1dcc
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Sam Boyer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/vendor/github.com/sdboyer/gps/README.md b/vendor/github.com/sdboyer/gps/README.md
new file mode 100644
index 0000000..227bf6b
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/README.md
@@ -0,0 +1,95 @@
+# gps
+
+--
+
+[](https://circleci.com/gh/sdboyer/gps) [](https://goreportcard.com/report/github.com/sdboyer/gps) [](https://godoc.org/github.com/sdboyer/gps)
+
+`gps` is the Go Packaging Solver. It is an engine for tackling dependency
+management problems in Go. You can replicate the fetching bits of `go get`,
+modulo arguments, [in about 30 lines of
+code](https://github.com/sdboyer/gps/blob/master/example.go) with `gps`.
+
+`gps` is _not_ Yet Another Go Package Management Tool. Rather, it's a library
+that package management (and adjacent) tools can use to solve the
+[hard](https://en.wikipedia.org/wiki/Boolean_satisfiability_problem) parts of
+the problem in a consistent,
+[holistic](https://medium.com/@sdboyer/so-you-want-to-write-a-package-manager-4ae9c17d9527)
+way. `gps` is [on track](https://github.com/Masterminds/glide/pull/384) to become the engine behind [glide](https://glide.sh).
+
+The wiki has a [general introduction to the `gps`
+approach](https://github.com/sdboyer/gps/wiki/Introduction-to-gps), as well
+as guides for folks [implementing
+tools](https://github.com/sdboyer/gps/wiki/gps-for-Implementors) or [looking
+to contribute](https://github.com/sdboyer/gps/wiki/Introduction-to-gps).
+
+**`gps` is progressing rapidly, but still beta, with a liberal sprinkling of panics.**
+
+## Wait...a package management _library_?!
+
+Yup. Because it's what the Go ecosystem needs right now.
+
+There are [scads of
+tools](https://github.com/golang/go/wiki/PackageManagementTools) out there, each
+tackling some slice of the Go package management domain. Some handle more than
+others, some impose more restrictions than others, and most are mutually
+incompatible (or mutually indifferent, which amounts to the same). This
+fragments the Go FLOSS ecosystem, harming the community as a whole.
+
+As in all epic software arguments, some of the points of disagreement between
+tools/their authors are a bit silly. Many, though, are based on legitimate
+differences of opinion about what workflows, controls, and interfaces are
+best to give Go developers.
+
+Now, we're certainly no less opinionated than anyone else. But part of the
+challenge has been that, with a problem as
+[complex](https://medium.com/@sdboyer/so-you-want-to-write-a-package-manager-4ae9c17d9527)
+as package management, subtle design decisions made in pursuit of a particular
+workflow or interface can have far-reaching effects on architecture, leading to
+deep incompatibilities between tools and approaches.
+
+We believe that many of [these
+differences](https://docs.google.com/document/d/1xrV9D5u8AKu1ip-A1W9JqhUmmeOhoI6d6zjVwvdn5mc/edit?usp=sharing)
+are incidental - and, given the right general solution, reconcilable. `gps` is
+our attempt at such a solution.
+
+By separating out the underlying problem into a standalone library, we are
+hoping to provide a common foundation for different tools. Such a foundation
+could improve interoperability, reduce harm to the ecosystem, and make the
+communal process of figuring out what's right for Go more about collaboration,
+and less about fiefdoms.
+
+### Assumptions
+
+Ideally, `gps` could provide this shared foundation with no additional
+assumptions beyond pure Go source files. Sadly, package management is too
+complex to be assumption-less. So, `gps` tries to keep its assumptions to the
+minimum, supporting as many situations as possible while still maintaining a
+predictable, well-formed system.
+
+* Go 1.6, or 1.5 with `GO15VENDOREXPERIMENT = 1` set. `vendor/`
+ directories are a requirement.
+* You don't manually change what's under `vendor/`. That’s tooling’s
+ job.
+* A **project** concept, where projects comprise the set of Go packages in a
+ rooted directory tree. By happy (not) accident, `vendor/` directories also
+ just happen to cover a rooted tree.
+* A [**manifest**](https://godoc.org/github.com/sdboyer/gps#Manifest) and
+ [**lock**](https://godoc.org/github.com/sdboyer/gps#Lock) approach to
+ tracking version and constraint information. The solver takes manifest (and,
+ optionally, lock)-type data as inputs, and produces lock-type data as its
+ output. Tools decide how to actually store this data, but these should
+ generally be at the root of the project tree.
+
+Manifests? Locks? Eeew. Yes, we also think it'd be swell if we didn't need
+metadata files. We love the idea of Go packages as standalone, self-describing
+code. Unfortunately, the wheels come off that idea as soon as versioning and
+cross-project/repository dependencies happen. But universe alignment is hard;
+trying to intermix version information directly with the code would only make
+matters worse.
+
+## Contributing
+
+Yay, contributing! Please see
+[CONTRIBUTING.md](https://github.com/sdboyer/gps/blob/master/CONTRIBUTING.md).
+Note that `gps` also abides by a [Code of
+Conduct](https://github.com/sdboyer/gps/blob/master/CODE_OF_CONDUCT.md), and is MIT-licensed.
diff --git a/vendor/github.com/sdboyer/gps/_testdata/src/disallow/.m1p/a.go b/vendor/github.com/sdboyer/gps/_testdata/src/disallow/.m1p/a.go
new file mode 100644
index 0000000..e4e2ced
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/_testdata/src/disallow/.m1p/a.go
@@ -0,0 +1,12 @@
+package m1p
+
+import (
+ "sort"
+
+ "github.com/sdboyer/gps"
+)
+
+var (
+ _ = sort.Strings
+ S = gps.Solve
+)
diff --git a/vendor/github.com/sdboyer/gps/_testdata/src/disallow/.m1p/b.go b/vendor/github.com/sdboyer/gps/_testdata/src/disallow/.m1p/b.go
new file mode 100644
index 0000000..83674b9
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/_testdata/src/disallow/.m1p/b.go
@@ -0,0 +1,11 @@
+package m1p
+
+import (
+ "os"
+ "sort"
+)
+
+var (
+ _ = sort.Strings
+ _ = os.PathSeparator
+)
diff --git a/vendor/github.com/sdboyer/gps/_testdata/src/disallow/a.go b/vendor/github.com/sdboyer/gps/_testdata/src/disallow/a.go
new file mode 100644
index 0000000..59d2f72
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/_testdata/src/disallow/a.go
@@ -0,0 +1,14 @@
+package disallow
+
+import (
+ "sort"
+ "disallow/testdata"
+
+ "github.com/sdboyer/gps"
+)
+
+var (
+ _ = sort.Strings
+ _ = gps.Solve
+ _ = testdata.H
+)
diff --git a/vendor/github.com/sdboyer/gps/_testdata/src/disallow/testdata/another.go b/vendor/github.com/sdboyer/gps/_testdata/src/disallow/testdata/another.go
new file mode 100644
index 0000000..6defdae
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/_testdata/src/disallow/testdata/another.go
@@ -0,0 +1,7 @@
+package testdata
+
+import "hash"
+
+var (
+ H = hash.Hash
+)
diff --git a/vendor/github.com/sdboyer/gps/_testdata/src/doublenest/a.go b/vendor/github.com/sdboyer/gps/_testdata/src/doublenest/a.go
new file mode 100644
index 0000000..04cac6a
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/_testdata/src/doublenest/a.go
@@ -0,0 +1,12 @@
+package base
+
+import (
+ "go/parser"
+
+ "github.com/sdboyer/gps"
+)
+
+var (
+ _ = parser.ParseFile
+ _ = gps.Solve
+)
diff --git a/vendor/github.com/sdboyer/gps/_testdata/src/doublenest/namemismatch/m1p/a.go b/vendor/github.com/sdboyer/gps/_testdata/src/doublenest/namemismatch/m1p/a.go
new file mode 100644
index 0000000..ec1f9b9
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/_testdata/src/doublenest/namemismatch/m1p/a.go
@@ -0,0 +1,12 @@
+package m1p
+
+import (
+ "sort"
+
+ "github.com/sdboyer/gps"
+)
+
+var (
+ _ = sort.Strings
+ _ = gps.Solve
+)
diff --git a/vendor/github.com/sdboyer/gps/_testdata/src/doublenest/namemismatch/m1p/b.go b/vendor/github.com/sdboyer/gps/_testdata/src/doublenest/namemismatch/m1p/b.go
new file mode 100644
index 0000000..83674b9
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/_testdata/src/doublenest/namemismatch/m1p/b.go
@@ -0,0 +1,11 @@
+package m1p
+
+import (
+ "os"
+ "sort"
+)
+
+var (
+ _ = sort.Strings
+ _ = os.PathSeparator
+)
diff --git a/vendor/github.com/sdboyer/gps/_testdata/src/doublenest/namemismatch/nm.go b/vendor/github.com/sdboyer/gps/_testdata/src/doublenest/namemismatch/nm.go
new file mode 100644
index 0000000..44a0abb
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/_testdata/src/doublenest/namemismatch/nm.go
@@ -0,0 +1,12 @@
+package nm
+
+import (
+ "os"
+
+ "github.com/Masterminds/semver"
+)
+
+var (
+ V = os.FileInfo
+ _ = semver.Constraint
+)
diff --git a/vendor/github.com/sdboyer/gps/_testdata/src/empty/.gitkeep b/vendor/github.com/sdboyer/gps/_testdata/src/empty/.gitkeep
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/_testdata/src/empty/.gitkeep
diff --git a/vendor/github.com/sdboyer/gps/_testdata/src/igmain/a.go b/vendor/github.com/sdboyer/gps/_testdata/src/igmain/a.go
new file mode 100644
index 0000000..300b730
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/_testdata/src/igmain/a.go
@@ -0,0 +1,12 @@
+package simple
+
+import (
+ "sort"
+
+ "github.com/sdboyer/gps"
+)
+
+var (
+ _ = sort.Strings
+ _ = gps.Solve
+)
diff --git a/vendor/github.com/sdboyer/gps/_testdata/src/igmain/igmain.go b/vendor/github.com/sdboyer/gps/_testdata/src/igmain/igmain.go
new file mode 100644
index 0000000..52129ef
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/_testdata/src/igmain/igmain.go
@@ -0,0 +1,7 @@
+// +build ignore
+
+package main
+
+import "unicode"
+
+var _ = unicode.In
diff --git a/vendor/github.com/sdboyer/gps/_testdata/src/igmainlong/a.go b/vendor/github.com/sdboyer/gps/_testdata/src/igmainlong/a.go
new file mode 100644
index 0000000..300b730
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/_testdata/src/igmainlong/a.go
@@ -0,0 +1,12 @@
+package simple
+
+import (
+ "sort"
+
+ "github.com/sdboyer/gps"
+)
+
+var (
+ _ = sort.Strings
+ _ = gps.Solve
+)
diff --git a/vendor/github.com/sdboyer/gps/_testdata/src/igmainlong/igmain.go b/vendor/github.com/sdboyer/gps/_testdata/src/igmainlong/igmain.go
new file mode 100644
index 0000000..efee3f9
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/_testdata/src/igmainlong/igmain.go
@@ -0,0 +1,9 @@
+// Another comment, which the parser should ignore and still see builds tags
+
+// +build ignore
+
+package main
+
+import "unicode"
+
+var _ = unicode.In
diff --git a/vendor/github.com/sdboyer/gps/_testdata/src/igmaint/a.go b/vendor/github.com/sdboyer/gps/_testdata/src/igmaint/a.go
new file mode 100644
index 0000000..300b730
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/_testdata/src/igmaint/a.go
@@ -0,0 +1,12 @@
+package simple
+
+import (
+ "sort"
+
+ "github.com/sdboyer/gps"
+)
+
+var (
+ _ = sort.Strings
+ _ = gps.Solve
+)
diff --git a/vendor/github.com/sdboyer/gps/_testdata/src/igmaint/igmain.go b/vendor/github.com/sdboyer/gps/_testdata/src/igmaint/igmain.go
new file mode 100644
index 0000000..52129ef
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/_testdata/src/igmaint/igmain.go
@@ -0,0 +1,7 @@
+// +build ignore
+
+package main
+
+import "unicode"
+
+var _ = unicode.In
diff --git a/vendor/github.com/sdboyer/gps/_testdata/src/igmaint/t_test.go b/vendor/github.com/sdboyer/gps/_testdata/src/igmaint/t_test.go
new file mode 100644
index 0000000..ff4f77b
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/_testdata/src/igmaint/t_test.go
@@ -0,0 +1,11 @@
+package simple
+
+import (
+ "math/rand"
+ "strconv"
+)
+
+var (
+ _ = rand.Int()
+ _ = strconv.Unquote
+)
diff --git a/vendor/github.com/sdboyer/gps/_testdata/src/m1p/a.go b/vendor/github.com/sdboyer/gps/_testdata/src/m1p/a.go
new file mode 100644
index 0000000..ec1f9b9
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/_testdata/src/m1p/a.go
@@ -0,0 +1,12 @@
+package m1p
+
+import (
+ "sort"
+
+ "github.com/sdboyer/gps"
+)
+
+var (
+ _ = sort.Strings
+ _ = gps.Solve
+)
diff --git a/vendor/github.com/sdboyer/gps/_testdata/src/m1p/b.go b/vendor/github.com/sdboyer/gps/_testdata/src/m1p/b.go
new file mode 100644
index 0000000..83674b9
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/_testdata/src/m1p/b.go
@@ -0,0 +1,11 @@
+package m1p
+
+import (
+ "os"
+ "sort"
+)
+
+var (
+ _ = sort.Strings
+ _ = os.PathSeparator
+)
diff --git a/vendor/github.com/sdboyer/gps/_testdata/src/missing/a.go b/vendor/github.com/sdboyer/gps/_testdata/src/missing/a.go
new file mode 100644
index 0000000..8522bdd
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/_testdata/src/missing/a.go
@@ -0,0 +1,14 @@
+package simple
+
+import (
+ "sort"
+
+ "missing/missing"
+ "github.com/sdboyer/gps"
+)
+
+var (
+ _ = sort.Strings
+ _ = gps.Solve
+ _ = missing.Foo
+)
diff --git a/vendor/github.com/sdboyer/gps/_testdata/src/missing/m1p/a.go b/vendor/github.com/sdboyer/gps/_testdata/src/missing/m1p/a.go
new file mode 100644
index 0000000..ec1f9b9
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/_testdata/src/missing/m1p/a.go
@@ -0,0 +1,12 @@
+package m1p
+
+import (
+ "sort"
+
+ "github.com/sdboyer/gps"
+)
+
+var (
+ _ = sort.Strings
+ _ = gps.Solve
+)
diff --git a/vendor/github.com/sdboyer/gps/_testdata/src/missing/m1p/b.go b/vendor/github.com/sdboyer/gps/_testdata/src/missing/m1p/b.go
new file mode 100644
index 0000000..83674b9
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/_testdata/src/missing/m1p/b.go
@@ -0,0 +1,11 @@
+package m1p
+
+import (
+ "os"
+ "sort"
+)
+
+var (
+ _ = sort.Strings
+ _ = os.PathSeparator
+)
diff --git a/vendor/github.com/sdboyer/gps/_testdata/src/nest/a.go b/vendor/github.com/sdboyer/gps/_testdata/src/nest/a.go
new file mode 100644
index 0000000..300b730
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/_testdata/src/nest/a.go
@@ -0,0 +1,12 @@
+package simple
+
+import (
+ "sort"
+
+ "github.com/sdboyer/gps"
+)
+
+var (
+ _ = sort.Strings
+ _ = gps.Solve
+)
diff --git a/vendor/github.com/sdboyer/gps/_testdata/src/nest/m1p/a.go b/vendor/github.com/sdboyer/gps/_testdata/src/nest/m1p/a.go
new file mode 100644
index 0000000..ec1f9b9
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/_testdata/src/nest/m1p/a.go
@@ -0,0 +1,12 @@
+package m1p
+
+import (
+ "sort"
+
+ "github.com/sdboyer/gps"
+)
+
+var (
+ _ = sort.Strings
+ _ = gps.Solve
+)
diff --git a/vendor/github.com/sdboyer/gps/_testdata/src/nest/m1p/b.go b/vendor/github.com/sdboyer/gps/_testdata/src/nest/m1p/b.go
new file mode 100644
index 0000000..83674b9
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/_testdata/src/nest/m1p/b.go
@@ -0,0 +1,11 @@
+package m1p
+
+import (
+ "os"
+ "sort"
+)
+
+var (
+ _ = sort.Strings
+ _ = os.PathSeparator
+)
diff --git a/vendor/github.com/sdboyer/gps/_testdata/src/ren/m1p/a.go b/vendor/github.com/sdboyer/gps/_testdata/src/ren/m1p/a.go
new file mode 100644
index 0000000..ec1f9b9
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/_testdata/src/ren/m1p/a.go
@@ -0,0 +1,12 @@
+package m1p
+
+import (
+ "sort"
+
+ "github.com/sdboyer/gps"
+)
+
+var (
+ _ = sort.Strings
+ _ = gps.Solve
+)
diff --git a/vendor/github.com/sdboyer/gps/_testdata/src/ren/m1p/b.go b/vendor/github.com/sdboyer/gps/_testdata/src/ren/m1p/b.go
new file mode 100644
index 0000000..83674b9
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/_testdata/src/ren/m1p/b.go
@@ -0,0 +1,11 @@
+package m1p
+
+import (
+ "os"
+ "sort"
+)
+
+var (
+ _ = sort.Strings
+ _ = os.PathSeparator
+)
diff --git a/vendor/github.com/sdboyer/gps/_testdata/src/ren/simple/a.go b/vendor/github.com/sdboyer/gps/_testdata/src/ren/simple/a.go
new file mode 100644
index 0000000..300b730
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/_testdata/src/ren/simple/a.go
@@ -0,0 +1,12 @@
+package simple
+
+import (
+ "sort"
+
+ "github.com/sdboyer/gps"
+)
+
+var (
+ _ = sort.Strings
+ _ = gps.Solve
+)
diff --git a/vendor/github.com/sdboyer/gps/_testdata/src/simple/a.go b/vendor/github.com/sdboyer/gps/_testdata/src/simple/a.go
new file mode 100644
index 0000000..300b730
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/_testdata/src/simple/a.go
@@ -0,0 +1,12 @@
+package simple
+
+import (
+ "sort"
+
+ "github.com/sdboyer/gps"
+)
+
+var (
+ _ = sort.Strings
+ _ = gps.Solve
+)
diff --git a/vendor/github.com/sdboyer/gps/_testdata/src/simpleallt/a.go b/vendor/github.com/sdboyer/gps/_testdata/src/simpleallt/a.go
new file mode 100644
index 0000000..300b730
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/_testdata/src/simpleallt/a.go
@@ -0,0 +1,12 @@
+package simple
+
+import (
+ "sort"
+
+ "github.com/sdboyer/gps"
+)
+
+var (
+ _ = sort.Strings
+ _ = gps.Solve
+)
diff --git a/vendor/github.com/sdboyer/gps/_testdata/src/simpleallt/a_test.go b/vendor/github.com/sdboyer/gps/_testdata/src/simpleallt/a_test.go
new file mode 100644
index 0000000..72a3014
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/_testdata/src/simpleallt/a_test.go
@@ -0,0 +1,11 @@
+package simple_test
+
+import (
+ "sort"
+ "strconv"
+)
+
+var (
+ _ = sort.Strings
+ _ = strconv.Unquote
+)
diff --git a/vendor/github.com/sdboyer/gps/_testdata/src/simpleallt/t_test.go b/vendor/github.com/sdboyer/gps/_testdata/src/simpleallt/t_test.go
new file mode 100644
index 0000000..ff4f77b
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/_testdata/src/simpleallt/t_test.go
@@ -0,0 +1,11 @@
+package simple
+
+import (
+ "math/rand"
+ "strconv"
+)
+
+var (
+ _ = rand.Int()
+ _ = strconv.Unquote
+)
diff --git a/vendor/github.com/sdboyer/gps/_testdata/src/simplet/a.go b/vendor/github.com/sdboyer/gps/_testdata/src/simplet/a.go
new file mode 100644
index 0000000..300b730
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/_testdata/src/simplet/a.go
@@ -0,0 +1,12 @@
+package simple
+
+import (
+ "sort"
+
+ "github.com/sdboyer/gps"
+)
+
+var (
+ _ = sort.Strings
+ _ = gps.Solve
+)
diff --git a/vendor/github.com/sdboyer/gps/_testdata/src/simplet/t_test.go b/vendor/github.com/sdboyer/gps/_testdata/src/simplet/t_test.go
new file mode 100644
index 0000000..ff4f77b
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/_testdata/src/simplet/t_test.go
@@ -0,0 +1,11 @@
+package simple
+
+import (
+ "math/rand"
+ "strconv"
+)
+
+var (
+ _ = rand.Int()
+ _ = strconv.Unquote
+)
diff --git a/vendor/github.com/sdboyer/gps/_testdata/src/simplext/a.go b/vendor/github.com/sdboyer/gps/_testdata/src/simplext/a.go
new file mode 100644
index 0000000..300b730
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/_testdata/src/simplext/a.go
@@ -0,0 +1,12 @@
+package simple
+
+import (
+ "sort"
+
+ "github.com/sdboyer/gps"
+)
+
+var (
+ _ = sort.Strings
+ _ = gps.Solve
+)
diff --git a/vendor/github.com/sdboyer/gps/_testdata/src/simplext/a_test.go b/vendor/github.com/sdboyer/gps/_testdata/src/simplext/a_test.go
new file mode 100644
index 0000000..72a3014
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/_testdata/src/simplext/a_test.go
@@ -0,0 +1,11 @@
+package simple_test
+
+import (
+ "sort"
+ "strconv"
+)
+
+var (
+ _ = sort.Strings
+ _ = strconv.Unquote
+)
diff --git a/vendor/github.com/sdboyer/gps/_testdata/src/t/t_test.go b/vendor/github.com/sdboyer/gps/_testdata/src/t/t_test.go
new file mode 100644
index 0000000..ff4f77b
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/_testdata/src/t/t_test.go
@@ -0,0 +1,11 @@
+package simple
+
+import (
+ "math/rand"
+ "strconv"
+)
+
+var (
+ _ = rand.Int()
+ _ = strconv.Unquote
+)
diff --git a/vendor/github.com/sdboyer/gps/_testdata/src/twopkgs/a.go b/vendor/github.com/sdboyer/gps/_testdata/src/twopkgs/a.go
new file mode 100644
index 0000000..300b730
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/_testdata/src/twopkgs/a.go
@@ -0,0 +1,12 @@
+package simple
+
+import (
+ "sort"
+
+ "github.com/sdboyer/gps"
+)
+
+var (
+ _ = sort.Strings
+ _ = gps.Solve
+)
diff --git a/vendor/github.com/sdboyer/gps/_testdata/src/twopkgs/b.go b/vendor/github.com/sdboyer/gps/_testdata/src/twopkgs/b.go
new file mode 100644
index 0000000..83674b9
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/_testdata/src/twopkgs/b.go
@@ -0,0 +1,11 @@
+package m1p
+
+import (
+ "os"
+ "sort"
+)
+
+var (
+ _ = sort.Strings
+ _ = os.PathSeparator
+)
diff --git a/vendor/github.com/sdboyer/gps/_testdata/src/varied/locals.go b/vendor/github.com/sdboyer/gps/_testdata/src/varied/locals.go
new file mode 100644
index 0000000..5c7e6c7
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/_testdata/src/varied/locals.go
@@ -0,0 +1,13 @@
+package main
+
+import (
+ "varied/namemismatch"
+ "varied/otherpath"
+ "varied/simple"
+)
+
+var (
+ _ = simple.S
+ _ = nm.V
+ _ = otherpath.O
+)
diff --git a/vendor/github.com/sdboyer/gps/_testdata/src/varied/m1p/a.go b/vendor/github.com/sdboyer/gps/_testdata/src/varied/m1p/a.go
new file mode 100644
index 0000000..65fd7ca
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/_testdata/src/varied/m1p/a.go
@@ -0,0 +1,12 @@
+package m1p
+
+import (
+ "sort"
+
+ "github.com/sdboyer/gps"
+)
+
+var (
+ M = sort.Strings
+ _ = gps.Solve
+)
diff --git a/vendor/github.com/sdboyer/gps/_testdata/src/varied/m1p/b.go b/vendor/github.com/sdboyer/gps/_testdata/src/varied/m1p/b.go
new file mode 100644
index 0000000..83674b9
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/_testdata/src/varied/m1p/b.go
@@ -0,0 +1,11 @@
+package m1p
+
+import (
+ "os"
+ "sort"
+)
+
+var (
+ _ = sort.Strings
+ _ = os.PathSeparator
+)
diff --git a/vendor/github.com/sdboyer/gps/_testdata/src/varied/main.go b/vendor/github.com/sdboyer/gps/_testdata/src/varied/main.go
new file mode 100644
index 0000000..92c3dc1
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/_testdata/src/varied/main.go
@@ -0,0 +1,9 @@
+package main
+
+import (
+ "net/http"
+)
+
+var (
+ _ = http.Client
+)
diff --git a/vendor/github.com/sdboyer/gps/_testdata/src/varied/namemismatch/nm.go b/vendor/github.com/sdboyer/gps/_testdata/src/varied/namemismatch/nm.go
new file mode 100644
index 0000000..44a0abb
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/_testdata/src/varied/namemismatch/nm.go
@@ -0,0 +1,12 @@
+package nm
+
+import (
+ "os"
+
+ "github.com/Masterminds/semver"
+)
+
+var (
+ V = os.FileInfo
+ _ = semver.Constraint
+)
diff --git a/vendor/github.com/sdboyer/gps/_testdata/src/varied/otherpath/otherpath_test.go b/vendor/github.com/sdboyer/gps/_testdata/src/varied/otherpath/otherpath_test.go
new file mode 100644
index 0000000..73891e6
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/_testdata/src/varied/otherpath/otherpath_test.go
@@ -0,0 +1,5 @@
+package otherpath
+
+import "varied/m1p"
+
+var O = m1p.M
diff --git a/vendor/github.com/sdboyer/gps/_testdata/src/varied/simple/another/another.go b/vendor/github.com/sdboyer/gps/_testdata/src/varied/simple/another/another.go
new file mode 100644
index 0000000..85368da
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/_testdata/src/varied/simple/another/another.go
@@ -0,0 +1,7 @@
+package another
+
+import "hash"
+
+var (
+ H = hash.Hash
+)
diff --git a/vendor/github.com/sdboyer/gps/_testdata/src/varied/simple/another/another_test.go b/vendor/github.com/sdboyer/gps/_testdata/src/varied/simple/another/another_test.go
new file mode 100644
index 0000000..72a89ad
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/_testdata/src/varied/simple/another/another_test.go
@@ -0,0 +1,7 @@
+package another
+
+import "encoding/binary"
+
+var (
+ _ = binary.PutVarint
+)
diff --git a/vendor/github.com/sdboyer/gps/_testdata/src/varied/simple/another/locals.go b/vendor/github.com/sdboyer/gps/_testdata/src/varied/simple/another/locals.go
new file mode 100644
index 0000000..d8d0316
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/_testdata/src/varied/simple/another/locals.go
@@ -0,0 +1,5 @@
+package another
+
+import "varied/m1p"
+
+var _ = m1p.M
diff --git a/vendor/github.com/sdboyer/gps/_testdata/src/varied/simple/locals.go b/vendor/github.com/sdboyer/gps/_testdata/src/varied/simple/locals.go
new file mode 100644
index 0000000..6ebb90f
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/_testdata/src/varied/simple/locals.go
@@ -0,0 +1,7 @@
+package simple
+
+import "varied/simple/another"
+
+var (
+ _ = another.H
+)
diff --git a/vendor/github.com/sdboyer/gps/_testdata/src/varied/simple/simple.go b/vendor/github.com/sdboyer/gps/_testdata/src/varied/simple/simple.go
new file mode 100644
index 0000000..c8fbb05
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/_testdata/src/varied/simple/simple.go
@@ -0,0 +1,12 @@
+package simple
+
+import (
+ "go/parser"
+
+ "github.com/sdboyer/gps"
+)
+
+var (
+ _ = parser.ParseFile
+ S = gps.Prepare
+)
diff --git a/vendor/github.com/sdboyer/gps/_testdata/src/xt/a_test.go b/vendor/github.com/sdboyer/gps/_testdata/src/xt/a_test.go
new file mode 100644
index 0000000..72a3014
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/_testdata/src/xt/a_test.go
@@ -0,0 +1,11 @@
+package simple_test
+
+import (
+ "sort"
+ "strconv"
+)
+
+var (
+ _ = sort.Strings
+ _ = strconv.Unquote
+)
diff --git a/vendor/github.com/sdboyer/gps/analysis.go b/vendor/github.com/sdboyer/gps/analysis.go
new file mode 100644
index 0000000..0cb93ba
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/analysis.go
@@ -0,0 +1,950 @@
+package gps
+
+import (
+ "bytes"
+ "fmt"
+ "go/build"
+ "io"
+ "io/ioutil"
+ "os"
+ "path/filepath"
+ "sort"
+ "strings"
+ "text/scanner"
+)
+
+var osList []string
+var archList []string
+var stdlib = make(map[string]bool)
+
+const stdlibPkgs string = "archive archive/tar archive/zip bufio builtin bytes compress compress/bzip2 compress/flate compress/gzip compress/lzw compress/zlib container container/heap container/list container/ring context crypto crypto/aes crypto/cipher crypto/des crypto/dsa crypto/ecdsa crypto/elliptic crypto/hmac crypto/md5 crypto/rand crypto/rc4 crypto/rsa crypto/sha1 crypto/sha256 crypto/sha512 crypto/subtle crypto/tls crypto/x509 crypto/x509/pkix database database/sql database/sql/driver debug debug/dwarf debug/elf debug/gosym debug/macho debug/pe debug/plan9obj encoding encoding/ascii85 encoding/asn1 encoding/base32 encoding/base64 encoding/binary encoding/csv encoding/gob encoding/hex encoding/json encoding/pem encoding/xml errors expvar flag fmt go go/ast go/build go/constant go/doc go/format go/importer go/parser go/printer go/scanner go/token go/types hash hash/adler32 hash/crc32 hash/crc64 hash/fnv html html/template image image/color image/color/palette image/draw image/gif image/jpeg image/png index index/suffixarray io io/ioutil log log/syslog math math/big math/cmplx math/rand mime mime/multipart mime/quotedprintable net net/http net/http/cgi net/http/cookiejar net/http/fcgi net/http/httptest net/http/httputil net/http/pprof net/mail net/rpc net/rpc/jsonrpc net/smtp net/textproto net/url os os/exec os/signal os/user path path/filepath reflect regexp regexp/syntax runtime runtime/cgo runtime/debug runtime/msan runtime/pprof runtime/race runtime/trace sort strconv strings sync sync/atomic syscall testing testing/iotest testing/quick text text/scanner text/tabwriter text/template text/template/parse time unicode unicode/utf16 unicode/utf8 unsafe"
+
+// Before appengine moved to google.golang.org/appengine, it had a magic
+// stdlib-like import path. We have to ignore all of these.
+const appenginePkgs string = "appengine/aetest appengine/blobstore appengine/capability appengine/channel appengine/cloudsql appengine/cmd appengine/cmd/aebundler appengine/cmd/aedeploy appengine/cmd/aefix appengine/datastore appengine/delay appengine/demos appengine/demos/guestbook appengine/demos/guestbook/templates appengine/demos/helloworld appengine/file appengine/image appengine/internal appengine/internal/aetesting appengine/internal/app_identity appengine/internal/base appengine/internal/blobstore appengine/internal/capability appengine/internal/channel appengine/internal/datastore appengine/internal/image appengine/internal/log appengine/internal/mail appengine/internal/memcache appengine/internal/modules appengine/internal/remote_api appengine/internal/search appengine/internal/socket appengine/internal/system appengine/internal/taskqueue appengine/internal/urlfetch appengine/internal/user appengine/internal/xmpp appengine/log appengine/mail appengine/memcache appengine/module appengine/remote_api appengine/runtime appengine/search appengine/socket appengine/taskqueue appengine/urlfetch appengine/user appengine/xmpp"
+
+func init() {
+ // The supported systems are listed in
+ // https://github.com/golang/go/blob/master/src/go/build/syslist.go
+ // The lists are not exported so we need to duplicate them here.
+ osListString := "android darwin dragonfly freebsd linux nacl netbsd openbsd plan9 solaris windows"
+ osList = strings.Split(osListString, " ")
+
+ archListString := "386 amd64 amd64p32 arm armbe arm64 arm64be ppc64 ppc64le mips mipsle mips64 mips64le mips64p32 mips64p32le ppc s390 s390x sparc sparc64"
+ archList = strings.Split(archListString, " ")
+
+ for _, pkg := range strings.Split(stdlibPkgs, " ") {
+ stdlib[pkg] = true
+ }
+ for _, pkg := range strings.Split(appenginePkgs, " ") {
+ stdlib[pkg] = true
+ }
+
+ // Also ignore C
+ // TODO(sdboyer) actually figure out how to deal with cgo
+ stdlib["C"] = true
+}
+
+// listPackages lists info for all packages at or below the provided fileRoot.
+//
+// Directories without any valid Go files are excluded. Directories with
+// multiple packages are excluded.
+//
+// The importRoot parameter is prepended to the relative path when determining
+// the import path for each package. The obvious case is for something typical,
+// like:
+//
+// fileRoot = "/home/user/go/src/github.com/foo/bar"
+// importRoot = "github.com/foo/bar"
+//
+// where the fileRoot and importRoot align. However, if you provide:
+//
+// fileRoot = "/home/user/workspace/path/to/repo"
+// importRoot = "github.com/foo/bar"
+//
+// then the root package at path/to/repo will be ascribed import path
+// "github.com/foo/bar", and its subpackage "baz" will be
+// "github.com/foo/bar/baz".
+//
+// 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) {
+ // Set up a build.ctx for parsing
+ ctx := build.Default
+ ctx.GOROOT = ""
+ ctx.GOPATH = ""
+ ctx.UseAllFiles = true
+
+ ptree := PackageTree{
+ ImportRoot: importRoot,
+ Packages: make(map[string]PackageOrErr),
+ }
+
+ // mkfilter returns two funcs that can be injected into a build.Context,
+ // letting us filter the results into an "in" and "out" set.
+ mkfilter := func(files map[string]struct{}) (in, out func(dir string) (fi []os.FileInfo, err error)) {
+ in = func(dir string) (fi []os.FileInfo, err error) {
+ all, err := ioutil.ReadDir(dir)
+ if err != nil {
+ return nil, err
+ }
+
+ for _, f := range all {
+ if _, exists := files[f.Name()]; exists {
+ fi = append(fi, f)
+ }
+ }
+ return fi, nil
+ }
+
+ out = func(dir string) (fi []os.FileInfo, err error) {
+ all, err := ioutil.ReadDir(dir)
+ if err != nil {
+ return nil, err
+ }
+
+ for _, f := range all {
+ if _, exists := files[f.Name()]; !exists {
+ fi = append(fi, f)
+ }
+ }
+ return fi, nil
+ }
+
+ return
+ }
+
+ // helper func to create a Package from a *build.Package
+ happy := func(importPath string, p *build.Package) Package {
+ // Happy path - simple parsing worked
+ pkg := Package{
+ ImportPath: importPath,
+ CommentPath: p.ImportComment,
+ Name: p.Name,
+ Imports: p.Imports,
+ TestImports: dedupeStrings(p.TestImports, p.XTestImports),
+ }
+
+ return pkg
+ }
+
+ err := filepath.Walk(fileRoot, func(path string, fi os.FileInfo, err error) error {
+ if err != nil && err != filepath.SkipDir {
+ return err
+ }
+ if !fi.IsDir() {
+ return nil
+ }
+
+ // Skip dirs that are known to hold non-local/dependency code.
+ //
+ // We don't skip _*, or testdata dirs because, while it may be poor
+ // form, importing them is not a compilation error.
+ switch fi.Name() {
+ case "vendor", "Godeps":
+ return filepath.SkipDir
+ }
+ // 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
+ }
+
+ // Compute the import path. Run the result through ToSlash(), so that windows
+ // paths are normalized to Unix separators, as import paths are expected
+ // to be.
+ ip := filepath.ToSlash(filepath.Join(importRoot, strings.TrimPrefix(path, fileRoot)))
+
+ // Find all the imports, across all os/arch combos
+ p, err := ctx.ImportDir(path, analysisImportMode())
+ var pkg Package
+ if err == nil {
+ pkg = happy(ip, p)
+ } else {
+ switch terr := err.(type) {
+ case *build.NoGoError:
+ ptree.Packages[ip] = PackageOrErr{
+ Err: err,
+ }
+ return nil
+ case *build.MultiplePackageError:
+ // Set this up preemptively, so we can easily just return out if
+ // something goes wrong. Otherwise, it'll get transparently
+ // overwritten later.
+ ptree.Packages[ip] = PackageOrErr{
+ Err: err,
+ }
+
+ // For now, we're punting entirely on dealing with os/arch
+ // combinations. That will be a more significant refactor.
+ //
+ // However, there is one case we want to allow here - one or
+ // more files with "+build ignore" with package `main`. (Ignore
+ // is just a convention, but for now it's good enough to just
+ // check that.) This is a fairly common way to give examples,
+ // and to make a more sophisticated build system than a Makefile
+ // allows, so we want to support that case. So, transparently
+ // lump the deps together.
+ mains := make(map[string]struct{})
+ for k, pkgname := range terr.Packages {
+ if pkgname == "main" {
+ tags, err2 := readFileBuildTags(filepath.Join(path, terr.Files[k]))
+ if err2 != nil {
+ return nil
+ }
+
+ var hasignore bool
+ for _, t := range tags {
+ if t == "ignore" {
+ hasignore = true
+ break
+ }
+ }
+ if !hasignore {
+ // No ignore tag found - bail out
+ return nil
+ }
+ mains[terr.Files[k]] = struct{}{}
+ }
+ }
+ // Make filtering funcs that will let us look only at the main
+ // files, and exclude the main files; inf and outf, respectively
+ inf, outf := mkfilter(mains)
+
+ // outf first; if there's another err there, we bail out with a
+ // return
+ ctx.ReadDir = outf
+ po, err2 := ctx.ImportDir(path, analysisImportMode())
+ if err2 != nil {
+ return nil
+ }
+ ctx.ReadDir = inf
+ pi, err2 := ctx.ImportDir(path, analysisImportMode())
+ if err2 != nil {
+ return nil
+ }
+ ctx.ReadDir = nil
+
+ // Use the other files as baseline, they're the main stuff
+ pkg = happy(ip, po)
+ mpkg := happy(ip, pi)
+ pkg.Imports = dedupeStrings(pkg.Imports, mpkg.Imports)
+ pkg.TestImports = dedupeStrings(pkg.TestImports, mpkg.TestImports)
+ default:
+ return err
+ }
+ }
+
+ // This area has some...fuzzy rules, but check all the imports for
+ // local/relative/dot-ness, and record an error for the package if we
+ // see any.
+ var lim []string
+ for _, imp := range append(pkg.Imports, pkg.TestImports...) {
+ switch {
+ // Do allow the single-dot, at least for now
+ case imp == "..":
+ lim = append(lim, imp)
+ // ignore stdlib done this way, b/c that's what the go tooling does
+ case strings.HasPrefix(imp, "./"):
+ if stdlib[imp[2:]] {
+ lim = append(lim, imp)
+ }
+ case strings.HasPrefix(imp, "../"):
+ if stdlib[imp[3:]] {
+ lim = append(lim, imp)
+ }
+ }
+ }
+
+ if len(lim) > 0 {
+ ptree.Packages[ip] = PackageOrErr{
+ Err: &LocalImportsError{
+ Dir: ip,
+ LocalImports: lim,
+ },
+ }
+ } else {
+ ptree.Packages[ip] = PackageOrErr{
+ P: pkg,
+ }
+ }
+
+ return nil
+ })
+
+ if err != nil {
+ return PackageTree{}, err
+ }
+
+ return ptree, nil
+}
+
+// LocalImportsError indicates that a package contains at least one relative
+// import that will prevent it from compiling.
+//
+// TODO(sdboyer) add a Files property once we're doing our own per-file parsing
+type LocalImportsError struct {
+ Dir string
+ LocalImports []string
+}
+
+func (e *LocalImportsError) Error() string {
+ return fmt.Sprintf("import path %s had problematic local imports", e.Dir)
+}
+
+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
+// 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.
+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
+ // containing a package with an error, or with a dep on an internal package
+ // that's missing.
+
+ const (
+ white uint8 = iota
+ grey
+ black
+ )
+
+ colors := make(map[string]uint8)
+ allreachsets := make(map[string]map[string]struct{})
+
+ // poison is a helper func to eliminate specific reachsets from allreachsets
+ poison := func(path []string) {
+ for _, ppkg := range path {
+ delete(allreachsets, ppkg)
+ }
+ }
+
+ var dfe func(string, []string) bool
+
+ // dfe is the depth-first-explorer that computes safe, error-free external
+ // reach map.
+ //
+ // pkg is the import path of the pkg currently being visited; path is the
+ // stack of parent packages we've visited to get to pkg. The return value
+ // indicates whether the level completed successfully (true) or if it was
+ // poisoned (false).
+ //
+ // TODO(sdboyer) some deft improvements could probably be made by passing the list of
+ // parent reachsets, rather than a list of parent package string names.
+ // might be able to eliminate the use of allreachsets map-of-maps entirely.
+ dfe = func(pkg string, path []string) bool {
+ // white is the zero value of uint8, which is what we want if the pkg
+ // isn't in the colors map, so this works fine
+ switch colors[pkg] {
+ case white:
+ // first visit to this pkg; mark it as in-process (grey)
+ colors[pkg] = grey
+
+ // make sure it's present and w/out errs
+ w, exists := workmap[pkg]
+ if !exists || w.err != nil {
+ // Does not exist or has an err; poison self and all parents
+ poison(path)
+
+ // we know we're done here, so mark it black
+ colors[pkg] = black
+ return false
+ }
+ // pkg exists with no errs. mark it as in-process (grey), and start
+ // a reachmap for it
+ //
+ // TODO(sdboyer) use sync.Pool here? can be lots of explicit map alloc/dealloc
+ rs := make(map[string]struct{})
+
+ // Push self onto the path slice. Passing this as a value has the
+ // effect of auto-popping the slice, while also giving us safe
+ // memory reuse.
+ path = append(path, pkg)
+
+ // Dump this package's external pkgs into its own reachset. Separate
+ // loop from the parent dump to avoid nested map loop lookups.
+ for ex := range w.ex {
+ rs[ex] = struct{}{}
+ }
+ allreachsets[pkg] = rs
+
+ // Push this pkg's external imports into all parent reachsets. Not
+ // all parents will necessarily have a reachset; none, some, or all
+ // could have been poisoned by a different path than what we're on
+ // right now. (Or we could be at depth 0)
+ for _, ppkg := range path {
+ if prs, exists := allreachsets[ppkg]; exists {
+ for ex := range w.ex {
+ prs[ex] = struct{}{}
+ }
+ }
+ }
+
+ // Now, recurse until done, or a false bubbles up, indicating the
+ // path is poisoned.
+ var clean bool
+ for in := range w.in {
+ // It's possible, albeit weird, for a package to import itself.
+ // If we try to visit self, though, then it erroneously poisons
+ // the path, as it would be interpreted as grey. In reality,
+ // this becomes a no-op, so just skip it.
+ if in == pkg {
+ continue
+ }
+
+ clean = dfe(in, path)
+ if !clean {
+ // Path is poisoned. Our reachmap was already deleted by the
+ // path we're returning from; mark ourselves black, then
+ // bubble up the poison. This is OK to do early, before
+ // exploring all internal imports, because the outer loop
+ // visits all internal packages anyway.
+ //
+ // In fact, stopping early is preferable - white subpackages
+ // won't have to iterate pointlessly through a parent path
+ // with no reachset.
+ colors[pkg] = black
+ return false
+ }
+ }
+
+ // Fully done with this pkg; no transitive problems.
+ colors[pkg] = black
+ return true
+
+ case grey:
+ // grey means an import cycle; guaranteed badness right here.
+ //
+ // FIXME handle import cycles by dropping everything involved. i
+ // think we need to compute SCC, then drop *all* of them?
+ colors[pkg] = black
+ poison(append(path, pkg)) // poison self and parents
+
+ case black:
+ // black means we're done with the package. If it has an entry in
+ // allreachsets, it completed successfully. If not, it was poisoned,
+ // and we need to bubble the poison back up.
+ rs, exists := allreachsets[pkg]
+ if !exists {
+ // just poison parents; self was necessarily already poisoned
+ poison(path)
+ return false
+ }
+
+ // It's good; pull over of the external imports from its reachset
+ // into all non-poisoned parent reachsets
+ for _, ppkg := range path {
+ if prs, exists := allreachsets[ppkg]; exists {
+ for ex := range rs {
+ prs[ex] = struct{}{}
+ }
+ }
+ }
+ return true
+
+ default:
+ panic(fmt.Sprintf("invalid color marker %v for %s", colors[pkg], pkg))
+ }
+
+ // shouldn't ever hit this
+ return false
+ }
+
+ // Run the depth-first exploration.
+ //
+ // Don't bother computing graph sources, this straightforward loop works
+ // comparably well, and fits nicely with an escape hatch in the dfe.
+ var path []string
+ for pkg := range workmap {
+ dfe(pkg, path)
+ }
+
+ if len(allreachsets) == 0 {
+ return nil
+ }
+
+ // Flatten allreachsets into the final reachlist
+ rt := strings.TrimSuffix(basedir, string(os.PathSeparator)) + string(os.PathSeparator)
+ rm := make(map[string][]string)
+ for pkg, rs := range allreachsets {
+ rlen := len(rs)
+ if rlen == 0 {
+ rm[strings.TrimPrefix(pkg, rt)] = nil
+ continue
+ }
+
+ edeps := make([]string, rlen)
+ k := 0
+ for opkg := range rs {
+ edeps[k] = opkg
+ k++
+ }
+
+ sort.Strings(edeps)
+ rm[strings.TrimPrefix(pkg, rt)] = edeps
+ }
+
+ 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
+// packages (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. main packages are generally excluded when analyzing anything other
+// than the root project, as they inherently 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 it is excluded from all transitive
+// dependency chains and does not appear as a key in the final map. 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
+//
+// If you ignore A/foo, then the returned map would be:
+//
+// map[string][]string{
+// "A": []string{},
+// "A/bar": []string{"B/baz"},
+// }
+//
+// It is safe to pass a nil map if there are no packages to ignore.
+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.
+//
+// main and tests determine whether main packages and test imports should be
+// included in the calculation. "External" is defined as anything not prefixed,
+// after path cleaning, by the PackageTree.ImportRoot. This includes stdlib.
+//
+// If an internal path is ignored, all of the external packages that it uniquely
+// imports are omitted. Note, however, that no internal transitivity checks are
+// made here - every non-ignored package in the tree is considered independently
+// (with one set of exceptions, noted below). That means, 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
+//
+// If you ignore A or A/foo, A/bar will still be visited, and B/baz will be
+// returned, because this method visits ALL packages in the tree, not only those reachable
+// from the root (or any other) packages. If your use case requires interrogating
+// external imports with respect to only specific package entry points, you need
+// ExternalReach() instead.
+//
+// It is safe to pass a nil map if there are no packages to ignore.
+//
+// If an internal package has an error (that is, PackageOrErr is Err), it is excluded from
+// consideration. Internal packages that transitively import the error package
+// are also excluded. So, if:
+//
+// -> B/foo
+// /
+// A
+// \
+// -> A/bar -> B/baz
+//
+// And A/bar has some error in it, then both A and A/bar will be eliminated from
+// consideration; neither B/foo nor B/baz will be in the results. If A/bar, with
+// its errors, is ignored, however, then A will remain, and B/foo will be in the
+// results.
+//
+// Finally, note that if a directory is named "testdata", or has a leading dot
+// or underscore, it will not be directly analyzed as a source. This is in
+// keeping with Go tooling conventions that such directories should be ignored.
+// So, if:
+//
+// A -> B/foo
+// A/.bar -> B/baz
+// A/_qux -> B/baz
+// A/testdata -> B/baz
+//
+// Then B/foo will be returned, but B/baz will not, because all three of the
+// packages that import it are in directories with disallowed names.
+//
+// HOWEVER, in keeping with the Go compiler, if one of those packages in a
+// disallowed directory is imported by a package in an allowed directory, then
+// it *will* be used. That is, while tools like go list will ignore a directory
+// named .foo, you can still import from .foo. Thus, it must be included. So,
+// if:
+//
+// -> B/foo
+// /
+// A
+// \
+// -> 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)
+
+ exm := make(map[string]struct{})
+ for pkg, reach := range rm {
+ // Eliminate import paths with any elements having leading dots, leading
+ // underscores, or testdata. If these are internally reachable (which is
+ // a no-no, but possible), any external imports will have already been
+ // pulled up through ExternalReach. The key here is that we don't want
+ // to treat such packages as themselves being sources.
+ //
+ // TODO(sdboyer) strings.Split will always heap alloc, which isn't great to do
+ // in a loop like this. We could also just parse it ourselves...
+ var skip bool
+ for _, elem := range strings.Split(pkg, "/") {
+ if strings.HasPrefix(elem, ".") || strings.HasPrefix(elem, "_") || elem == "testdata" {
+ skip = true
+ break
+ }
+ }
+
+ if !skip {
+ for _, ex := range reach {
+ exm[ex] = struct{}{}
+ }
+ }
+ }
+
+ if len(exm) == 0 {
+ return nil
+ }
+
+ ex := make([]string, len(exm))
+ k := 0
+ for p := range exm {
+ ex[k] = p
+ k++
+ }
+
+ sort.Strings(ex)
+ return ex
+}
+
+// checkPrefixSlash checks to see if the prefix is a prefix of the string as-is,
+// and that it is either equal OR the prefix + / is still a prefix.
+func checkPrefixSlash(s, prefix string) bool {
+ if !strings.HasPrefix(s, prefix) {
+ return false
+ }
+ return s == prefix || strings.HasPrefix(s, ensureTrailingSlash(prefix))
+}
diff --git a/vendor/github.com/sdboyer/gps/analysis_test.go b/vendor/github.com/sdboyer/gps/analysis_test.go
new file mode 100644
index 0000000..210d036
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/analysis_test.go
@@ -0,0 +1,1262 @@
+package gps
+
+import (
+ "fmt"
+ "go/build"
+ "os"
+ "path/filepath"
+ "reflect"
+ "strings"
+ "testing"
+)
+
+// PackageTree.ExternalReach() uses an easily separable algorithm, wmToReach(),
+// to turn a discovered set of packages and their imports into a proper external
+// reach map.
+//
+// That algorithm is purely symbolic (no filesystem interaction), and thus is
+// easy to test. This is that test.
+func TestWorkmapToReach(t *testing.T) {
+ empty := func() map[string]bool {
+ return make(map[string]bool)
+ }
+
+ table := map[string]struct {
+ workmap map[string]wm
+ basedir string
+ out map[string][]string
+ }{
+ "single": {
+ workmap: map[string]wm{
+ "foo": {
+ ex: empty(),
+ in: empty(),
+ },
+ },
+ out: map[string][]string{
+ "foo": nil,
+ },
+ },
+ "no external": {
+ workmap: map[string]wm{
+ "foo": {
+ ex: empty(),
+ in: empty(),
+ },
+ "foo/bar": {
+ ex: empty(),
+ in: empty(),
+ },
+ },
+ out: map[string][]string{
+ "foo": nil,
+ "foo/bar": nil,
+ },
+ },
+ "no external with subpkg": {
+ workmap: map[string]wm{
+ "foo": {
+ ex: empty(),
+ in: map[string]bool{
+ "foo/bar": true,
+ },
+ },
+ "foo/bar": {
+ ex: empty(),
+ in: empty(),
+ },
+ },
+ out: map[string][]string{
+ "foo": nil,
+ "foo/bar": nil,
+ },
+ },
+ "simple base transitive": {
+ workmap: map[string]wm{
+ "foo": {
+ ex: empty(),
+ in: map[string]bool{
+ "foo/bar": true,
+ },
+ },
+ "foo/bar": {
+ ex: map[string]bool{
+ "baz": true,
+ },
+ in: empty(),
+ },
+ },
+ out: map[string][]string{
+ "foo": {
+ "baz",
+ },
+ "foo/bar": {
+ "baz",
+ },
+ },
+ },
+ "missing package is poison": {
+ workmap: map[string]wm{
+ "A": {
+ ex: map[string]bool{
+ "B/foo": true,
+ },
+ in: map[string]bool{
+ "A/foo": true, // missing
+ "A/bar": true,
+ },
+ },
+ "A/bar": {
+ ex: map[string]bool{
+ "B/baz": true,
+ },
+ in: empty(),
+ },
+ },
+ out: map[string][]string{
+ "A/bar": {
+ "B/baz",
+ },
+ },
+ },
+ "transitive missing package is poison": {
+ workmap: map[string]wm{
+ "A": {
+ ex: map[string]bool{
+ "B/foo": true,
+ },
+ in: map[string]bool{
+ "A/foo": true, // transitively missing
+ "A/quux": true,
+ },
+ },
+ "A/foo": {
+ ex: map[string]bool{
+ "C/flugle": true,
+ },
+ in: map[string]bool{
+ "A/bar": true, // missing
+ },
+ },
+ "A/quux": {
+ ex: map[string]bool{
+ "B/baz": true,
+ },
+ in: empty(),
+ },
+ },
+ out: map[string][]string{
+ "A/quux": {
+ "B/baz",
+ },
+ },
+ },
+ "err'd package is poison": {
+ workmap: map[string]wm{
+ "A": {
+ ex: map[string]bool{
+ "B/foo": true,
+ },
+ in: map[string]bool{
+ "A/foo": true, // err'd
+ "A/bar": true,
+ },
+ },
+ "A/foo": {
+ err: fmt.Errorf("err pkg"),
+ },
+ "A/bar": {
+ ex: map[string]bool{
+ "B/baz": true,
+ },
+ in: empty(),
+ },
+ },
+ out: map[string][]string{
+ "A/bar": {
+ "B/baz",
+ },
+ },
+ },
+ "transitive err'd package is poison": {
+ workmap: map[string]wm{
+ "A": {
+ ex: map[string]bool{
+ "B/foo": true,
+ },
+ in: map[string]bool{
+ "A/foo": true, // transitively err'd
+ "A/quux": true,
+ },
+ },
+ "A/foo": {
+ ex: map[string]bool{
+ "C/flugle": true,
+ },
+ in: map[string]bool{
+ "A/bar": true, // err'd
+ },
+ },
+ "A/bar": {
+ err: fmt.Errorf("err pkg"),
+ },
+ "A/quux": {
+ ex: map[string]bool{
+ "B/baz": true,
+ },
+ in: empty(),
+ },
+ },
+ out: map[string][]string{
+ "A/quux": {
+ "B/baz",
+ },
+ },
+ },
+ }
+
+ for name, fix := range table {
+ out := wmToReach(fix.workmap, fix.basedir)
+ if !reflect.DeepEqual(out, fix.out) {
+ t.Errorf("wmToReach(%q): Did not get expected reach map:\n\t(GOT): %s\n\t(WNT): %s", name, out, fix.out)
+ }
+ }
+}
+
+func TestListPackages(t *testing.T) {
+ srcdir := filepath.Join(getwd(t), "_testdata", "src")
+ j := func(s string) string {
+ return filepath.Join(srcdir, s)
+ }
+
+ table := map[string]struct {
+ fileRoot string
+ importRoot string
+ out PackageTree
+ err error
+ }{
+ "empty": {
+ fileRoot: j("empty"),
+ importRoot: "empty",
+ out: PackageTree{
+ ImportRoot: "empty",
+ Packages: map[string]PackageOrErr{
+ "empty": {
+ Err: &build.NoGoError{
+ Dir: j("empty"),
+ },
+ },
+ },
+ },
+ err: nil,
+ },
+ "code only": {
+ fileRoot: j("simple"),
+ importRoot: "simple",
+ out: PackageTree{
+ ImportRoot: "simple",
+ Packages: map[string]PackageOrErr{
+ "simple": {
+ P: Package{
+ ImportPath: "simple",
+ CommentPath: "",
+ Name: "simple",
+ Imports: []string{
+ "github.com/sdboyer/gps",
+ "sort",
+ },
+ },
+ },
+ },
+ },
+ },
+ "impose import path": {
+ fileRoot: j("simple"),
+ importRoot: "arbitrary",
+ out: PackageTree{
+ ImportRoot: "arbitrary",
+ Packages: map[string]PackageOrErr{
+ "arbitrary": {
+ P: Package{
+ ImportPath: "arbitrary",
+ CommentPath: "",
+ Name: "simple",
+ Imports: []string{
+ "github.com/sdboyer/gps",
+ "sort",
+ },
+ },
+ },
+ },
+ },
+ },
+ "test only": {
+ fileRoot: j("t"),
+ importRoot: "simple",
+ out: PackageTree{
+ ImportRoot: "simple",
+ Packages: map[string]PackageOrErr{
+ "simple": {
+ P: Package{
+ ImportPath: "simple",
+ CommentPath: "",
+ Name: "simple",
+ Imports: []string{},
+ TestImports: []string{
+ "math/rand",
+ "strconv",
+ },
+ },
+ },
+ },
+ },
+ },
+ "xtest only": {
+ fileRoot: j("xt"),
+ importRoot: "simple",
+ out: PackageTree{
+ ImportRoot: "simple",
+ Packages: map[string]PackageOrErr{
+ "simple": {
+ P: Package{
+ ImportPath: "simple",
+ CommentPath: "",
+ Name: "simple",
+ Imports: []string{},
+ TestImports: []string{
+ "sort",
+ "strconv",
+ },
+ },
+ },
+ },
+ },
+ },
+ "code and test": {
+ fileRoot: j("simplet"),
+ importRoot: "simple",
+ out: PackageTree{
+ ImportRoot: "simple",
+ Packages: map[string]PackageOrErr{
+ "simple": {
+ P: Package{
+ ImportPath: "simple",
+ CommentPath: "",
+ Name: "simple",
+ Imports: []string{
+ "github.com/sdboyer/gps",
+ "sort",
+ },
+ TestImports: []string{
+ "math/rand",
+ "strconv",
+ },
+ },
+ },
+ },
+ },
+ },
+ "code and xtest": {
+ fileRoot: j("simplext"),
+ importRoot: "simple",
+ out: PackageTree{
+ ImportRoot: "simple",
+ Packages: map[string]PackageOrErr{
+ "simple": {
+ P: Package{
+ ImportPath: "simple",
+ CommentPath: "",
+ Name: "simple",
+ Imports: []string{
+ "github.com/sdboyer/gps",
+ "sort",
+ },
+ TestImports: []string{
+ "sort",
+ "strconv",
+ },
+ },
+ },
+ },
+ },
+ },
+ "code, test, xtest": {
+ fileRoot: j("simpleallt"),
+ importRoot: "simple",
+ out: PackageTree{
+ ImportRoot: "simple",
+ Packages: map[string]PackageOrErr{
+ "simple": {
+ P: Package{
+ ImportPath: "simple",
+ CommentPath: "",
+ Name: "simple",
+ Imports: []string{
+ "github.com/sdboyer/gps",
+ "sort",
+ },
+ TestImports: []string{
+ "math/rand",
+ "sort",
+ "strconv",
+ },
+ },
+ },
+ },
+ },
+ },
+ "one pkg multifile": {
+ fileRoot: j("m1p"),
+ importRoot: "m1p",
+ out: PackageTree{
+ ImportRoot: "m1p",
+ Packages: map[string]PackageOrErr{
+ "m1p": {
+ P: Package{
+ ImportPath: "m1p",
+ CommentPath: "",
+ Name: "m1p",
+ Imports: []string{
+ "github.com/sdboyer/gps",
+ "os",
+ "sort",
+ },
+ },
+ },
+ },
+ },
+ },
+ "one nested below": {
+ fileRoot: j("nest"),
+ importRoot: "nest",
+ out: PackageTree{
+ ImportRoot: "nest",
+ Packages: map[string]PackageOrErr{
+ "nest": {
+ P: Package{
+ ImportPath: "nest",
+ CommentPath: "",
+ Name: "simple",
+ Imports: []string{
+ "github.com/sdboyer/gps",
+ "sort",
+ },
+ },
+ },
+ "nest/m1p": {
+ P: Package{
+ ImportPath: "nest/m1p",
+ CommentPath: "",
+ Name: "m1p",
+ Imports: []string{
+ "github.com/sdboyer/gps",
+ "os",
+ "sort",
+ },
+ },
+ },
+ },
+ },
+ },
+ "two nested under empty root": {
+ fileRoot: j("ren"),
+ importRoot: "ren",
+ out: PackageTree{
+ ImportRoot: "ren",
+ Packages: map[string]PackageOrErr{
+ "ren": {
+ Err: &build.NoGoError{
+ Dir: j("ren"),
+ },
+ },
+ "ren/m1p": {
+ P: Package{
+ ImportPath: "ren/m1p",
+ CommentPath: "",
+ Name: "m1p",
+ Imports: []string{
+ "github.com/sdboyer/gps",
+ "os",
+ "sort",
+ },
+ },
+ },
+ "ren/simple": {
+ P: Package{
+ ImportPath: "ren/simple",
+ CommentPath: "",
+ Name: "simple",
+ Imports: []string{
+ "github.com/sdboyer/gps",
+ "sort",
+ },
+ },
+ },
+ },
+ },
+ },
+ "internal name mismatch": {
+ fileRoot: j("doublenest"),
+ importRoot: "doublenest",
+ out: PackageTree{
+ ImportRoot: "doublenest",
+ Packages: map[string]PackageOrErr{
+ "doublenest": {
+ P: Package{
+ ImportPath: "doublenest",
+ CommentPath: "",
+ Name: "base",
+ Imports: []string{
+ "github.com/sdboyer/gps",
+ "go/parser",
+ },
+ },
+ },
+ "doublenest/namemismatch": {
+ P: Package{
+ ImportPath: "doublenest/namemismatch",
+ CommentPath: "",
+ Name: "nm",
+ Imports: []string{
+ "github.com/Masterminds/semver",
+ "os",
+ },
+ },
+ },
+ "doublenest/namemismatch/m1p": {
+ P: Package{
+ ImportPath: "doublenest/namemismatch/m1p",
+ CommentPath: "",
+ Name: "m1p",
+ Imports: []string{
+ "github.com/sdboyer/gps",
+ "os",
+ "sort",
+ },
+ },
+ },
+ },
+ },
+ },
+ "file and importroot mismatch": {
+ fileRoot: j("doublenest"),
+ importRoot: "other",
+ out: PackageTree{
+ ImportRoot: "other",
+ Packages: map[string]PackageOrErr{
+ "other": {
+ P: Package{
+ ImportPath: "other",
+ CommentPath: "",
+ Name: "base",
+ Imports: []string{
+ "github.com/sdboyer/gps",
+ "go/parser",
+ },
+ },
+ },
+ "other/namemismatch": {
+ P: Package{
+ ImportPath: "other/namemismatch",
+ CommentPath: "",
+ Name: "nm",
+ Imports: []string{
+ "github.com/Masterminds/semver",
+ "os",
+ },
+ },
+ },
+ "other/namemismatch/m1p": {
+ P: Package{
+ ImportPath: "other/namemismatch/m1p",
+ CommentPath: "",
+ Name: "m1p",
+ Imports: []string{
+ "github.com/sdboyer/gps",
+ "os",
+ "sort",
+ },
+ },
+ },
+ },
+ },
+ },
+ "code and ignored main": {
+ fileRoot: j("igmain"),
+ importRoot: "simple",
+ out: PackageTree{
+ ImportRoot: "simple",
+ Packages: map[string]PackageOrErr{
+ "simple": {
+ P: Package{
+ ImportPath: "simple",
+ CommentPath: "",
+ Name: "simple",
+ Imports: []string{
+ "github.com/sdboyer/gps",
+ "sort",
+ "unicode",
+ },
+ },
+ },
+ },
+ },
+ },
+ "code and ignored main with comment leader": {
+ fileRoot: j("igmainlong"),
+ importRoot: "simple",
+ out: PackageTree{
+ ImportRoot: "simple",
+ Packages: map[string]PackageOrErr{
+ "simple": {
+ P: Package{
+ ImportPath: "simple",
+ CommentPath: "",
+ Name: "simple",
+ Imports: []string{
+ "github.com/sdboyer/gps",
+ "sort",
+ "unicode",
+ },
+ },
+ },
+ },
+ },
+ },
+ "code, tests, and ignored main": {
+ fileRoot: j("igmaint"),
+ importRoot: "simple",
+ out: PackageTree{
+ ImportRoot: "simple",
+ Packages: map[string]PackageOrErr{
+ "simple": {
+ P: Package{
+ ImportPath: "simple",
+ CommentPath: "",
+ Name: "simple",
+ Imports: []string{
+ "github.com/sdboyer/gps",
+ "sort",
+ "unicode",
+ },
+ TestImports: []string{
+ "math/rand",
+ "strconv",
+ },
+ },
+ },
+ },
+ },
+ },
+ "two pkgs": {
+ fileRoot: j("twopkgs"),
+ importRoot: "twopkgs",
+ out: PackageTree{
+ ImportRoot: "twopkgs",
+ Packages: map[string]PackageOrErr{
+ "twopkgs": {
+ Err: &build.MultiplePackageError{
+ Dir: j("twopkgs"),
+ Packages: []string{"simple", "m1p"},
+ Files: []string{"a.go", "b.go"},
+ },
+ },
+ },
+ },
+ },
+ // imports a missing pkg
+ "missing import": {
+ fileRoot: j("missing"),
+ importRoot: "missing",
+ out: PackageTree{
+ ImportRoot: "missing",
+ Packages: map[string]PackageOrErr{
+ "missing": {
+ P: Package{
+ ImportPath: "missing",
+ CommentPath: "",
+ Name: "simple",
+ Imports: []string{
+ "github.com/sdboyer/gps",
+ "missing/missing",
+ "sort",
+ },
+ },
+ },
+ "missing/m1p": {
+ P: Package{
+ ImportPath: "missing/m1p",
+ CommentPath: "",
+ Name: "m1p",
+ Imports: []string{
+ "github.com/sdboyer/gps",
+ "os",
+ "sort",
+ },
+ },
+ },
+ },
+ },
+ },
+ // has disallowed dir names
+ "disallowed dirs": {
+ fileRoot: j("disallow"),
+ importRoot: "disallow",
+ out: PackageTree{
+ ImportRoot: "disallow",
+ Packages: map[string]PackageOrErr{
+ "disallow": {
+ P: Package{
+ ImportPath: "disallow",
+ CommentPath: "",
+ Name: "disallow",
+ Imports: []string{
+ "disallow/testdata",
+ "github.com/sdboyer/gps",
+ "sort",
+ },
+ },
+ },
+ // disallow/.m1p is ignored by listPackages...for now. Kept
+ // here commented because this might change again...
+ //"disallow/.m1p": {
+ //P: Package{
+ //ImportPath: "disallow/.m1p",
+ //CommentPath: "",
+ //Name: "m1p",
+ //Imports: []string{
+ //"github.com/sdboyer/gps",
+ //"os",
+ //"sort",
+ //},
+ //},
+ //},
+ "disallow/testdata": {
+ P: Package{
+ ImportPath: "disallow/testdata",
+ CommentPath: "",
+ Name: "testdata",
+ Imports: []string{
+ "hash",
+ },
+ },
+ },
+ },
+ },
+ },
+ // This case mostly exists for the PackageTree methods, but it does
+ // cover a bit of range
+ "varied": {
+ fileRoot: j("varied"),
+ importRoot: "varied",
+ out: PackageTree{
+ ImportRoot: "varied",
+ Packages: map[string]PackageOrErr{
+ "varied": {
+ P: Package{
+ ImportPath: "varied",
+ CommentPath: "",
+ Name: "main",
+ Imports: []string{
+ "net/http",
+ "varied/namemismatch",
+ "varied/otherpath",
+ "varied/simple",
+ },
+ },
+ },
+ "varied/otherpath": {
+ P: Package{
+ ImportPath: "varied/otherpath",
+ CommentPath: "",
+ Name: "otherpath",
+ Imports: []string{},
+ TestImports: []string{
+ "varied/m1p",
+ },
+ },
+ },
+ "varied/simple": {
+ P: Package{
+ ImportPath: "varied/simple",
+ CommentPath: "",
+ Name: "simple",
+ Imports: []string{
+ "github.com/sdboyer/gps",
+ "go/parser",
+ "varied/simple/another",
+ },
+ },
+ },
+ "varied/simple/another": {
+ P: Package{
+ ImportPath: "varied/simple/another",
+ CommentPath: "",
+ Name: "another",
+ Imports: []string{
+ "hash",
+ "varied/m1p",
+ },
+ TestImports: []string{
+ "encoding/binary",
+ },
+ },
+ },
+ "varied/namemismatch": {
+ P: Package{
+ ImportPath: "varied/namemismatch",
+ CommentPath: "",
+ Name: "nm",
+ Imports: []string{
+ "github.com/Masterminds/semver",
+ "os",
+ },
+ },
+ },
+ "varied/m1p": {
+ P: Package{
+ ImportPath: "varied/m1p",
+ CommentPath: "",
+ Name: "m1p",
+ Imports: []string{
+ "github.com/sdboyer/gps",
+ "os",
+ "sort",
+ },
+ },
+ },
+ },
+ },
+ },
+ }
+
+ for name, fix := range table {
+ if _, err := os.Stat(fix.fileRoot); err != nil {
+ t.Errorf("listPackages(%q): error on fileRoot %s: %s", name, fix.fileRoot, err)
+ continue
+ }
+
+ 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)
+ } else if fix.err != nil && err == nil {
+ t.Errorf("listPackages(%q): Error expected but none received", name)
+ } else if fix.err != nil && err != nil {
+ if !reflect.DeepEqual(fix.err, err) {
+ t.Errorf("listPackages(%q): Did not receive expected error:\n\t(GOT): %s\n\t(WNT): %s", name, err, fix.err)
+ }
+ }
+
+ if fix.out.ImportRoot != "" && fix.out.Packages != nil {
+ if !reflect.DeepEqual(out, fix.out) {
+ if fix.out.ImportRoot != out.ImportRoot {
+ t.Errorf("listPackages(%q): Expected ImportRoot %s, got %s", name, fix.out.ImportRoot, out.ImportRoot)
+ }
+
+ // overwrite the out one to see if we still have a real problem
+ out.ImportRoot = fix.out.ImportRoot
+
+ if !reflect.DeepEqual(out, fix.out) {
+ if len(fix.out.Packages) < 2 {
+ t.Errorf("listPackages(%q): Did not get expected PackageOrErrs:\n\t(GOT): %s\n\t(WNT): %s", name, out, fix.out)
+ } else {
+ seen := make(map[string]bool)
+ for path, perr := range fix.out.Packages {
+ seen[path] = true
+ if operr, exists := out.Packages[path]; !exists {
+ t.Errorf("listPackages(%q): Expected PackageOrErr for path %s was missing from output:\n\t%s", name, path, perr)
+ } else {
+ if !reflect.DeepEqual(perr, operr) {
+ t.Errorf("listPackages(%q): PkgOrErr for path %s was not as expected:\n\t(GOT): %s\n\t(WNT): %s", name, path, operr, perr)
+ }
+ }
+ }
+
+ for path, operr := range out.Packages {
+ if seen[path] {
+ continue
+ }
+
+ t.Errorf("listPackages(%q): Got PackageOrErr for path %s, but none was expected:\n\t%s", name, path, operr)
+ }
+ }
+ }
+ }
+ }
+ }
+}
+
+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")
+ if err != nil {
+ t.Fatalf("listPackages failed on varied test case: %s", err)
+ }
+
+ var expect []string
+ var name string
+ var ignore map[string]bool
+ var main, tests bool
+
+ validate := func() {
+ result := vptree.ListExternalImports(main, tests, ignore)
+ if !reflect.DeepEqual(expect, result) {
+ t.Errorf("Wrong imports in %q case:\n\t(GOT): %s\n\t(WNT): %s", name, result, expect)
+ }
+ }
+
+ all := []string{
+ "encoding/binary",
+ "github.com/Masterminds/semver",
+ "github.com/sdboyer/gps",
+ "go/parser",
+ "hash",
+ "net/http",
+ "os",
+ "sort",
+ }
+
+ // helper to rewrite expect, except for a couple packages
+ //
+ // this makes it easier to see what we're taking out on each test
+ except := func(not ...string) {
+ expect = make([]string, len(all)-len(not))
+
+ drop := make(map[string]bool)
+ for _, npath := range not {
+ drop[npath] = true
+ }
+
+ k := 0
+ for _, path := range all {
+ if !drop[path] {
+ expect[k] = path
+ k++
+ }
+ }
+ }
+
+ // everything on
+ name = "simple"
+ except()
+ main, tests = true, true
+ validate()
+
+ // Now without tests, which should just cut one
+ name = "no tests"
+ tests = false
+ except("encoding/binary")
+ validate()
+
+ // Now skip main, which still just cuts out one
+ name = "no main"
+ main, tests = false, true
+ except("net/http")
+ validate()
+
+ // No test and no main, which should be additive
+ name = "no test, no main"
+ main, tests = false, false
+ except("net/http", "encoding/binary")
+ validate()
+
+ // now, the ignore tests. turn main and tests back on
+ main, tests = true, true
+
+ // start with non-matching
+ name = "non-matching ignore"
+ ignore = map[string]bool{
+ "nomatch": true,
+ }
+ except()
+ validate()
+
+ // should have the same effect as ignoring main
+ name = "ignore the root"
+ ignore = map[string]bool{
+ "varied": true,
+ }
+ except("net/http")
+ validate()
+
+ // now drop a more interesting one
+ name = "ignore simple"
+ ignore = map[string]bool{
+ "varied/simple": true,
+ }
+ // we get github.com/sdboyer/gps from m1p, too, so it should still be there
+ except("go/parser")
+ validate()
+
+ // now drop two
+ name = "ignore simple and namemismatch"
+ ignore = map[string]bool{
+ "varied/simple": true,
+ "varied/namemismatch": true,
+ }
+ except("go/parser", "github.com/Masterminds/semver")
+ validate()
+
+ // make sure tests and main play nice with ignore
+ name = "ignore simple and namemismatch, and no tests"
+ tests = false
+ except("go/parser", "github.com/Masterminds/semver", "encoding/binary")
+ validate()
+ name = "ignore simple and namemismatch, and no main"
+ main, tests = false, true
+ except("go/parser", "github.com/Masterminds/semver", "net/http")
+ validate()
+ name = "ignore simple and namemismatch, and no main or tests"
+ main, tests = false, false
+ except("go/parser", "github.com/Masterminds/semver", "net/http", "encoding/binary")
+ validate()
+
+ main, tests = true, true
+
+ // ignore two that should knock out gps
+ name = "ignore both importers"
+ ignore = map[string]bool{
+ "varied/simple": true,
+ "varied/m1p": true,
+ }
+ except("sort", "github.com/sdboyer/gps", "go/parser")
+ validate()
+
+ // finally, directly ignore some external packages
+ name = "ignore external"
+ ignore = map[string]bool{
+ "github.com/sdboyer/gps": true,
+ "go/parser": true,
+ "sort": true,
+ }
+ except("sort", "github.com/sdboyer/gps", "go/parser")
+ validate()
+
+ // The only thing varied *doesn't* cover is disallowed path patterns
+ 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)
+ 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)
+ }
+}
+
+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")
+ if err != nil {
+ t.Fatalf("listPackages failed on varied test case: %s", err)
+ }
+
+ // Set up vars for validate closure
+ var expect map[string][]string
+ var name string
+ var main, tests bool
+ var ignore map[string]bool
+
+ validate := func() {
+ result := vptree.ExternalReach(main, tests, ignore)
+ if !reflect.DeepEqual(expect, result) {
+ seen := make(map[string]bool)
+ for ip, epkgs := range expect {
+ seen[ip] = true
+ if pkgs, exists := result[ip]; !exists {
+ t.Errorf("ver(%q): expected import path %s was not present in result", name, ip)
+ } else {
+ if !reflect.DeepEqual(pkgs, epkgs) {
+ t.Errorf("ver(%q): did not get expected package set for import path %s:\n\t(GOT): %s\n\t(WNT): %s", name, ip, pkgs, epkgs)
+ }
+ }
+ }
+
+ for ip, pkgs := range result {
+ if seen[ip] {
+ continue
+ }
+ t.Errorf("ver(%q): Got packages for import path %s, but none were expected:\n\t%s", name, ip, pkgs)
+ }
+ }
+ }
+
+ all := map[string][]string{
+ "varied": {"encoding/binary", "github.com/Masterminds/semver", "github.com/sdboyer/gps", "go/parser", "hash", "net/http", "os", "sort"},
+ "varied/m1p": {"github.com/sdboyer/gps", "os", "sort"},
+ "varied/namemismatch": {"github.com/Masterminds/semver", "os"},
+ "varied/otherpath": {"github.com/sdboyer/gps", "os", "sort"},
+ "varied/simple": {"encoding/binary", "github.com/sdboyer/gps", "go/parser", "hash", "os", "sort"},
+ "varied/simple/another": {"encoding/binary", "github.com/sdboyer/gps", "hash", "os", "sort"},
+ }
+ // build a map to validate the exception inputs. do this because shit is
+ // hard enough to keep track of that it's preferable not to have silent
+ // success if a typo creeps in and we're trying to except an import that
+ // isn't in a pkg in the first place
+ valid := make(map[string]map[string]bool)
+ for ip, expkgs := range all {
+ m := make(map[string]bool)
+ for _, pkg := range expkgs {
+ m[pkg] = true
+ }
+ valid[ip] = m
+ }
+
+ // helper to compose expect, excepting specific packages
+ //
+ // this makes it easier to see what we're taking out on each test
+ except := func(pkgig ...string) {
+ // reinit expect with everything from all
+ expect = make(map[string][]string)
+ for ip, expkgs := range all {
+ sl := make([]string, len(expkgs))
+ copy(sl, expkgs)
+ expect[ip] = sl
+ }
+
+ // now build the dropmap
+ drop := make(map[string]map[string]bool)
+ for _, igstr := range pkgig {
+ // split on space; first elem is import path to pkg, the rest are
+ // the imports to drop.
+ not := strings.Split(igstr, " ")
+ var ip string
+ ip, not = not[0], not[1:]
+ if _, exists := valid[ip]; !exists {
+ t.Fatalf("%s is not a package name we're working with, doofus", ip)
+ }
+
+ // if only a single elem was passed, though, drop the whole thing
+ if len(not) == 0 {
+ delete(expect, ip)
+ continue
+ }
+
+ m := make(map[string]bool)
+ for _, imp := range not {
+ if !valid[ip][imp] {
+ t.Fatalf("%s is not a reachable import of %s, even in the all case", imp, ip)
+ }
+ m[imp] = true
+ }
+
+ drop[ip] = m
+ }
+
+ for ip, pkgs := range expect {
+ var npkgs []string
+ for _, imp := range pkgs {
+ if !drop[ip][imp] {
+ npkgs = append(npkgs, imp)
+ }
+ }
+
+ expect[ip] = npkgs
+ }
+ }
+
+ // first, validate all
+ name = "all"
+ main, tests = true, true
+ except()
+ validate()
+
+ // turn off main pkgs, which necessarily doesn't affect anything else
+ name = "no main"
+ main = false
+ except("varied")
+ validate()
+
+ // ignoring the "varied" pkg has same effect as disabling main pkgs
+ name = "ignore root"
+ ignore = map[string]bool{
+ "varied": true,
+ }
+ main = true
+ validate()
+
+ // when we drop tests, varied/otherpath loses its link to varied/m1p and
+ // varied/simple/another loses its test import, which has a fairly big
+ // cascade
+ name = "no tests"
+ tests = false
+ ignore = nil
+ except(
+ "varied encoding/binary",
+ "varied/simple encoding/binary",
+ "varied/simple/another encoding/binary",
+ "varied/otherpath github.com/sdboyer/gps os sort",
+ )
+
+ // almost the same as previous, but varied just goes away completely
+ name = "no main or tests"
+ main = false
+ except(
+ "varied",
+ "varied/simple encoding/binary",
+ "varied/simple/another encoding/binary",
+ "varied/otherpath github.com/sdboyer/gps os sort",
+ )
+ validate()
+
+ // focus on ignores now, so reset main and tests
+ main, tests = true, true
+
+ // now, the fun stuff. punch a hole in the middle by cutting out
+ // varied/simple
+ name = "ignore varied/simple"
+ ignore = map[string]bool{
+ "varied/simple": true,
+ }
+ except(
+ // root pkg loses on everything in varied/simple/another
+ "varied hash encoding/binary go/parser",
+ "varied/simple",
+ )
+ validate()
+
+ // widen the hole by excluding otherpath
+ name = "ignore varied/{otherpath,simple}"
+ ignore = map[string]bool{
+ "varied/otherpath": true,
+ "varied/simple": true,
+ }
+ except(
+ // root pkg loses on everything in varied/simple/another and varied/m1p
+ "varied hash encoding/binary go/parser github.com/sdboyer/gps sort",
+ "varied/otherpath",
+ "varied/simple",
+ )
+ validate()
+
+ // remove namemismatch, though we're mostly beating a dead horse now
+ name = "ignore varied/{otherpath,simple,namemismatch}"
+ ignore["varied/namemismatch"] = true
+ except(
+ // root pkg loses on everything in varied/simple/another and varied/m1p
+ "varied hash encoding/binary go/parser github.com/sdboyer/gps sort os github.com/Masterminds/semver",
+ "varied/otherpath",
+ "varied/simple",
+ "varied/namemismatch",
+ )
+ validate()
+}
+
+var _ = map[string][]string{
+ "varied": {"encoding/binary", "github.com/Masterminds/semver", "github.com/sdboyer/gps", "go/parser", "hash", "net/http", "os", "sort"},
+ "varied/m1p": {"github.com/sdboyer/gps", "os", "sort"},
+ "varied/namemismatch": {"github.com/Masterminds/semver", "os"},
+ "varied/otherpath": {"github.com/sdboyer/gps", "os", "sort"},
+ "varied/simple": {"encoding/binary", "github.com/sdboyer/gps", "go/parser", "hash", "os", "sort"},
+ "varied/simple/another": {"encoding/binary", "github.com/sdboyer/gps", "hash", "os", "sort"},
+}
+
+func getwd(t *testing.T) string {
+ cwd, err := os.Getwd()
+ if err != nil {
+ t.Fatal(err)
+ }
+ return cwd
+}
diff --git a/vendor/github.com/sdboyer/gps/appveyor.yml b/vendor/github.com/sdboyer/gps/appveyor.yml
new file mode 100644
index 0000000..9bf23a3
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/appveyor.yml
@@ -0,0 +1,24 @@
+version: build-{build}.{branch}
+
+clone_folder: C:\gopath\src\github.com\sdboyer\gps
+shallow_clone: true
+
+environment:
+ GOPATH: C:\gopath
+
+platform:
+ - x64
+
+install:
+ - go version
+ - go env
+ - choco install bzr hg
+ - set PATH=C:\Program Files (x86)\Bazaar\;C:\Program Files\Mercurial\;%PATH%
+build_script:
+ - go get github.com/Masterminds/glide
+ - C:\gopath\bin\glide install
+
+test_script:
+ - go test
+
+deploy: off
diff --git a/vendor/github.com/sdboyer/gps/bridge.go b/vendor/github.com/sdboyer/gps/bridge.go
new file mode 100644
index 0000000..8b26e6b
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/bridge.go
@@ -0,0 +1,627 @@
+package gps
+
+import (
+ "fmt"
+ "os"
+ "path/filepath"
+ "sort"
+)
+
+// sourceBridges provide an adapter to SourceManagers that tailor operations
+// for a single solve run.
+type sourceBridge interface {
+ getProjectInfo(pa atom) (Manifest, Lock, error)
+ listVersions(id ProjectIdentifier) ([]Version, error)
+ listPackages(id ProjectIdentifier, v Version) (PackageTree, error)
+ computeRootReach() ([]string, error)
+ revisionPresentIn(id ProjectIdentifier, r Revision) (bool, error)
+ pairRevision(id ProjectIdentifier, r Revision) []Version
+ pairVersion(id ProjectIdentifier, v UnpairedVersion) PairedVersion
+ repoExists(id ProjectIdentifier) (bool, error)
+ vendorCodeExists(id ProjectIdentifier) (bool, error)
+ matches(id ProjectIdentifier, c Constraint, v Version) bool
+ matchesAny(id ProjectIdentifier, c1, c2 Constraint) bool
+ intersect(id ProjectIdentifier, c1, c2 Constraint) Constraint
+ verifyRootDir(path string) error
+ deduceRemoteRepo(path string) (*remoteRepo, error)
+}
+
+// bridge is an adapter around a proper SourceManager. It provides localized
+// caching that's tailored to the requirements of a particular solve run.
+//
+// It also performs transformations between ProjectIdentifiers, which is what
+// the solver primarily deals in, and ProjectRoot, which is what the
+// SourceManager primarily deals in. This separation is helpful because it keeps
+// the complexities of deciding what a particular name "means" entirely within
+// the solver, while the SourceManager can traffic exclusively in
+// globally-unique network names.
+//
+// Finally, it provides authoritative version/constraint operations, ensuring
+// that any possible approach to a match - even those not literally encoded in
+// the inputs - is achieved.
+type bridge struct {
+ // The underlying, adapted-to SourceManager
+ sm SourceManager
+
+ // The solver which we're assisting.
+ //
+ // The link between solver and bridge is circular, which is typically a bit
+ // awkward, but the bridge needs access to so many of the input arguments
+ // held by the solver that it ends up being easier and saner to do this.
+ s *solver
+
+ // Simple, local cache of the root's PackageTree
+ crp *struct {
+ ptree PackageTree
+ err error
+ }
+
+ // Map of project root name to their available version list. This cache is
+ // layered on top of the proper SourceManager's cache; the only difference
+ // is that this keeps the versions sorted in the direction required by the
+ // current solve run
+ vlists map[ProjectRoot][]Version
+}
+
+// Global factory func to create a bridge. This exists solely to allow tests to
+// override it with a custom bridge and sm.
+var mkBridge func(*solver, SourceManager) sourceBridge = func(s *solver, sm SourceManager) sourceBridge {
+ return &bridge{
+ sm: sm,
+ s: s,
+ vlists: make(map[ProjectRoot][]Version),
+ }
+}
+
+func (b *bridge) getProjectInfo(pa atom) (Manifest, Lock, error) {
+ if pa.id.ProjectRoot == b.s.params.ImportRoot {
+ return b.s.rm, b.s.rl, nil
+ }
+ return b.sm.GetProjectInfo(ProjectRoot(pa.id.netName()), pa.v)
+}
+
+func (b *bridge) key(id ProjectIdentifier) ProjectRoot {
+ k := ProjectRoot(id.NetworkName)
+ if k == "" {
+ k = id.ProjectRoot
+ }
+
+ return k
+}
+
+func (b *bridge) listVersions(id ProjectIdentifier) ([]Version, error) {
+ k := b.key(id)
+
+ if vl, exists := b.vlists[k]; exists {
+ return vl, nil
+ }
+
+ vl, err := b.sm.ListVersions(k)
+ // TODO(sdboyer) cache errors, too?
+ if err != nil {
+ return nil, err
+ }
+
+ if b.s.params.Downgrade {
+ sort.Sort(downgradeVersionSorter(vl))
+ } else {
+ sort.Sort(upgradeVersionSorter(vl))
+ }
+
+ b.vlists[k] = vl
+ return vl, nil
+}
+
+func (b *bridge) revisionPresentIn(id ProjectIdentifier, r Revision) (bool, error) {
+ k := b.key(id)
+ return b.sm.RevisionPresentIn(k, r)
+}
+
+func (b *bridge) repoExists(id ProjectIdentifier) (bool, error) {
+ k := b.key(id)
+ return b.sm.RepoExists(k)
+}
+
+func (b *bridge) vendorCodeExists(id ProjectIdentifier) (bool, error) {
+ fi, err := os.Stat(filepath.Join(b.s.params.RootDir, "vendor", string(id.ProjectRoot)))
+ if err != nil {
+ return false, err
+ } else if fi.IsDir() {
+ return true, nil
+ }
+
+ return false, nil
+}
+
+func (b *bridge) pairVersion(id ProjectIdentifier, v UnpairedVersion) PairedVersion {
+ vl, err := b.listVersions(id)
+ if err != nil {
+ return nil
+ }
+
+ // doing it like this is a bit sloppy
+ for _, v2 := range vl {
+ if p, ok := v2.(PairedVersion); ok {
+ if p.Matches(v) {
+ return p
+ }
+ }
+ }
+
+ return nil
+}
+
+func (b *bridge) pairRevision(id ProjectIdentifier, r Revision) []Version {
+ vl, err := b.listVersions(id)
+ if err != nil {
+ return nil
+ }
+
+ p := []Version{r}
+ // doing it like this is a bit sloppy
+ for _, v2 := range vl {
+ if pv, ok := v2.(PairedVersion); ok {
+ if pv.Matches(r) {
+ p = append(p, pv)
+ }
+ }
+ }
+
+ return p
+}
+
+// matches performs a typical match check between the provided version and
+// constraint. If that basic check fails and the provided version is incomplete
+// (e.g. an unpaired version or bare revision), it will attempt to gather more
+// information on one or the other and re-perform the comparison.
+func (b *bridge) matches(id ProjectIdentifier, c2 Constraint, v Version) bool {
+ if c2.Matches(v) {
+ return true
+ }
+
+ // There's a wide field of possible ways that pairing might result in a
+ // match. For each possible type of version, start by carving out all the
+ // cases where the constraint would have provided an authoritative match
+ // result.
+ switch tv := v.(type) {
+ case PairedVersion:
+ switch tc := c2.(type) {
+ case PairedVersion, Revision, noneConstraint:
+ // These three would all have been authoritative matches
+ return false
+ case UnpairedVersion:
+ // Only way paired and unpaired could match is if they share an
+ // underlying rev
+ pv := b.pairVersion(id, tc)
+ if pv == nil {
+ return false
+ }
+ return pv.Matches(v)
+ case semverConstraint:
+ // Have to check all the possible versions for that rev to see if
+ // any match the semver constraint
+ for _, pv := range b.pairRevision(id, tv.Underlying()) {
+ if tc.Matches(pv) {
+ return true
+ }
+ }
+ return false
+ }
+
+ case Revision:
+ switch tc := c2.(type) {
+ case PairedVersion, Revision, noneConstraint:
+ // These three would all have been authoritative matches
+ return false
+ case UnpairedVersion:
+ // Only way paired and unpaired could match is if they share an
+ // underlying rev
+ pv := b.pairVersion(id, tc)
+ if pv == nil {
+ return false
+ }
+ return pv.Matches(v)
+ case semverConstraint:
+ // Have to check all the possible versions for the rev to see if
+ // any match the semver constraint
+ for _, pv := range b.pairRevision(id, tv) {
+ if tc.Matches(pv) {
+ return true
+ }
+ }
+ return false
+ }
+
+ // UnpairedVersion as input has the most weird cases. It's also the one
+ // we'll probably see the least
+ case UnpairedVersion:
+ switch tc := c2.(type) {
+ case noneConstraint:
+ // obviously
+ return false
+ case Revision, PairedVersion:
+ // Easy case for both - just pair the uv and see if it matches the revision
+ // constraint
+ pv := b.pairVersion(id, tv)
+ if pv == nil {
+ return false
+ }
+ return tc.Matches(pv)
+ case UnpairedVersion:
+ // Both are unpaired versions. See if they share an underlying rev.
+ pv := b.pairVersion(id, tv)
+ if pv == nil {
+ return false
+ }
+
+ pc := b.pairVersion(id, tc)
+ if pc == nil {
+ return false
+ }
+ return pc.Matches(pv)
+
+ case semverConstraint:
+ // semverConstraint can't ever match a rev, but we do need to check
+ // if any other versions corresponding to this rev work.
+ pv := b.pairVersion(id, tv)
+ if pv == nil {
+ return false
+ }
+
+ for _, ttv := range b.pairRevision(id, pv.Underlying()) {
+ if c2.Matches(ttv) {
+ return true
+ }
+ }
+ return false
+ }
+ default:
+ panic("unreachable")
+ }
+
+ return false
+}
+
+// matchesAny is the authoritative version of Constraint.MatchesAny.
+func (b *bridge) matchesAny(id ProjectIdentifier, c1, c2 Constraint) bool {
+ if c1.MatchesAny(c2) {
+ return true
+ }
+
+ // This approach is slightly wasteful, but just SO much less verbose, and
+ // more easily understood.
+ var uc1, uc2 Constraint
+ if v1, ok := c1.(Version); ok {
+ uc1 = b.vtu(id, v1)
+ } else {
+ uc1 = c1
+ }
+
+ if v2, ok := c2.(Version); ok {
+ uc2 = b.vtu(id, v2)
+ } else {
+ uc2 = c2
+ }
+
+ return uc1.MatchesAny(uc2)
+}
+
+// intersect is the authoritative version of Constraint.Intersect.
+func (b *bridge) intersect(id ProjectIdentifier, c1, c2 Constraint) Constraint {
+ rc := c1.Intersect(c2)
+ if rc != none {
+ return rc
+ }
+
+ // This approach is slightly wasteful, but just SO much less verbose, and
+ // more easily understood.
+ var uc1, uc2 Constraint
+ if v1, ok := c1.(Version); ok {
+ uc1 = b.vtu(id, v1)
+ } else {
+ uc1 = c1
+ }
+
+ if v2, ok := c2.(Version); ok {
+ uc2 = b.vtu(id, v2)
+ } else {
+ uc2 = c2
+ }
+
+ return uc1.Intersect(uc2)
+}
+
+// vtu creates a versionTypeUnion for the provided version.
+//
+// This union may (and typically will) end up being nothing more than the single
+// input version, but creating a versionTypeUnion guarantees that 'local'
+// constraint checks (direct method calls) are authoritative.
+func (b *bridge) vtu(id ProjectIdentifier, v Version) versionTypeUnion {
+ switch tv := v.(type) {
+ case Revision:
+ return versionTypeUnion(b.pairRevision(id, tv))
+ case PairedVersion:
+ return versionTypeUnion(b.pairRevision(id, tv.Underlying()))
+ case UnpairedVersion:
+ pv := b.pairVersion(id, tv)
+ if pv == nil {
+ return versionTypeUnion{tv}
+ }
+
+ return versionTypeUnion(b.pairRevision(id, pv.Underlying()))
+ }
+
+ 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()
+ }
+
+ // FIXME if we're aliasing here, the returned PackageTree will have
+ // unaliased import paths, which is super not correct
+ return b.sm.ListPackages(b.key(id), v)
+}
+
+// verifyRoot ensures that the provided path to the project root is in good
+// working condition. This check is made only once, at the beginning of a solve
+// run.
+func (b *bridge) verifyRootDir(path string) error {
+ if fi, err := os.Stat(path); err != nil {
+ return badOptsFailure(fmt.Sprintf("could not read project root (%s): %s", path, err))
+ } else if !fi.IsDir() {
+ return badOptsFailure(fmt.Sprintf("project root (%s) is a file, not a directory", path))
+ }
+
+ return nil
+}
+
+// deduceRemoteRepo deduces certain network-oriented properties about an import
+// path.
+func (b *bridge) deduceRemoteRepo(path string) (*remoteRepo, error) {
+ return deduceRemoteRepo(path)
+}
+
+// versionTypeUnion represents a set of versions that are, within the scope of
+// this solver run, equivalent.
+//
+// The simple case here is just a pair - a normal version plus its underlying
+// revision - but if a tag or branch point at the same rev, then we consider
+// them equivalent. Again, however, this equivalency is short-lived; it must be
+// re-assessed during every solver run.
+//
+// The union members are treated as being OR'd together: all constraint
+// operations attempt each member, and will take the most open/optimistic
+// answer.
+//
+// This technically does allow tags to match branches - something we
+// otherwise try hard to avoid - but because the original input constraint never
+// actually changes (and is never written out in the Result), there's no harmful
+// case of a user suddenly riding a branch when they expected a fixed tag.
+type versionTypeUnion []Version
+
+// This should generally not be called, but is required for the interface. If it
+// is called, we have a bigger problem (the type has escaped the solver); thus,
+// panic.
+func (av versionTypeUnion) String() string {
+ panic("versionTypeUnion should never be turned into a string; it is solver internal-only")
+}
+
+// This should generally not be called, but is required for the interface. If it
+// is called, we have a bigger problem (the type has escaped the solver); thus,
+// panic.
+func (av versionTypeUnion) Type() string {
+ panic("versionTypeUnion should never need to answer a Type() call; it is solver internal-only")
+}
+
+// Matches takes a version, and returns true if that version matches any version
+// contained in the union.
+//
+// This DOES allow tags to match branches, albeit indirectly through a revision.
+func (av versionTypeUnion) Matches(v Version) bool {
+ av2, oav := v.(versionTypeUnion)
+
+ for _, v1 := range av {
+ if oav {
+ for _, v2 := range av2 {
+ if v1.Matches(v2) {
+ return true
+ }
+ }
+ } else if v1.Matches(v) {
+ return true
+ }
+ }
+
+ return false
+}
+
+// MatchesAny returns true if any of the contained versions (which are also
+// constraints) in the union successfully MatchAny with the provided
+// constraint.
+func (av versionTypeUnion) MatchesAny(c Constraint) bool {
+ av2, oav := c.(versionTypeUnion)
+
+ for _, v1 := range av {
+ if oav {
+ for _, v2 := range av2 {
+ if v1.MatchesAny(v2) {
+ return true
+ }
+ }
+ } else if v1.MatchesAny(c) {
+ return true
+ }
+ }
+
+ return false
+}
+
+// Intersect takes a constraint, and attempts to intersect it with all the
+// versions contained in the union until one returns non-none. If that never
+// happens, then none is returned.
+//
+// In order to avoid weird version floating elsewhere in the solver, the union
+// always returns the input constraint. (This is probably obviously correct, but
+// is still worth noting.)
+func (av versionTypeUnion) Intersect(c Constraint) Constraint {
+ av2, oav := c.(versionTypeUnion)
+
+ for _, v1 := range av {
+ if oav {
+ for _, v2 := range av2 {
+ if rc := v1.Intersect(v2); rc != none {
+ return rc
+ }
+ }
+ } else if rc := v1.Intersect(c); rc != none {
+ return rc
+ }
+ }
+
+ return none
+}
+
+func (av versionTypeUnion) _private() {}
+
+type upgradeVersionSorter []Version
+type downgradeVersionSorter []Version
+
+func (vs upgradeVersionSorter) Len() int {
+ return len(vs)
+}
+
+func (vs upgradeVersionSorter) Swap(i, j int) {
+ vs[i], vs[j] = vs[j], vs[i]
+}
+
+func (vs downgradeVersionSorter) Len() int {
+ return len(vs)
+}
+
+func (vs downgradeVersionSorter) Swap(i, j int) {
+ vs[i], vs[j] = vs[j], vs[i]
+}
+
+func (vs upgradeVersionSorter) Less(i, j int) bool {
+ l, r := vs[i], vs[j]
+
+ if tl, ispair := l.(versionPair); ispair {
+ l = tl.v
+ }
+ if tr, ispair := r.(versionPair); ispair {
+ r = tr.v
+ }
+
+ switch compareVersionType(l, r) {
+ case -1:
+ return true
+ case 1:
+ return false
+ case 0:
+ break
+ default:
+ panic("unreachable")
+ }
+
+ switch l.(type) {
+ // For these, now nothing to do but alpha sort
+ case Revision, branchVersion, plainVersion:
+ return l.String() < r.String()
+ }
+
+ // This ensures that pre-release versions are always sorted after ALL
+ // full-release versions
+ lsv, rsv := l.(semVersion).sv, r.(semVersion).sv
+ lpre, rpre := lsv.Prerelease() == "", rsv.Prerelease() == ""
+ if (lpre && !rpre) || (!lpre && rpre) {
+ return lpre
+ }
+ return lsv.GreaterThan(rsv)
+}
+
+func (vs downgradeVersionSorter) Less(i, j int) bool {
+ l, r := vs[i], vs[j]
+
+ if tl, ispair := l.(versionPair); ispair {
+ l = tl.v
+ }
+ if tr, ispair := r.(versionPair); ispair {
+ r = tr.v
+ }
+
+ switch compareVersionType(l, r) {
+ case -1:
+ return true
+ case 1:
+ return false
+ case 0:
+ break
+ default:
+ panic("unreachable")
+ }
+
+ switch l.(type) {
+ // For these, now nothing to do but alpha
+ case Revision, branchVersion, plainVersion:
+ return l.String() < r.String()
+ }
+
+ // This ensures that pre-release versions are always sorted after ALL
+ // full-release versions
+ lsv, rsv := l.(semVersion).sv, r.(semVersion).sv
+ lpre, rpre := lsv.Prerelease() == "", rsv.Prerelease() == ""
+ if (lpre && !rpre) || (!lpre && rpre) {
+ return lpre
+ }
+ return lsv.LessThan(rsv)
+}
diff --git a/vendor/github.com/sdboyer/gps/circle.yml b/vendor/github.com/sdboyer/gps/circle.yml
new file mode 100644
index 0000000..5723c35
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/circle.yml
@@ -0,0 +1,19 @@
+machine:
+ environment:
+ GO15VENDOREXPERIMENT: 1
+checkout:
+ post:
+dependencies:
+ override:
+ - mkdir -pv $HOME/.go_workspace/src/github.com/$CIRCLE_PROJECT_USERNAME
+ - ln -Tsf $HOME/$CIRCLE_PROJECT_REPONAME $HOME/.go_workspace/src/github.com/$CIRCLE_PROJECT_USERNAME/$CIRCLE_PROJECT_REPONAME
+ # Glide 0.10.1
+ - wget https://github.com/Masterminds/glide/releases/download/0.10.1/glide-0.10.1-linux-amd64.tar.gz
+ - tar -vxz -C $HOME/bin --strip=1 -f glide-0.10.1-linux-amd64.tar.gz
+ # Fetch deps with glide
+ - glide --home $HOME/.glide -y glide.yaml install --cache
+ cache_directories:
+ - "~/.glide"
+test:
+ override:
+ - cd $HOME/.go_workspace/src/github.com/$CIRCLE_PROJECT_USERNAME/$CIRCLE_PROJECT_REPONAME && go test
diff --git a/vendor/github.com/sdboyer/gps/constraint_test.go b/vendor/github.com/sdboyer/gps/constraint_test.go
new file mode 100644
index 0000000..3863e65
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/constraint_test.go
@@ -0,0 +1,817 @@
+package gps
+
+import (
+ "fmt"
+ "testing"
+)
+
+// gu - helper func for stringifying what we assume is a VersionPair (otherwise
+// will panic), but is given as a Constraint
+func gu(v Constraint) string {
+ return fmt.Sprintf("%q at rev %q", v, v.(PairedVersion).Underlying())
+}
+
+func TestBranchConstraintOps(t *testing.T) {
+ v1 := NewBranch("master").(branchVersion)
+ v2 := NewBranch("test").(branchVersion)
+
+ if !v1.MatchesAny(any) {
+ t.Errorf("Branches should always match the any constraint")
+ }
+ if v1.Intersect(any) != v1 {
+ t.Errorf("Branches should always return self when intersecting the any constraint, but got %s", v1.Intersect(any))
+ }
+
+ if v1.MatchesAny(none) {
+ t.Errorf("Branches should never match the none constraint")
+ }
+ if v1.Intersect(none) != none {
+ t.Errorf("Branches should always return none when intersecting the none constraint, but got %s", v1.Intersect(none))
+ }
+
+ if v1.Matches(v2) {
+ t.Errorf("%s should not match %s", v1, v2)
+ }
+
+ if v1.MatchesAny(v2) {
+ t.Errorf("%s should not allow any matches when combined with %s", v1, v2)
+ }
+
+ if v1.Intersect(v2) != none {
+ t.Errorf("Intersection of %s with %s should result in empty set", v1, v2)
+ }
+
+ // Add rev to one
+ snuffster := Revision("snuffleupagus")
+ v3 := v1.Is(snuffster).(versionPair)
+ if v2.Matches(v3) {
+ t.Errorf("%s should not match %s", v2, gu(v3))
+ }
+ if v3.Matches(v2) {
+ t.Errorf("%s should not match %s", gu(v3), v2)
+ }
+
+ if v2.MatchesAny(v3) {
+ t.Errorf("%s should not allow any matches when combined with %s", v2, gu(v3))
+ }
+ if v3.MatchesAny(v2) {
+ t.Errorf("%s should not allow any matches when combined with %s", v2, gu(v3))
+ }
+
+ if v2.Intersect(v3) != none {
+ t.Errorf("Intersection of %s with %s should result in empty set", v2, gu(v3))
+ }
+ if v3.Intersect(v2) != none {
+ t.Errorf("Intersection of %s with %s should result in empty set", gu(v3), v2)
+ }
+
+ // Add different rev to the other
+ v4 := v2.Is(Revision("cookie monster")).(versionPair)
+ if v4.Matches(v3) {
+ t.Errorf("%s should not match %s", gu(v4), gu(v3))
+ }
+ if v3.Matches(v4) {
+ t.Errorf("%s should not match %s", gu(v3), gu(v4))
+ }
+
+ if v4.MatchesAny(v3) {
+ t.Errorf("%s should not allow any matches when combined with %s", gu(v4), gu(v3))
+ }
+ if v3.MatchesAny(v4) {
+ t.Errorf("%s should not allow any matches when combined with %s", gu(v4), gu(v3))
+ }
+
+ if v4.Intersect(v3) != none {
+ t.Errorf("Intersection of %s with %s should result in empty set", gu(v4), gu(v3))
+ }
+ if v3.Intersect(v4) != none {
+ t.Errorf("Intersection of %s with %s should result in empty set", gu(v3), gu(v4))
+ }
+
+ // Now add same rev to different branches
+ // TODO(sdboyer) this might not actually be a good idea, when you consider the
+ // semantics of floating versions...matching on an underlying rev might be
+ // nice in the short term, but it's probably shit most of the time
+ v5 := v2.Is(Revision("snuffleupagus")).(versionPair)
+ if !v5.Matches(v3) {
+ t.Errorf("%s should match %s", gu(v5), gu(v3))
+ }
+ if !v3.Matches(v5) {
+ t.Errorf("%s should match %s", gu(v3), gu(v5))
+ }
+
+ if !v5.MatchesAny(v3) {
+ t.Errorf("%s should allow some matches when combined with %s", gu(v5), gu(v3))
+ }
+ if !v3.MatchesAny(v5) {
+ t.Errorf("%s should allow some matches when combined with %s", gu(v5), gu(v3))
+ }
+
+ if v5.Intersect(v3) != snuffster {
+ t.Errorf("Intersection of %s with %s should return underlying rev", gu(v5), gu(v3))
+ }
+ if v3.Intersect(v5) != snuffster {
+ t.Errorf("Intersection of %s with %s should return underlying rev", gu(v3), gu(v5))
+ }
+
+ // Set up for cross-type constraint ops
+ cookie := Revision("cookie monster")
+ o1 := NewVersion("master").(plainVersion)
+ o2 := NewVersion("1.0.0").(semVersion)
+ o3 := o1.Is(cookie).(versionPair)
+ o4 := o2.Is(cookie).(versionPair)
+ v6 := v1.Is(cookie).(versionPair)
+
+ if v1.Matches(o1) {
+ t.Errorf("%s (branch) should not match %s (version) across types", v1, o1)
+ }
+
+ if v1.MatchesAny(o1) {
+ t.Errorf("%s (branch) should not allow any matches when combined with %s (version)", v1, o1)
+ }
+
+ if v1.Intersect(o1) != none {
+ t.Errorf("Intersection of %s (branch) with %s (version) should result in empty set", v1, o1)
+ }
+
+ if v1.Matches(o2) {
+ t.Errorf("%s (branch) should not match %s (semver) across types", v1, o2)
+ }
+
+ if v1.MatchesAny(o2) {
+ t.Errorf("%s (branch) should not allow any matches when combined with %s (semver)", v1, o2)
+ }
+
+ if v1.Intersect(o2) != none {
+ t.Errorf("Intersection of %s (branch) with %s (semver) should result in empty set", v1, o2)
+ }
+
+ if v1.Matches(o3) {
+ t.Errorf("%s (branch) should not match %s (version) across types", v1, gu(o3))
+ }
+
+ if v1.MatchesAny(o3) {
+ t.Errorf("%s (branch) should not allow any matches when combined with %s (version)", v1, gu(o3))
+ }
+
+ if v1.Intersect(o3) != none {
+ t.Errorf("Intersection of %s (branch) with %s (version) should result in empty set", v1, gu(o3))
+ }
+
+ if v1.Matches(o4) {
+ t.Errorf("%s (branch) should not match %s (semver) across types", v1, gu(o4))
+ }
+
+ if v1.MatchesAny(o4) {
+ t.Errorf("%s (branch) should not allow any matches when combined with %s (semver)", v1, gu(o4))
+ }
+
+ if v1.Intersect(o4) != none {
+ t.Errorf("Intersection of %s (branch) with %s (semver) should result in empty set", v1, gu(o4))
+ }
+
+ if !v6.Matches(o3) {
+ t.Errorf("%s (branch) should match %s (version) across types due to shared rev", gu(v6), gu(o3))
+ }
+
+ if !v6.MatchesAny(o3) {
+ t.Errorf("%s (branch) should allow some matches when combined with %s (version) across types due to shared rev", gu(v6), gu(o3))
+ }
+
+ if v6.Intersect(o3) != cookie {
+ t.Errorf("Intersection of %s (branch) with %s (version) should return shared underlying rev", gu(v6), gu(o3))
+ }
+
+ if !v6.Matches(o4) {
+ t.Errorf("%s (branch) should match %s (version) across types due to shared rev", gu(v6), gu(o4))
+ }
+
+ if !v6.MatchesAny(o4) {
+ t.Errorf("%s (branch) should allow some matches when combined with %s (version) across types due to shared rev", gu(v6), gu(o4))
+ }
+
+ if v6.Intersect(o4) != cookie {
+ t.Errorf("Intersection of %s (branch) with %s (version) should return shared underlying rev", gu(v6), gu(o4))
+ }
+}
+
+func TestVersionConstraintOps(t *testing.T) {
+ v1 := NewVersion("ab123").(plainVersion)
+ v2 := NewVersion("b2a13").(plainVersion)
+
+ if !v1.MatchesAny(any) {
+ t.Errorf("Versions should always match the any constraint")
+ }
+ if v1.Intersect(any) != v1 {
+ t.Errorf("Versions should always return self when intersecting the any constraint, but got %s", v1.Intersect(any))
+ }
+
+ if v1.MatchesAny(none) {
+ t.Errorf("Versions should never match the none constraint")
+ }
+ if v1.Intersect(none) != none {
+ t.Errorf("Versions should always return none when intersecting the none constraint, but got %s", v1.Intersect(none))
+ }
+
+ if v1.Matches(v2) {
+ t.Errorf("%s should not match %s", v1, v2)
+ }
+
+ if v1.MatchesAny(v2) {
+ t.Errorf("%s should not allow any matches when combined with %s", v1, v2)
+ }
+
+ if v1.Intersect(v2) != none {
+ t.Errorf("Intersection of %s with %s should result in empty set", v1, v2)
+ }
+
+ // Add rev to one
+ snuffster := Revision("snuffleupagus")
+ v3 := v1.Is(snuffster).(versionPair)
+ if v2.Matches(v3) {
+ t.Errorf("%s should not match %s", v2, gu(v3))
+ }
+ if v3.Matches(v2) {
+ t.Errorf("%s should not match %s", gu(v3), v2)
+ }
+
+ if v2.MatchesAny(v3) {
+ t.Errorf("%s should not allow any matches when combined with %s", v2, gu(v3))
+ }
+ if v3.MatchesAny(v2) {
+ t.Errorf("%s should not allow any matches when combined with %s", v2, gu(v3))
+ }
+
+ if v2.Intersect(v3) != none {
+ t.Errorf("Intersection of %s with %s should result in empty set", v2, gu(v3))
+ }
+ if v3.Intersect(v2) != none {
+ t.Errorf("Intersection of %s with %s should result in empty set", gu(v3), v2)
+ }
+
+ // Add different rev to the other
+ v4 := v2.Is(Revision("cookie monster")).(versionPair)
+ if v4.Matches(v3) {
+ t.Errorf("%s should not match %s", gu(v4), gu(v3))
+ }
+ if v3.Matches(v4) {
+ t.Errorf("%s should not match %s", gu(v3), gu(v4))
+ }
+
+ if v4.MatchesAny(v3) {
+ t.Errorf("%s should not allow any matches when combined with %s", gu(v4), gu(v3))
+ }
+ if v3.MatchesAny(v4) {
+ t.Errorf("%s should not allow any matches when combined with %s", gu(v4), gu(v3))
+ }
+
+ if v4.Intersect(v3) != none {
+ t.Errorf("Intersection of %s with %s should result in empty set", gu(v4), gu(v3))
+ }
+ if v3.Intersect(v4) != none {
+ t.Errorf("Intersection of %s with %s should result in empty set", gu(v3), gu(v4))
+ }
+
+ // Now add same rev to different versions, and things should line up
+ v5 := v2.Is(Revision("snuffleupagus")).(versionPair)
+ if !v5.Matches(v3) {
+ t.Errorf("%s should match %s", gu(v5), gu(v3))
+ }
+ if !v3.Matches(v5) {
+ t.Errorf("%s should match %s", gu(v3), gu(v5))
+ }
+
+ if !v5.MatchesAny(v3) {
+ t.Errorf("%s should allow some matches when combined with %s", gu(v5), gu(v3))
+ }
+ if !v3.MatchesAny(v5) {
+ t.Errorf("%s should allow some matches when combined with %s", gu(v5), gu(v3))
+ }
+
+ if v5.Intersect(v3) != snuffster {
+ t.Errorf("Intersection of %s with %s should return underlying rev", gu(v5), gu(v3))
+ }
+ if v3.Intersect(v5) != snuffster {
+ t.Errorf("Intersection of %s with %s should return underlying rev", gu(v3), gu(v5))
+ }
+
+ // Set up for cross-type constraint ops
+ cookie := Revision("cookie monster")
+ o1 := NewBranch("master").(branchVersion)
+ o2 := NewVersion("1.0.0").(semVersion)
+ o3 := o1.Is(cookie).(versionPair)
+ o4 := o2.Is(cookie).(versionPair)
+ v6 := v1.Is(cookie).(versionPair)
+
+ if v1.Matches(o1) {
+ t.Errorf("%s (version) should not match %s (branch) across types", v1, o1)
+ }
+
+ if v1.MatchesAny(o1) {
+ t.Errorf("%s (version) should not allow any matches when combined with %s (branch)", v1, o1)
+ }
+
+ if v1.Intersect(o1) != none {
+ t.Errorf("Intersection of %s (version) with %s (branch) should result in empty set", v1, o1)
+ }
+
+ if v1.Matches(o2) {
+ t.Errorf("%s (version) should not match %s (semver) across types", v1, o2)
+ }
+
+ if v1.MatchesAny(o2) {
+ t.Errorf("%s (version) should not allow any matches when combined with %s (semver)", v1, o2)
+ }
+
+ if v1.Intersect(o2) != none {
+ t.Errorf("Intersection of %s (version) with %s (semver) should result in empty set", v1, o2)
+ }
+
+ if v1.Matches(o3) {
+ t.Errorf("%s (version) should not match %s (branch) across types", v1, gu(o3))
+ }
+
+ if v1.MatchesAny(o3) {
+ t.Errorf("%s (version) should not allow any matches when combined with %s (branch)", v1, gu(o3))
+ }
+
+ if v1.Intersect(o3) != none {
+ t.Errorf("Intersection of %s (version) with %s (branch) should result in empty set", v1, gu(o3))
+ }
+
+ if v1.Matches(o4) {
+ t.Errorf("%s (version) should not match %s (semver) across types", v1, gu(o4))
+ }
+
+ if v1.MatchesAny(o4) {
+ t.Errorf("%s (version) should not allow any matches when combined with %s (semver)", v1, gu(o4))
+ }
+
+ if v1.Intersect(o4) != none {
+ t.Errorf("Intersection of %s (version) with %s (semver) should result in empty set", v1, gu(o4))
+ }
+
+ if !v6.Matches(o3) {
+ t.Errorf("%s (version) should match %s (branch) across types due to shared rev", gu(v6), gu(o3))
+ }
+
+ if !v6.MatchesAny(o3) {
+ t.Errorf("%s (version) should allow some matches when combined with %s (branch) across types due to shared rev", gu(v6), gu(o3))
+ }
+
+ if v6.Intersect(o3) != cookie {
+ t.Errorf("Intersection of %s (version) with %s (branch) should return shared underlying rev", gu(v6), gu(o3))
+ }
+
+ if !v6.Matches(o4) {
+ t.Errorf("%s (version) should match %s (branch) across types due to shared rev", gu(v6), gu(o4))
+ }
+
+ if !v6.MatchesAny(o4) {
+ t.Errorf("%s (version) should allow some matches when combined with %s (branch) across types due to shared rev", gu(v6), gu(o4))
+ }
+
+ if v6.Intersect(o4) != cookie {
+ t.Errorf("Intersection of %s (version) with %s (branch) should return shared underlying rev", gu(v6), gu(o4))
+ }
+}
+
+func TestSemverVersionConstraintOps(t *testing.T) {
+ v1 := NewVersion("1.0.0").(semVersion)
+ v2 := NewVersion("2.0.0").(semVersion)
+
+ if !v1.MatchesAny(any) {
+ t.Errorf("Semvers should always match the any constraint")
+ }
+ if v1.Intersect(any) != v1 {
+ t.Errorf("Semvers should always return self when intersecting the any constraint, but got %s", v1.Intersect(any))
+ }
+
+ if v1.MatchesAny(none) {
+ t.Errorf("Semvers should never match the none constraint")
+ }
+ if v1.Intersect(none) != none {
+ t.Errorf("Semvers should always return none when intersecting the none constraint, but got %s", v1.Intersect(none))
+ }
+
+ if v1.Matches(v2) {
+ t.Errorf("%s should not match %s", v1, v2)
+ }
+
+ if v1.MatchesAny(v2) {
+ t.Errorf("%s should not allow any matches when combined with %s", v1, v2)
+ }
+
+ if v1.Intersect(v2) != none {
+ t.Errorf("Intersection of %s with %s should result in empty set", v1, v2)
+ }
+
+ // Add rev to one
+ snuffster := Revision("snuffleupagus")
+ v3 := v1.Is(snuffster).(versionPair)
+ if v2.Matches(v3) {
+ t.Errorf("%s should not match %s", v2, gu(v3))
+ }
+ if v3.Matches(v2) {
+ t.Errorf("%s should not match %s", gu(v3), v2)
+ }
+
+ if v2.MatchesAny(v3) {
+ t.Errorf("%s should not allow any matches when combined with %s", v2, gu(v3))
+ }
+ if v3.MatchesAny(v2) {
+ t.Errorf("%s should not allow any matches when combined with %s", v2, gu(v3))
+ }
+
+ if v2.Intersect(v3) != none {
+ t.Errorf("Intersection of %s with %s should result in empty set", v2, gu(v3))
+ }
+ if v3.Intersect(v2) != none {
+ t.Errorf("Intersection of %s with %s should result in empty set", gu(v3), v2)
+ }
+
+ // Add different rev to the other
+ v4 := v2.Is(Revision("cookie monster")).(versionPair)
+ if v4.Matches(v3) {
+ t.Errorf("%s should not match %s", gu(v4), gu(v3))
+ }
+ if v3.Matches(v4) {
+ t.Errorf("%s should not match %s", gu(v3), gu(v4))
+ }
+
+ if v4.MatchesAny(v3) {
+ t.Errorf("%s should not allow any matches when combined with %s", gu(v4), gu(v3))
+ }
+ if v3.MatchesAny(v4) {
+ t.Errorf("%s should not allow any matches when combined with %s", gu(v4), gu(v3))
+ }
+
+ if v4.Intersect(v3) != none {
+ t.Errorf("Intersection of %s with %s should result in empty set", gu(v4), gu(v3))
+ }
+ if v3.Intersect(v4) != none {
+ t.Errorf("Intersection of %s with %s should result in empty set", gu(v3), gu(v4))
+ }
+
+ // Now add same rev to different versions, and things should line up
+ v5 := v2.Is(Revision("snuffleupagus")).(versionPair)
+ if !v5.Matches(v3) {
+ t.Errorf("%s should match %s", gu(v5), gu(v3))
+ }
+ if !v3.Matches(v5) {
+ t.Errorf("%s should match %s", gu(v3), gu(v5))
+ }
+
+ if !v5.MatchesAny(v3) {
+ t.Errorf("%s should allow some matches when combined with %s", gu(v5), gu(v3))
+ }
+ if !v3.MatchesAny(v5) {
+ t.Errorf("%s should allow some matches when combined with %s", gu(v5), gu(v3))
+ }
+
+ if v5.Intersect(v3) != snuffster {
+ t.Errorf("Intersection of %s with %s should return underlying rev", gu(v5), gu(v3))
+ }
+ if v3.Intersect(v5) != snuffster {
+ t.Errorf("Intersection of %s with %s should return underlying rev", gu(v3), gu(v5))
+ }
+
+ // Set up for cross-type constraint ops
+ cookie := Revision("cookie monster")
+ o1 := NewBranch("master").(branchVersion)
+ o2 := NewVersion("ab123").(plainVersion)
+ o3 := o1.Is(cookie).(versionPair)
+ o4 := o2.Is(cookie).(versionPair)
+ v6 := v1.Is(cookie).(versionPair)
+
+ if v1.Matches(o1) {
+ t.Errorf("%s (semver) should not match %s (branch) across types", v1, o1)
+ }
+
+ if v1.MatchesAny(o1) {
+ t.Errorf("%s (semver) should not allow any matches when combined with %s (branch)", v1, o1)
+ }
+
+ if v1.Intersect(o1) != none {
+ t.Errorf("Intersection of %s (semver) with %s (branch) should result in empty set", v1, o1)
+ }
+
+ if v1.Matches(o2) {
+ t.Errorf("%s (semver) should not match %s (version) across types", v1, o2)
+ }
+
+ if v1.MatchesAny(o2) {
+ t.Errorf("%s (semver) should not allow any matches when combined with %s (version)", v1, o2)
+ }
+
+ if v1.Intersect(o2) != none {
+ t.Errorf("Intersection of %s (semver) with %s (version) should result in empty set", v1, o2)
+ }
+
+ if v1.Matches(o3) {
+ t.Errorf("%s (semver) should not match %s (branch) across types", v1, gu(o3))
+ }
+
+ if v1.MatchesAny(o3) {
+ t.Errorf("%s (semver) should not allow any matches when combined with %s (branch)", v1, gu(o3))
+ }
+
+ if v1.Intersect(o3) != none {
+ t.Errorf("Intersection of %s (semver) with %s (branch) should result in empty set", v1, gu(o3))
+ }
+
+ if v1.Matches(o4) {
+ t.Errorf("%s (semver) should not match %s (version) across types", v1, gu(o4))
+ }
+
+ if v1.MatchesAny(o4) {
+ t.Errorf("%s (semver) should not allow any matches when combined with %s (version)", v1, gu(o4))
+ }
+
+ if v1.Intersect(o4) != none {
+ t.Errorf("Intersection of %s (semver) with %s (version) should result in empty set", v1, gu(o4))
+ }
+
+ if !v6.Matches(o3) {
+ t.Errorf("%s (semver) should match %s (branch) across types due to shared rev", gu(v6), gu(o3))
+ }
+
+ if !v6.MatchesAny(o3) {
+ t.Errorf("%s (semver) should allow some matches when combined with %s (branch) across types due to shared rev", gu(v6), gu(o3))
+ }
+
+ if v6.Intersect(o3) != cookie {
+ t.Errorf("Intersection of %s (semver) with %s (branch) should return shared underlying rev", gu(v6), gu(o3))
+ }
+
+ if !v6.Matches(o4) {
+ t.Errorf("%s (semver) should match %s (branch) across types due to shared rev", gu(v6), gu(o4))
+ }
+
+ if !v6.MatchesAny(o4) {
+ t.Errorf("%s (semver) should allow some matches when combined with %s (branch) across types due to shared rev", gu(v6), gu(o4))
+ }
+
+ if v6.Intersect(o4) != cookie {
+ t.Errorf("Intersection of %s (semver) with %s (branch) should return shared underlying rev", gu(v6), gu(o4))
+ }
+
+ // Regression check - make sure that semVersion -> semverConstraint works
+ // the same as verified in the other test
+ c1, _ := NewSemverConstraint("=1.0.0")
+ if !v1.MatchesAny(c1) {
+ t.Errorf("%s (semver) should allow some matches - itself - when combined with an equivalent semverConstraint", gu(v1))
+ }
+ if v1.Intersect(c1) != v1 {
+ t.Errorf("Intersection of %s (semver) with equivalent semver constraint should return self, got %s", gu(v1), v1.Intersect(c1))
+ }
+
+ if !v6.MatchesAny(c1) {
+ t.Errorf("%s (semver pair) should allow some matches - itself - when combined with an equivalent semverConstraint", gu(v6))
+ }
+ if v6.Intersect(c1) != v6 {
+ t.Errorf("Intersection of %s (semver pair) with equivalent semver constraint should return self, got %s", gu(v6), v6.Intersect(c1))
+ }
+
+}
+
+// The other test is about the semverVersion, this is about semverConstraint
+func TestSemverConstraintOps(t *testing.T) {
+ v1 := NewBranch("master").(branchVersion)
+ v2 := NewVersion("ab123").(plainVersion)
+ v3 := NewVersion("1.0.0").(semVersion)
+
+ fozzie := Revision("fozzie bear")
+ v4 := v1.Is(fozzie).(versionPair)
+ v5 := v2.Is(fozzie).(versionPair)
+ v6 := v3.Is(fozzie).(versionPair)
+
+ // TODO(sdboyer) we can't use the same range as below b/c semver.rangeConstraint is
+ // still an incomparable type
+ c1, err := NewSemverConstraint("=1.0.0")
+ if err != nil {
+ t.Errorf("Failed to create constraint: %s", err)
+ t.FailNow()
+ }
+
+ if !c1.MatchesAny(any) {
+ t.Errorf("Semver constraints should always match the any constraint")
+ }
+ if c1.Intersect(any) != c1 {
+ t.Errorf("Semver constraints should always return self when intersecting the any constraint, but got %s", c1.Intersect(any))
+ }
+
+ if c1.MatchesAny(none) {
+ t.Errorf("Semver constraints should never match the none constraint")
+ }
+ if c1.Intersect(none) != none {
+ t.Errorf("Semver constraints should always return none when intersecting the none constraint, but got %s", c1.Intersect(none))
+ }
+
+ c1, err = NewSemverConstraint(">= 1.0.0")
+ if err != nil {
+ t.Errorf("Failed to create constraint: %s", err)
+ t.FailNow()
+ }
+
+ if c1.Matches(v1) {
+ t.Errorf("Semver constraint should not match simple branch")
+ }
+ if c1.Matches(v2) {
+ t.Errorf("Semver constraint should not match simple version")
+ }
+ if !c1.Matches(v3) {
+ t.Errorf("Semver constraint should match a simple semver version in its range")
+ }
+ if c1.Matches(v4) {
+ t.Errorf("Semver constraint should not match paired branch")
+ }
+ if c1.Matches(v5) {
+ t.Errorf("Semver constraint should not match paired version")
+ }
+ if !c1.Matches(v6) {
+ t.Errorf("Semver constraint should match a paired semver version in its range")
+ }
+
+ if c1.MatchesAny(v1) {
+ t.Errorf("Semver constraint should not allow any when intersected with simple branch")
+ }
+ if c1.MatchesAny(v2) {
+ t.Errorf("Semver constraint should not allow any when intersected with simple version")
+ }
+ if !c1.MatchesAny(v3) {
+ t.Errorf("Semver constraint should allow some when intersected with a simple semver version in its range")
+ }
+ if c1.MatchesAny(v4) {
+ t.Errorf("Semver constraint should not allow any when intersected with paired branch")
+ }
+ if c1.MatchesAny(v5) {
+ t.Errorf("Semver constraint should not allow any when intersected with paired version")
+ }
+ if !c1.MatchesAny(v6) {
+ t.Errorf("Semver constraint should allow some when intersected with a paired semver version in its range")
+ }
+
+ if c1.Intersect(v1) != none {
+ t.Errorf("Semver constraint should return none when intersected with a simple branch")
+ }
+ if c1.Intersect(v2) != none {
+ t.Errorf("Semver constraint should return none when intersected with a simple version")
+ }
+ if c1.Intersect(v3) != v3 {
+ t.Errorf("Semver constraint should return input when intersected with a simple semver version in its range")
+ }
+ if c1.Intersect(v4) != none {
+ t.Errorf("Semver constraint should return none when intersected with a paired branch")
+ }
+ if c1.Intersect(v5) != none {
+ t.Errorf("Semver constraint should return none when intersected with a paired version")
+ }
+ if c1.Intersect(v6) != v6 {
+ t.Errorf("Semver constraint should return input when intersected with a paired semver version in its range")
+ }
+}
+
+// Test that certain types of cross-version comparisons work when they are
+// expressed as a version union (but that others don't).
+func TestVersionUnion(t *testing.T) {
+ rev := Revision("flooboofoobooo")
+ v1 := NewBranch("master")
+ v2 := NewBranch("test")
+ v3 := NewVersion("1.0.0").Is(rev)
+ v4 := NewVersion("1.0.1")
+ v5 := NewVersion("v2.0.5").Is(Revision("notamatch"))
+
+ uv1 := versionTypeUnion{v1, v4, rev}
+
+ if uv1.MatchesAny(none) {
+ t.Errorf("Union can't match none")
+ }
+ if none.MatchesAny(uv1) {
+ t.Errorf("Union can't match none")
+ }
+
+ if !uv1.MatchesAny(any) {
+ t.Errorf("Union must match any")
+ }
+ if !any.MatchesAny(uv1) {
+ t.Errorf("Union must match any")
+ }
+
+ // Basic matching
+ if !uv1.Matches(v4) {
+ t.Errorf("Union should match on branch to branch")
+ }
+ if !v4.Matches(uv1) {
+ t.Errorf("Union should reverse-match on branch to branch")
+ }
+
+ if !uv1.Matches(v3) {
+ t.Errorf("Union should match on rev to paired rev")
+ }
+ if !v3.Matches(uv1) {
+ t.Errorf("Union should reverse-match on rev to paired rev")
+ }
+
+ if uv1.Matches(v2) {
+ t.Errorf("Union should not match on anything in disjoint unpaired")
+ }
+ if v2.Matches(uv1) {
+ t.Errorf("Union should not reverse-match on anything in disjoint unpaired")
+ }
+
+ if uv1.Matches(v5) {
+ t.Errorf("Union should not match on anything in disjoint pair")
+ }
+ if v5.Matches(uv1) {
+ t.Errorf("Union should not reverse-match on anything in disjoint pair")
+ }
+
+ // MatchesAny - repeat Matches for safety, but add more, too
+ if !uv1.MatchesAny(v4) {
+ t.Errorf("Union should match on branch to branch")
+ }
+ if !v4.MatchesAny(uv1) {
+ t.Errorf("Union should reverse-match on branch to branch")
+ }
+
+ if !uv1.MatchesAny(v3) {
+ t.Errorf("Union should match on rev to paired rev")
+ }
+ if !v3.MatchesAny(uv1) {
+ t.Errorf("Union should reverse-match on rev to paired rev")
+ }
+
+ if uv1.MatchesAny(v2) {
+ t.Errorf("Union should not match on anything in disjoint unpaired")
+ }
+ if v2.MatchesAny(uv1) {
+ t.Errorf("Union should not reverse-match on anything in disjoint unpaired")
+ }
+
+ if uv1.MatchesAny(v5) {
+ t.Errorf("Union should not match on anything in disjoint pair")
+ }
+ if v5.MatchesAny(uv1) {
+ t.Errorf("Union should not reverse-match on anything in disjoint pair")
+ }
+
+ c1, _ := NewSemverConstraint("~1.0.0")
+ c2, _ := NewSemverConstraint("~2.0.0")
+ if !uv1.MatchesAny(c1) {
+ t.Errorf("Union should have some overlap due to containing 1.0.1 version")
+ }
+ if !c1.MatchesAny(uv1) {
+ t.Errorf("Union should have some overlap due to containing 1.0.1 version")
+ }
+
+ if uv1.MatchesAny(c2) {
+ t.Errorf("Union should have no overlap with ~2.0.0 semver range")
+ }
+ if c2.MatchesAny(uv1) {
+ t.Errorf("Union should have no overlap with ~2.0.0 semver range")
+ }
+
+ // Intersect - repeat all previous
+ if uv1.Intersect(v4) != v4 {
+ t.Errorf("Union intersection on contained version should return that version")
+ }
+ if v4.Intersect(uv1) != v4 {
+ t.Errorf("Union reverse-intersection on contained version should return that version")
+ }
+
+ if uv1.Intersect(v3) != rev {
+ t.Errorf("Union intersection on paired version w/matching rev should return rev, got %s", uv1.Intersect(v3))
+ }
+ if v3.Intersect(uv1) != rev {
+ t.Errorf("Union reverse-intersection on paired version w/matching rev should return rev, got %s", v3.Intersect(uv1))
+ }
+
+ if uv1.Intersect(v2) != none {
+ t.Errorf("Union should not intersect with anything in disjoint unpaired")
+ }
+ if v2.Intersect(uv1) != none {
+ t.Errorf("Union should not reverse-intersect with anything in disjoint unpaired")
+ }
+
+ if uv1.Intersect(v5) != none {
+ t.Errorf("Union should not intersect with anything in disjoint pair")
+ }
+ if v5.Intersect(uv1) != none {
+ t.Errorf("Union should not reverse-intersect with anything in disjoint pair")
+ }
+
+ if uv1.Intersect(c1) != v4 {
+ t.Errorf("Union intersecting with semver range should return 1.0.1 version, got %s", uv1.Intersect(c1))
+ }
+ if c1.Intersect(uv1) != v4 {
+ t.Errorf("Union reverse-intersecting with semver range should return 1.0.1 version, got %s", c1.Intersect(uv1))
+ }
+
+ if uv1.Intersect(c2) != none {
+ t.Errorf("Union intersecting with non-overlapping semver range should return none, got %s", uv1.Intersect(c2))
+ }
+ if c2.Intersect(uv1) != none {
+ t.Errorf("Union reverse-intersecting with non-overlapping semver range should return none, got %s", uv1.Intersect(c2))
+ }
+}
diff --git a/vendor/github.com/sdboyer/gps/constraints.go b/vendor/github.com/sdboyer/gps/constraints.go
new file mode 100644
index 0000000..43b8b09
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/constraints.go
@@ -0,0 +1,166 @@
+package gps
+
+import (
+ "fmt"
+
+ "github.com/Masterminds/semver"
+)
+
+var (
+ none = noneConstraint{}
+ any = anyConstraint{}
+)
+
+// A Constraint provides structured limitations on the versions that are
+// admissible for a given project.
+//
+// As with Version, it has a private method because the gps's internal
+// implementation of the problem is complete, and the system relies on type
+// magic to operate.
+type Constraint interface {
+ fmt.Stringer
+ // Matches indicates if the provided Version is allowed by the Constraint.
+ Matches(Version) bool
+ // MatchesAny indicates if the intersection of the Constraint with the
+ // provided Constraint would yield a Constraint that could allow *any*
+ // Version.
+ MatchesAny(Constraint) bool
+ // Intersect computes the intersection of the Constraint with the provided
+ // Constraint.
+ Intersect(Constraint) Constraint
+ _private()
+}
+
+func (semverConstraint) _private() {}
+func (anyConstraint) _private() {}
+func (noneConstraint) _private() {}
+
+// NewSemverConstraint attempts to construct a semver Constraint object from the
+// input string.
+//
+// If the input string cannot be made into a valid semver Constraint, an error
+// is returned.
+func NewSemverConstraint(body string) (Constraint, error) {
+ c, err := semver.NewConstraint(body)
+ if err != nil {
+ return nil, err
+ }
+ return semverConstraint{c: c}, nil
+}
+
+type semverConstraint struct {
+ c semver.Constraint
+}
+
+func (c semverConstraint) String() string {
+ return c.c.String()
+}
+
+func (c semverConstraint) Matches(v Version) bool {
+ switch tv := v.(type) {
+ case versionTypeUnion:
+ for _, elem := range tv {
+ if c.Matches(elem) {
+ return true
+ }
+ }
+ case semVersion:
+ return c.c.Matches(tv.sv) == nil
+ case versionPair:
+ if tv2, ok := tv.v.(semVersion); ok {
+ return c.c.Matches(tv2.sv) == nil
+ }
+ }
+
+ return false
+}
+
+func (c semverConstraint) MatchesAny(c2 Constraint) bool {
+ return c.Intersect(c2) != none
+}
+
+func (c semverConstraint) Intersect(c2 Constraint) Constraint {
+ switch tc := c2.(type) {
+ case anyConstraint:
+ return c
+ case versionTypeUnion:
+ for _, elem := range tc {
+ if rc := c.Intersect(elem); rc != none {
+ return rc
+ }
+ }
+ case semverConstraint:
+ rc := c.c.Intersect(tc.c)
+ if !semver.IsNone(rc) {
+ return semverConstraint{c: rc}
+ }
+ case semVersion:
+ rc := c.c.Intersect(tc.sv)
+ if !semver.IsNone(rc) {
+ // If single version intersected with constraint, we know the result
+ // must be the single version, so just return it back out
+ return c2
+ }
+ case versionPair:
+ if tc2, ok := tc.v.(semVersion); ok {
+ rc := c.c.Intersect(tc2.sv)
+ if !semver.IsNone(rc) {
+ // same reasoning as previous case
+ return c2
+ }
+ }
+ }
+
+ return none
+}
+
+// IsAny indicates if the provided constraint is the wildcard "Any" constraint.
+func IsAny(c Constraint) bool {
+ _, ok := c.(anyConstraint)
+ return ok
+}
+
+// Any returns a constraint that will match anything.
+func Any() Constraint {
+ return anyConstraint{}
+}
+
+// anyConstraint is an unbounded constraint - it matches all other types of
+// constraints. It mirrors the behavior of the semver package's any type.
+type anyConstraint struct{}
+
+func (anyConstraint) String() string {
+ return "*"
+}
+
+func (anyConstraint) Matches(Version) bool {
+ return true
+}
+
+func (anyConstraint) MatchesAny(Constraint) bool {
+ return true
+}
+
+func (anyConstraint) Intersect(c Constraint) Constraint {
+ return c
+}
+
+// noneConstraint is the empty set - it matches no versions. It mirrors the
+// behavior of the semver package's none type.
+type noneConstraint struct{}
+
+func (noneConstraint) String() string {
+ return ""
+}
+
+func (noneConstraint) Matches(Version) bool {
+ return false
+}
+
+func (noneConstraint) MatchesAny(Constraint) bool {
+ return false
+}
+
+func (noneConstraint) Intersect(Constraint) Constraint {
+ return none
+}
diff --git a/vendor/github.com/sdboyer/gps/discovery.go b/vendor/github.com/sdboyer/gps/discovery.go
new file mode 100644
index 0000000..8da4a66
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/discovery.go
@@ -0,0 +1,83 @@
+// Copyright 2012 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package gps
+
+// This code is taken from cmd/go/discovery.go; it is the logic go get itself
+// uses to interpret meta imports information.
+
+import (
+ "encoding/xml"
+ "fmt"
+ "io"
+ "strings"
+)
+
+// charsetReader returns a reader for the given charset. Currently
+// it only supports UTF-8 and ASCII. Otherwise, it returns a meaningful
+// error which is printed by go get, so the user can find why the package
+// wasn't downloaded if the encoding is not supported. Note that, in
+// order to reduce potential errors, ASCII is treated as UTF-8 (i.e. characters
+// greater than 0x7f are not rejected).
+func charsetReader(charset string, input io.Reader) (io.Reader, error) {
+ switch strings.ToLower(charset) {
+ case "ascii":
+ return input, nil
+ default:
+ return nil, fmt.Errorf("can't decode XML document using charset %q", charset)
+ }
+}
+
+type metaImport struct {
+ Prefix, VCS, RepoRoot string
+}
+
+// parseMetaGoImports returns meta imports from the HTML in r.
+// Parsing ends at the end of the <head> section or the beginning of the <body>.
+func parseMetaGoImports(r io.Reader) (imports []metaImport, err error) {
+ d := xml.NewDecoder(r)
+ d.CharsetReader = charsetReader
+ d.Strict = false
+ var t xml.Token
+ for {
+ t, err = d.RawToken()
+ if err != nil {
+ if err == io.EOF || len(imports) > 0 {
+ err = nil
+ }
+ return
+ }
+ if e, ok := t.(xml.StartElement); ok && strings.EqualFold(e.Name.Local, "body") {
+ return
+ }
+ if e, ok := t.(xml.EndElement); ok && strings.EqualFold(e.Name.Local, "head") {
+ return
+ }
+ e, ok := t.(xml.StartElement)
+ if !ok || !strings.EqualFold(e.Name.Local, "meta") {
+ continue
+ }
+ if attrValue(e.Attr, "name") != "go-import" {
+ continue
+ }
+ if f := strings.Fields(attrValue(e.Attr, "content")); len(f) == 3 {
+ imports = append(imports, metaImport{
+ Prefix: f[0],
+ VCS: f[1],
+ RepoRoot: f[2],
+ })
+ }
+ }
+}
+
+// attrValue returns the attribute value for the case-insensitive key
+// `name', or the empty string if nothing is found.
+func attrValue(attrs []xml.Attr, name string) string {
+ for _, a := range attrs {
+ if strings.EqualFold(a.Name.Local, name) {
+ return a.Value
+ }
+ }
+ return ""
+}
diff --git a/vendor/github.com/sdboyer/gps/errors.go b/vendor/github.com/sdboyer/gps/errors.go
new file mode 100644
index 0000000..26c8413
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/errors.go
@@ -0,0 +1,405 @@
+package gps
+
+import (
+ "bytes"
+ "fmt"
+ "strings"
+)
+
+type errorLevel uint8
+
+// TODO(sdboyer) consistent, sensible way of handling 'type' and 'severity' - or figure
+// out that they're not orthogonal and collapse into just 'type'
+
+const (
+ warning errorLevel = 1 << iota
+ mustResolve
+ cannotResolve
+)
+
+type traceError interface {
+ traceString() string
+}
+
+type solveError struct {
+ lvl errorLevel
+ msg string
+}
+
+func newSolveError(msg string, lvl errorLevel) error {
+ return &solveError{msg: msg, lvl: lvl}
+}
+
+func (e *solveError) Error() string {
+ return e.msg
+}
+
+type noVersionError struct {
+ pn ProjectIdentifier
+ fails []failedVersion
+}
+
+func (e *noVersionError) Error() string {
+ if len(e.fails) == 0 {
+ return fmt.Sprintf("No versions found for project %q.", e.pn.ProjectRoot)
+ }
+
+ var buf bytes.Buffer
+ fmt.Fprintf(&buf, "No versions of %s met constraints:", e.pn.ProjectRoot)
+ for _, f := range e.fails {
+ fmt.Fprintf(&buf, "\n\t%s: %s", f.v, f.f.Error())
+ }
+
+ return buf.String()
+}
+
+func (e *noVersionError) traceString() string {
+ if len(e.fails) == 0 {
+ return fmt.Sprintf("No versions found")
+ }
+
+ var buf bytes.Buffer
+ fmt.Fprintf(&buf, "No versions of %s met constraints:", e.pn.ProjectRoot)
+ for _, f := range e.fails {
+ if te, ok := f.f.(traceError); ok {
+ fmt.Fprintf(&buf, "\n %s: %s", f.v, te.traceString())
+ } else {
+ fmt.Fprintf(&buf, "\n %s: %s", f.v, f.f.Error())
+ }
+ }
+
+ return buf.String()
+}
+
+type disjointConstraintFailure struct {
+ goal dependency
+ failsib []dependency
+ nofailsib []dependency
+ c Constraint
+}
+
+func (e *disjointConstraintFailure) Error() string {
+ if len(e.failsib) == 1 {
+ str := "Could not introduce %s at %s, as it has a dependency on %s with constraint %s, which has no overlap with existing constraint %s from %s at %s"
+ return fmt.Sprintf(str, e.goal.depender.id.errString(), e.goal.depender.v, e.goal.dep.Ident.errString(), e.goal.dep.Constraint.String(), e.failsib[0].dep.Constraint.String(), e.failsib[0].depender.id.errString(), e.failsib[0].depender.v)
+ }
+
+ var buf bytes.Buffer
+
+ var sibs []dependency
+ if len(e.failsib) > 1 {
+ sibs = e.failsib
+
+ str := "Could not introduce %s at %s, as it has a dependency on %s with constraint %s, which has no overlap with the following existing constraints:\n"
+ fmt.Fprintf(&buf, str, e.goal.depender.id.errString(), e.goal.depender.v, e.goal.dep.Ident.errString(), e.goal.dep.Constraint.String())
+ } else {
+ sibs = e.nofailsib
+
+ str := "Could not introduce %s at %s, as it has a dependency on %s with constraint %s, which does not overlap with the intersection of existing constraints from other currently selected packages:\n"
+ fmt.Fprintf(&buf, str, e.goal.depender.id.errString(), e.goal.depender.v, e.goal.dep.Ident.errString(), e.goal.dep.Constraint.String())
+ }
+
+ for _, c := range sibs {
+ fmt.Fprintf(&buf, "\t%s from %s at %s\n", c.dep.Constraint.String(), c.depender.id.errString(), c.depender.v)
+ }
+
+ return buf.String()
+}
+
+func (e *disjointConstraintFailure) traceString() string {
+ var buf bytes.Buffer
+ fmt.Fprintf(&buf, "constraint %s on %s disjoint with other dependers:\n", e.goal.dep.Constraint.String(), e.goal.dep.Ident.errString())
+ for _, f := range e.failsib {
+ fmt.Fprintf(&buf, "%s from %s at %s (no overlap)\n", f.dep.Constraint.String(), f.depender.id.ProjectRoot, f.depender.v)
+ }
+ for _, f := range e.nofailsib {
+ fmt.Fprintf(&buf, "%s from %s at %s (some overlap)\n", f.dep.Constraint.String(), f.depender.id.ProjectRoot, f.depender.v)
+ }
+
+ return buf.String()
+}
+
+// Indicates that an atom could not be introduced because one of its dep
+// constraints does not admit the currently-selected version of the target
+// project.
+type constraintNotAllowedFailure struct {
+ goal dependency
+ v Version
+}
+
+func (e *constraintNotAllowedFailure) Error() string {
+ str := "Could not introduce %s at %s, as it has a dependency on %s with constraint %s, which does not allow the currently selected version of %s"
+ return fmt.Sprintf(str, e.goal.depender.id.errString(), e.goal.depender.v, e.goal.dep.Ident.errString(), e.goal.dep.Constraint, e.v)
+}
+
+func (e *constraintNotAllowedFailure) traceString() string {
+ str := "%s at %s depends on %s with %s, but that's already selected at %s"
+ return fmt.Sprintf(str, e.goal.depender.id.ProjectRoot, e.goal.depender.v, e.goal.dep.Ident.ProjectRoot, e.goal.dep.Constraint, e.v)
+}
+
+type versionNotAllowedFailure struct {
+ goal atom
+ failparent []dependency
+ c Constraint
+}
+
+func (e *versionNotAllowedFailure) Error() string {
+ if len(e.failparent) == 1 {
+ str := "Could not introduce %s at %s, as it is not allowed by constraint %s from project %s."
+ return fmt.Sprintf(str, e.goal.id.errString(), e.goal.v, e.failparent[0].dep.Constraint.String(), e.failparent[0].depender.id.errString())
+ }
+
+ var buf bytes.Buffer
+
+ str := "Could not introduce %s at %s, as it is not allowed by constraints from the following projects:\n"
+ fmt.Fprintf(&buf, str, e.goal.id.errString(), e.goal.v)
+
+ for _, f := range e.failparent {
+ fmt.Fprintf(&buf, "\t%s from %s at %s\n", f.dep.Constraint.String(), f.depender.id.errString(), f.depender.v)
+ }
+
+ return buf.String()
+}
+
+func (e *versionNotAllowedFailure) traceString() string {
+ var buf bytes.Buffer
+
+ fmt.Fprintf(&buf, "%s at %s not allowed by constraint %s:\n", e.goal.id.ProjectRoot, e.goal.v, e.c.String())
+ for _, f := range e.failparent {
+ fmt.Fprintf(&buf, " %s from %s at %s\n", f.dep.Constraint.String(), f.depender.id.ProjectRoot, f.depender.v)
+ }
+
+ return buf.String()
+}
+
+type missingSourceFailure struct {
+ goal ProjectIdentifier
+ prob string
+}
+
+func (e *missingSourceFailure) Error() string {
+ return fmt.Sprintf(e.prob, e.goal)
+}
+
+type badOptsFailure string
+
+func (e badOptsFailure) Error() string {
+ return string(e)
+}
+
+type sourceMismatchFailure struct {
+ shared ProjectRoot
+ sel []dependency
+ current, mismatch string
+ prob atom
+}
+
+func (e *sourceMismatchFailure) Error() string {
+ var cur []string
+ for _, c := range e.sel {
+ cur = append(cur, string(c.depender.id.ProjectRoot))
+ }
+
+ str := "Could not introduce %s at %s, as it depends on %s from %s, but %s is already marked as coming from %s by %s"
+ return fmt.Sprintf(str, e.prob.id.errString(), e.prob.v, e.shared, e.mismatch, e.shared, e.current, strings.Join(cur, ", "))
+}
+
+func (e *sourceMismatchFailure) traceString() string {
+ var buf bytes.Buffer
+ fmt.Fprintf(&buf, "disagreement on network addr for %s:\n", e.shared)
+
+ fmt.Fprintf(&buf, " %s from %s\n", e.mismatch, e.prob.id.errString())
+ for _, dep := range e.sel {
+ fmt.Fprintf(&buf, " %s from %s\n", e.current, dep.depender.id.errString())
+ }
+
+ return buf.String()
+}
+
+type errDeppers struct {
+ err error
+ deppers []atom
+}
+type checkeeHasProblemPackagesFailure struct {
+ goal atom
+ failpkg map[string]errDeppers
+}
+
+func (e *checkeeHasProblemPackagesFailure) Error() string {
+ var buf bytes.Buffer
+ indent := ""
+
+ if len(e.failpkg) > 1 {
+ indent = "\t"
+ fmt.Fprintf(
+ &buf, "Could not introduce %s at %s due to multiple problematic subpackages:\n",
+ e.goal.id.errString(),
+ e.goal.v,
+ )
+ }
+
+ for pkg, errdep := range e.failpkg {
+ var cause string
+ if errdep.err == nil {
+ cause = "is missing"
+ } else {
+ cause = fmt.Sprintf("does not contain usable Go code (%T).", errdep.err)
+ }
+
+ if len(e.failpkg) == 1 {
+ fmt.Fprintf(
+ &buf, "Could not introduce %s at %s, as its subpackage %s %s.",
+ e.goal.id.errString(),
+ e.goal.v,
+ pkg,
+ cause,
+ )
+ } else {
+ fmt.Fprintf(&buf, "\tSubpackage %s %s.", pkg, cause)
+ }
+
+ if len(errdep.deppers) == 1 {
+ fmt.Fprintf(
+ &buf, " (Package is required by %s at %s.)",
+ errdep.deppers[0].id.errString(),
+ errdep.deppers[0].v,
+ )
+ } else {
+ fmt.Fprintf(&buf, " Package is required by:")
+ for _, pa := range errdep.deppers {
+ fmt.Fprintf(&buf, "\n%s\t%s at %s", indent, pa.id.errString(), pa.v)
+ }
+ }
+ }
+
+ return buf.String()
+}
+
+func (e *checkeeHasProblemPackagesFailure) traceString() string {
+ var buf bytes.Buffer
+
+ fmt.Fprintf(&buf, "%s at %s has problem subpkg(s):\n", e.goal.id.ProjectRoot, e.goal.v)
+ for pkg, errdep := range e.failpkg {
+ if errdep.err == nil {
+ fmt.Fprintf(&buf, "\t%s is missing; ", pkg)
+ } else {
+ fmt.Fprintf(&buf, "\t%s has err (%T); ", pkg, errdep.err)
+ }
+
+ if len(errdep.deppers) == 1 {
+ fmt.Fprintf(
+ &buf, "required by %s at %s.",
+ errdep.deppers[0].id.errString(),
+ errdep.deppers[0].v,
+ )
+ } else {
+ fmt.Fprintf(&buf, " required by:")
+ for _, pa := range errdep.deppers {
+ fmt.Fprintf(&buf, "\n\t\t%s at %s", pa.id.errString(), pa.v)
+ }
+ }
+ }
+
+ return buf.String()
+}
+
+type depHasProblemPackagesFailure struct {
+ goal dependency
+ v Version
+ pl []string
+ prob map[string]error
+}
+
+func (e *depHasProblemPackagesFailure) Error() string {
+ fcause := func(pkg string) string {
+ var cause string
+ if err, has := e.prob[pkg]; has {
+ cause = fmt.Sprintf("does not contain usable Go code (%T).", err)
+ } else {
+ cause = "is missing."
+ }
+ return cause
+ }
+
+ if len(e.pl) == 1 {
+ return fmt.Sprintf(
+ "Could not introduce %s at %s, as it requires package %s from %s, but in version %s that package %s",
+ e.goal.depender.id.errString(),
+ e.goal.depender.v,
+ e.pl[0],
+ e.goal.dep.Ident.errString(),
+ e.v,
+ fcause(e.pl[0]),
+ )
+ }
+
+ var buf bytes.Buffer
+ fmt.Fprintf(
+ &buf, "Could not introduce %s at %s, as it requires problematic packages from %s (current version %s):",
+ e.goal.depender.id.errString(),
+ e.goal.depender.v,
+ e.goal.dep.Ident.errString(),
+ e.v,
+ )
+
+ for _, pkg := range e.pl {
+ fmt.Fprintf(&buf, "\t%s %s", pkg, fcause(pkg))
+ }
+
+ return buf.String()
+}
+
+func (e *depHasProblemPackagesFailure) traceString() string {
+ var buf bytes.Buffer
+ fcause := func(pkg string) string {
+ var cause string
+ if err, has := e.prob[pkg]; has {
+ cause = fmt.Sprintf("has parsing err (%T).", err)
+ } else {
+ cause = "is missing"
+ }
+ return cause
+ }
+
+ fmt.Fprintf(
+ &buf, "%s at %s depping on %s at %s has problem subpkg(s):",
+ e.goal.depender.id.errString(),
+ e.goal.depender.v,
+ e.goal.dep.Ident.errString(),
+ e.v,
+ )
+
+ for _, pkg := range e.pl {
+ fmt.Fprintf(&buf, "\t%s %s", pkg, fcause(pkg))
+ }
+
+ return buf.String()
+}
+
+// nonexistentRevisionFailure indicates that a revision constraint was specified
+// for a given project, but that that revision does not exist in the source
+// repository.
+type nonexistentRevisionFailure struct {
+ goal dependency
+ r Revision
+}
+
+func (e *nonexistentRevisionFailure) Error() string {
+ return fmt.Sprintf(
+ "Could not introduce %s at %s, as it requires %s at revision %s, but that revision does not exist",
+ e.goal.depender.id.errString(),
+ e.goal.depender.v,
+ e.goal.dep.Ident.errString(),
+ e.r,
+ )
+}
+
+func (e *nonexistentRevisionFailure) traceString() string {
+ return fmt.Sprintf(
+ "%s at %s wants missing rev %s of %s",
+ e.goal.depender.id.errString(),
+ e.goal.depender.v,
+ e.r,
+ e.goal.dep.Ident.errString(),
+ )
+}
diff --git a/vendor/github.com/sdboyer/gps/example.go b/vendor/github.com/sdboyer/gps/example.go
new file mode 100644
index 0000000..1a5a31a
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/example.go
@@ -0,0 +1,58 @@
+// +build ignore
+
+package main
+
+import (
+ "go/build"
+ "log"
+ "os"
+ "path/filepath"
+ "strings"
+
+ gps "github.com/sdboyer/gps"
+)
+
+// This is probably the simplest possible implementation of gps. It does the
+// substantive work that `go get` does, except:
+// 1. It drops the resulting tree into vendor instead of GOPATH
+// 2. It prefers semver tags (if available) over branches
+// 3. It removes any vendor directories nested within dependencies
+//
+// This will compile and work...and then blow away the vendor directory present
+// in the cwd, if any. Be careful!
+func main() {
+ // Operate on the current directory
+ root, _ := os.Getwd()
+ // Assume the current directory is correctly placed on a GOPATH, and derive
+ // the ProjectRoot from it
+ srcprefix := filepath.Join(build.Default.GOPATH, "src") + string(filepath.Separator)
+ importroot := filepath.ToSlash(strings.TrimPrefix(root, srcprefix))
+
+ // Set up params, including tracing
+ params := gps.SolveParameters{
+ RootDir: root,
+ ImportRoot: gps.ProjectRoot(importroot),
+ Trace: true,
+ TraceLogger: log.New(os.Stdout, "", 0),
+ }
+
+ // Set up a SourceManager with the NaiveAnalyzer
+ sourcemgr, _ := gps.NewSourceManager(NaiveAnalyzer{}, ".repocache", false)
+ defer sourcemgr.Release()
+
+ // Prep and run the solver
+ solver, _ := gps.Prepare(params, sourcemgr)
+ solution, err := solver.Solve()
+ if err == nil {
+ // If no failure, blow away the vendor dir and write a new one out,
+ // stripping nested vendor directories as we go.
+ os.RemoveAll(filepath.Join(root, "vendor"))
+ gps.CreateVendorTree(filepath.Join(root, "vendor"), solution, sourcemgr, true)
+ }
+}
+
+type NaiveAnalyzer struct{}
+
+func (a NaiveAnalyzer) GetInfo(path string, n gps.ProjectRoot) (gps.Manifest, gps.Lock, error) {
+ return nil, nil, nil
+}
diff --git a/vendor/github.com/sdboyer/gps/flags.go b/vendor/github.com/sdboyer/gps/flags.go
new file mode 100644
index 0000000..a7172c1
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/flags.go
@@ -0,0 +1,37 @@
+package gps
+
+// projectExistence values represent the extent to which a project "exists."
+type projectExistence uint8
+
+const (
+ // ExistsInVendorRoot indicates that a project exists in a vendor directory
+ // at the predictable location based on import path. It does NOT imply, much
+ // less guarantee, any of the following:
+ // - That the code at the expected location under vendor is at the version
+ // given in a lock file
+ // - That the code at the expected location under vendor is from the
+ // expected upstream project at all
+ // - That, if this flag is not present, the project does not exist at some
+ // unexpected/nested location under vendor
+ // - That the full repository history is available. In fact, the
+ // assumption should be that if only this flag is on, the full repository
+ // history is likely not available (locally)
+ //
+ // In short, the information encoded in this flag should not be construed as
+ // exhaustive.
+ existsInVendorRoot projectExistence = 1 << iota
+
+ // ExistsInCache indicates that a project exists on-disk in the local cache.
+ // It does not guarantee that an upstream exists, thus it cannot imply
+ // that the cache is at all correct - up-to-date, or even of the expected
+ // upstream project repository.
+ //
+ // Additionally, this refers only to the existence of the local repository
+ // itself; it says nothing about the existence or completeness of the
+ // separate metadata cache.
+ existsInCache
+
+ // ExistsUpstream indicates that a project repository was locatable at the
+ // path provided by a project's URI (a base import path).
+ existsUpstream
+)
diff --git a/vendor/github.com/sdboyer/gps/glide.lock b/vendor/github.com/sdboyer/gps/glide.lock
new file mode 100644
index 0000000..ea36f4b
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/glide.lock
@@ -0,0 +1,19 @@
+hash: 2252a285ab27944a4d7adcba8dbd03980f59ba652f12db39fa93b927c345593e
+updated: 2016-06-06T22:10:37.696580463-04:00
+imports:
+- name: github.com/armon/go-radix
+ version: 4239b77079c7b5d1243b7b4736304ce8ddb6f0f2
+- name: github.com/hashicorp/go-immutable-radix
+ version: 8e8ed81f8f0bf1bdd829593fdd5c29922c1ea990
+- name: github.com/hashicorp/golang-lru
+ version: a0d98a5f288019575c6d1f4bb1573fef2d1fcdc4
+- name: github.com/Masterminds/semver
+ version: 0a2c9fc0eee2c4cbb9526877c4a54da047fdcadd
+ vcs: git
+- name: github.com/Masterminds/vcs
+ version: 7a21de0acff824ccf45f633cc844a19625149c2f
+ vcs: git
+- name: github.com/termie/go-shutil
+ version: bcacb06fecaeec8dc42af03c87c6949f4a05c74c
+ vcs: git
+devImports: []
diff --git a/vendor/github.com/sdboyer/gps/glide.yaml b/vendor/github.com/sdboyer/gps/glide.yaml
new file mode 100644
index 0000000..690f9e1
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/glide.yaml
@@ -0,0 +1,14 @@
+package: github.com/sdboyer/gps
+owners:
+- name: Sam Boyer
+ email: tech@samboyer.org
+import:
+- package: github.com/Masterminds/semver
+ branch: 2.x
+ vcs: git
+- package: github.com/Masterminds/vcs
+ vcs: git
+- package: github.com/termie/go-shutil
+ version: bcacb06fecaeec8dc42af03c87c6949f4a05c74c
+ vcs: git
+- package: github.com/armon/go-radix
diff --git a/vendor/github.com/sdboyer/gps/hash.go b/vendor/github.com/sdboyer/gps/hash.go
new file mode 100644
index 0000000..9e27bcd
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/hash.go
@@ -0,0 +1,104 @@
+package gps
+
+import (
+ "crypto/sha256"
+ "fmt"
+ "sort"
+)
+
+// HashInputs computes a hash digest of all data in a SolveOpts that are as
+// function inputs to Solve().
+//
+// The digest returned from this function is the same as the digest that would
+// be included with a Solve() Result. As such, it's appropriate for comparison
+// against the digest stored in a lock file, generated by a previous Solve(): if
+// the digests match, then manifest and lock are in sync, and a Solve() is
+// unnecessary.
+//
+// (Basically, this is for memoization.)
+func (s *solver) HashInputs() ([]byte, error) {
+ // 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)
+ if err != nil {
+ return nil, badOptsFailure(fmt.Sprintf("Error while parsing packages under %s: %s", s.params.RootDir, err.Error()))
+ }
+
+ d, dd := s.params.Manifest.DependencyConstraints(), s.params.Manifest.TestDependencyConstraints()
+ p := make(sortedDeps, len(d))
+ copy(p, d)
+ p = append(p, dd...)
+
+ sort.Stable(p)
+
+ // We have everything we need; now, compute the hash.
+ h := sha256.New()
+ for _, pd := range p {
+ h.Write([]byte(pd.Ident.ProjectRoot))
+ h.Write([]byte(pd.Ident.NetworkName))
+ // FIXME Constraint.String() is a surjective-only transformation - tags
+ // and branches with the same name are written out as the same string.
+ // This could, albeit rarely, result in input collisions when a real
+ // change has occurred.
+ h.Write([]byte(pd.Constraint.String()))
+ }
+
+ // The stdlib and old appengine packages play the same functional role in
+ // solving as ignores. Because they change, albeit quite infrequently, we
+ // have to include them in the hash.
+ h.Write([]byte(stdlibPkgs))
+ h.Write([]byte(appenginePkgs))
+
+ // Write each of the packages, or the errors that were found for a
+ // particular subpath, into the hash.
+ for _, perr := range ptree.Packages {
+ if perr.Err != nil {
+ h.Write([]byte(perr.Err.Error()))
+ } else {
+ h.Write([]byte(perr.P.Name))
+ h.Write([]byte(perr.P.CommentPath))
+ h.Write([]byte(perr.P.ImportPath))
+ for _, imp := range perr.P.Imports {
+ h.Write([]byte(imp))
+ }
+ for _, imp := range perr.P.TestImports {
+ h.Write([]byte(imp))
+ }
+ }
+ }
+
+ // Add the package ignores, if any.
+ if len(s.ig) > 0 {
+ // Dump and sort the ignores
+ ig := make([]string, len(s.ig))
+ k := 0
+ for pkg := range s.ig {
+ ig[k] = pkg
+ k++
+ }
+ sort.Strings(ig)
+
+ for _, igp := range ig {
+ h.Write([]byte(igp))
+ }
+ }
+
+ // TODO(sdboyer) overrides
+ // TODO(sdboyer) aliases
+ return h.Sum(nil), nil
+}
+
+type sortedDeps []ProjectConstraint
+
+func (s sortedDeps) Len() int {
+ return len(s)
+}
+
+func (s sortedDeps) Swap(i, j int) {
+ s[i], s[j] = s[j], s[i]
+}
+
+func (s sortedDeps) Less(i, j int) bool {
+ return s[i].Ident.less(s[j].Ident)
+}
diff --git a/vendor/github.com/sdboyer/gps/hash_test.go b/vendor/github.com/sdboyer/gps/hash_test.go
new file mode 100644
index 0000000..dc27ddf
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/hash_test.go
@@ -0,0 +1,35 @@
+package gps
+
+import (
+ "bytes"
+ "crypto/sha256"
+ "testing"
+)
+
+func TestHashInputs(t *testing.T) {
+ fix := basicFixtures["shared dependency with overlapping constraints"]
+
+ params := SolveParameters{
+ RootDir: string(fix.ds[0].n),
+ ImportRoot: fix.ds[0].n,
+ Manifest: fix.ds[0],
+ Ignore: []string{"foo", "bar"},
+ }
+
+ s, err := Prepare(params, newdepspecSM(fix.ds, nil))
+
+ dig, err := s.HashInputs()
+ if err != nil {
+ t.Fatalf("HashInputs returned unexpected err: %s", err)
+ }
+
+ h := sha256.New()
+ for _, v := range []string{"a", "a", "1.0.0", "b", "b", "1.0.0", stdlibPkgs, appenginePkgs, "root", "", "root", "a", "b", "bar", "foo"} {
+ h.Write([]byte(v))
+ }
+ correct := h.Sum(nil)
+
+ if !bytes.Equal(dig, correct) {
+ t.Errorf("Hashes are not equal")
+ }
+}
diff --git a/vendor/github.com/sdboyer/gps/import_mode_go15.go b/vendor/github.com/sdboyer/gps/import_mode_go15.go
new file mode 100644
index 0000000..5ef11c2
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/import_mode_go15.go
@@ -0,0 +1,13 @@
+// +build !go1.6
+
+package gps
+
+import "go/build"
+
+// analysisImportMode returns the import mode used for build.Import() calls for
+// standard package analysis.
+//
+// build.NoVendor was added in go1.6, so we have to omit it here.
+func analysisImportMode() build.ImportMode {
+ return build.ImportComment
+}
diff --git a/vendor/github.com/sdboyer/gps/import_mode_go16.go b/vendor/github.com/sdboyer/gps/import_mode_go16.go
new file mode 100644
index 0000000..edb534a
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/import_mode_go16.go
@@ -0,0 +1,11 @@
+// +build go1.6
+
+package gps
+
+import "go/build"
+
+// analysisImportMode returns the import mode used for build.Import() calls for
+// standard package analysis.
+func analysisImportMode() build.ImportMode {
+ return build.ImportComment | build.IgnoreVendor
+}
diff --git a/vendor/github.com/sdboyer/gps/lock.go b/vendor/github.com/sdboyer/gps/lock.go
new file mode 100644
index 0000000..1d4db56
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/lock.go
@@ -0,0 +1,161 @@
+package gps
+
+// Lock represents data from a lock file (or however the implementing tool
+// chooses to store it) at a particular version that is relevant to the
+// satisfiability solving process.
+//
+// In general, the information produced by gps on finding a successful
+// solution is all that would be necessary to constitute a lock file, though
+// tools can include whatever other information they want in their storage.
+type Lock interface {
+ // Indicates the version of the solver used to generate this lock data
+ //SolverVersion() string
+
+ // The hash of inputs to gps that resulted in this lock data
+ InputHash() []byte
+
+ // Projects returns the list of LockedProjects contained in the lock data.
+ Projects() []LockedProject
+}
+
+// LockedProject is a single project entry from a lock file. It expresses the
+// project's name, one or both of version and underlying revision, the network
+// URI for accessing it, the path at which it should be placed within a vendor
+// directory, and the packages that are used in it.
+type LockedProject struct {
+ pi ProjectIdentifier
+ v UnpairedVersion
+ r Revision
+ pkgs []string
+}
+
+// SimpleLock is a helper for tools to easily describe lock data when they know
+// that no hash, or other complex information, is available.
+type SimpleLock []LockedProject
+
+var _ Lock = SimpleLock{}
+
+// InputHash always returns an empty string for SimpleLock. This makes it useless
+// as a stable lock to be written to disk, but still useful for some ephemeral
+// purposes.
+func (SimpleLock) InputHash() []byte {
+ return nil
+}
+
+// Projects returns the entire contents of the SimpleLock.
+func (l SimpleLock) Projects() []LockedProject {
+ return l
+}
+
+// NewLockedProject creates a new LockedProject struct with a given name,
+// version, and upstream repository URL.
+//
+// Note that passing a nil version will cause a panic. This is a correctness
+// measure to ensure that the solver is never exposed to a version-less lock
+// entry. Such a case would be meaningless - the solver would have no choice but
+// to simply dismiss that project. By creating a hard failure case via panic
+// instead, we are trying to avoid inflicting the resulting pain on the user by
+// instead forcing a decision on the Analyzer implementation.
+func NewLockedProject(n ProjectRoot, v Version, url string, pkgs []string) LockedProject {
+ if v == nil {
+ panic("must provide a non-nil version to create a LockedProject")
+ }
+
+ lp := LockedProject{
+ pi: ProjectIdentifier{
+ ProjectRoot: n,
+ NetworkName: url,
+ },
+ pkgs: pkgs,
+ }
+
+ switch tv := v.(type) {
+ case Revision:
+ lp.r = tv
+ case branchVersion:
+ lp.v = tv
+ case semVersion:
+ lp.v = tv
+ case plainVersion:
+ lp.v = tv
+ case versionPair:
+ lp.r = tv.r
+ lp.v = tv.v
+ }
+
+ return lp
+}
+
+// Ident returns the identifier describing the project. This includes both the
+// local name (the root name by which the project is referenced in import paths)
+// and the network name, where the upstream source lives.
+func (lp LockedProject) Ident() ProjectIdentifier {
+ return lp.pi
+}
+
+// Version assembles together whatever version and/or revision data is
+// available into a single Version.
+func (lp LockedProject) Version() Version {
+ if lp.r == "" {
+ return lp.v
+ }
+
+ if lp.v == nil {
+ return lp.r
+ }
+
+ return lp.v.Is(lp.r)
+}
+
+func (lp LockedProject) toAtom() atom {
+ pa := atom{
+ id: lp.Ident(),
+ }
+
+ if lp.v == nil {
+ pa.v = lp.r
+ } else if lp.r != "" {
+ pa.v = lp.v.Is(lp.r)
+ } else {
+ pa.v = lp.v
+ }
+
+ return pa
+}
+
+type safeLock struct {
+ h []byte
+ p []LockedProject
+}
+
+func (sl safeLock) InputHash() []byte {
+ return sl.h
+}
+
+func (sl safeLock) Projects() []LockedProject {
+ return sl.p
+}
+
+// prepLock ensures a lock is prepared and safe for use by the solver.
+// This entails two things:
+//
+// * Ensuring that all LockedProject's identifiers are normalized.
+// * Defensively ensuring that no outside routine can modify the lock while the
+// solver is in-flight.
+//
+// This is achieved by copying the lock's data into a new safeLock.
+func prepLock(l Lock) Lock {
+ pl := l.Projects()
+
+ rl := safeLock{
+ h: l.InputHash(),
+ p: make([]LockedProject, len(pl)),
+ }
+
+ for k, lp := range pl {
+ lp.pi = lp.pi.normalize()
+ rl.p[k] = lp
+ }
+
+ return rl
+}
diff --git a/vendor/github.com/sdboyer/gps/manager_test.go b/vendor/github.com/sdboyer/gps/manager_test.go
new file mode 100644
index 0000000..ebc8091
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/manager_test.go
@@ -0,0 +1,342 @@
+package gps
+
+import (
+ "fmt"
+ "io/ioutil"
+ "os"
+ "path"
+ "runtime"
+ "sort"
+ "testing"
+
+ "github.com/Masterminds/semver"
+)
+
+var bd string
+
+// An analyzer that passes nothing back, but doesn't error. This is the naive
+// case - no constraints, no lock, and no errors. The SourceMgr will interpret
+// this as open/Any constraints on everything in the import graph.
+type naiveAnalyzer struct{}
+
+func (naiveAnalyzer) GetInfo(string, ProjectRoot) (Manifest, Lock, error) {
+ return nil, nil, nil
+}
+
+func sv(s string) *semver.Version {
+ sv, err := semver.NewVersion(s)
+ if err != nil {
+ panic(fmt.Sprintf("Error creating semver from %q: %s", s, err))
+ }
+
+ return sv
+}
+
+func init() {
+ _, filename, _, _ := runtime.Caller(1)
+ bd = path.Dir(filename)
+}
+
+func TestSourceManagerInit(t *testing.T) {
+ cpath, err := ioutil.TempDir("", "smcache")
+ if err != nil {
+ t.Errorf("Failed to create temp dir: %s", err)
+ }
+ _, err = NewSourceManager(naiveAnalyzer{}, cpath, false)
+
+ if err != nil {
+ t.Errorf("Unexpected error on SourceManager creation: %s", err)
+ }
+ defer func() {
+ err := removeAll(cpath)
+ if err != nil {
+ t.Errorf("removeAll failed: %s", err)
+ }
+ }()
+
+ _, err = NewSourceManager(naiveAnalyzer{}, cpath, false)
+ if err == nil {
+ t.Errorf("Creating second SourceManager should have failed due to file lock contention")
+ }
+
+ sm, err := NewSourceManager(naiveAnalyzer{}, cpath, true)
+ defer sm.Release()
+ if err != nil {
+ t.Errorf("Creating second SourceManager should have succeeded when force flag was passed, but failed with err %s", err)
+ }
+
+ if _, err = os.Stat(path.Join(cpath, "sm.lock")); err != nil {
+ t.Errorf("Global cache lock file not created correctly")
+ }
+}
+
+func TestProjectManagerInit(t *testing.T) {
+ // This test is a bit slow, skip it on -short
+ if testing.Short() {
+ t.Skip("Skipping project manager init test in short mode")
+ }
+
+ cpath, err := ioutil.TempDir("", "smcache")
+ if err != nil {
+ t.Errorf("Failed to create temp dir: %s", err)
+ }
+ sm, err := NewSourceManager(naiveAnalyzer{}, cpath, false)
+
+ if err != nil {
+ t.Errorf("Unexpected error on SourceManager creation: %s", err)
+ t.FailNow()
+ }
+ defer func() {
+ err := removeAll(cpath)
+ if err != nil {
+ t.Errorf("removeAll failed: %s", err)
+ }
+ }()
+ defer sm.Release()
+
+ pn := ProjectRoot("github.com/Masterminds/VCSTestRepo")
+ v, err := sm.ListVersions(pn)
+ if err != nil {
+ t.Errorf("Unexpected error during initial project setup/fetching %s", err)
+ }
+
+ if len(v) != 3 {
+ t.Errorf("Expected three version results from the test repo, got %v", len(v))
+ } else {
+ rev := Revision("30605f6ac35fcb075ad0bfa9296f90a7d891523e")
+ expected := []Version{
+ NewVersion("1.0.0").Is(rev),
+ NewBranch("master").Is(rev),
+ NewBranch("test").Is(rev),
+ }
+
+ // SourceManager itself doesn't guarantee ordering; sort them here so we
+ // can dependably check output
+ sort.Sort(upgradeVersionSorter(v))
+
+ for k, e := range expected {
+ if v[k] != e {
+ t.Errorf("Expected version %s in position %v but got %s", e, k, v[k])
+ }
+ }
+ }
+
+ // Two birds, one stone - make sure the internal ProjectManager vlist cache
+ // works by asking for the versions again, and do it through smcache to
+ // ensure its sorting works, as well.
+ smc := &bridge{
+ sm: sm,
+ vlists: make(map[ProjectRoot][]Version),
+ s: &solver{},
+ }
+
+ v, err = smc.listVersions(ProjectIdentifier{ProjectRoot: pn})
+ if err != nil {
+ t.Errorf("Unexpected error during initial project setup/fetching %s", err)
+ }
+
+ if len(v) != 3 {
+ t.Errorf("Expected three version results from the test repo, got %v", len(v))
+ } else {
+ rev := Revision("30605f6ac35fcb075ad0bfa9296f90a7d891523e")
+ expected := []Version{
+ NewVersion("1.0.0").Is(rev),
+ NewBranch("master").Is(rev),
+ NewBranch("test").Is(rev),
+ }
+
+ for k, e := range expected {
+ if v[k] != e {
+ t.Errorf("Expected version %s in position %v but got %s", e, k, v[k])
+ }
+ }
+ }
+
+ // Ensure that the appropriate cache dirs and files exist
+ _, err = os.Stat(path.Join(cpath, "src", "github.com", "Masterminds", "VCSTestRepo", ".git"))
+ if err != nil {
+ t.Error("Cache repo does not exist in expected location")
+ }
+
+ _, err = os.Stat(path.Join(cpath, "metadata", "github.com", "Masterminds", "VCSTestRepo", "cache.json"))
+ if err != nil {
+ // TODO(sdboyer) temporarily disabled until we turn caching back on
+ //t.Error("Metadata cache json file does not exist in expected location")
+ }
+
+ // Ensure project existence values are what we expect
+ var exists bool
+ exists, err = sm.RepoExists(pn)
+ if err != nil {
+ t.Errorf("Error on checking RepoExists: %s", err)
+ }
+ if !exists {
+ t.Error("Repo should exist after non-erroring call to ListVersions")
+ }
+
+ // Now reach inside the black box
+ pms, err := sm.getProjectManager(pn)
+ if err != nil {
+ t.Errorf("Error on grabbing project manager obj: %s", err)
+ }
+
+ // Check upstream existence flag
+ if !pms.pm.CheckExistence(existsUpstream) {
+ t.Errorf("ExistsUpstream flag not being correctly set the project")
+ }
+}
+
+func TestRepoVersionFetching(t *testing.T) {
+ // This test is quite slow, skip it on -short
+ if testing.Short() {
+ t.Skip("Skipping repo version fetching test in short mode")
+ }
+
+ cpath, err := ioutil.TempDir("", "smcache")
+ if err != nil {
+ t.Errorf("Failed to create temp dir: %s", err)
+ }
+
+ sm, err := NewSourceManager(naiveAnalyzer{}, cpath, false)
+ if err != nil {
+ t.Errorf("Unexpected error on SourceManager creation: %s", err)
+ t.FailNow()
+ }
+
+ upstreams := []ProjectRoot{
+ "github.com/Masterminds/VCSTestRepo",
+ "bitbucket.org/mattfarina/testhgrepo",
+ "launchpad.net/govcstestbzrrepo",
+ }
+
+ pms := make([]*projectManager, len(upstreams))
+ for k, u := range upstreams {
+ pmi, err := sm.getProjectManager(u)
+ if err != nil {
+ sm.Release()
+ removeAll(cpath)
+ t.Errorf("Unexpected error on ProjectManager creation: %s", err)
+ t.FailNow()
+ }
+ pms[k] = pmi.pm
+ }
+
+ defer func() {
+ err := removeAll(cpath)
+ if err != nil {
+ t.Errorf("removeAll failed: %s", err)
+ }
+ }()
+ defer sm.Release()
+
+ // test git first
+ vlist, exbits, err := pms[0].crepo.getCurrentVersionPairs()
+ if err != nil {
+ t.Errorf("Unexpected error getting version pairs from git repo: %s", err)
+ }
+ if exbits != existsUpstream {
+ t.Errorf("git pair fetch should only set upstream existence bits, but got %v", exbits)
+ }
+ if len(vlist) != 3 {
+ t.Errorf("git test repo should've produced three versions, got %v", len(vlist))
+ } else {
+ v := NewBranch("master").Is(Revision("30605f6ac35fcb075ad0bfa9296f90a7d891523e"))
+ if vlist[0] != v {
+ t.Errorf("git pair fetch reported incorrect first version, got %s", vlist[0])
+ }
+
+ v = NewBranch("test").Is(Revision("30605f6ac35fcb075ad0bfa9296f90a7d891523e"))
+ if vlist[1] != v {
+ t.Errorf("git pair fetch reported incorrect second version, got %s", vlist[1])
+ }
+
+ v = NewVersion("1.0.0").Is(Revision("30605f6ac35fcb075ad0bfa9296f90a7d891523e"))
+ if vlist[2] != v {
+ t.Errorf("git pair fetch reported incorrect third version, got %s", vlist[2])
+ }
+ }
+
+ // now hg
+ vlist, exbits, err = pms[1].crepo.getCurrentVersionPairs()
+ if err != nil {
+ t.Errorf("Unexpected error getting version pairs from hg repo: %s", err)
+ }
+ if exbits != existsUpstream|existsInCache {
+ t.Errorf("hg pair fetch should set upstream and cache existence bits, but got %v", exbits)
+ }
+ if len(vlist) != 2 {
+ t.Errorf("hg test repo should've produced two versions, got %v", len(vlist))
+ } else {
+ v := NewVersion("1.0.0").Is(Revision("d680e82228d206935ab2eaa88612587abe68db07"))
+ if vlist[0] != v {
+ t.Errorf("hg pair fetch reported incorrect first version, got %s", vlist[0])
+ }
+
+ v = NewBranch("test").Is(Revision("6c44ee3fe5d87763616c19bf7dbcadb24ff5a5ce"))
+ if vlist[1] != v {
+ t.Errorf("hg pair fetch reported incorrect second version, got %s", vlist[1])
+ }
+ }
+
+ // bzr last
+ vlist, exbits, err = pms[2].crepo.getCurrentVersionPairs()
+ if err != nil {
+ t.Errorf("Unexpected error getting version pairs from bzr repo: %s", err)
+ }
+ if exbits != existsUpstream|existsInCache {
+ t.Errorf("bzr pair fetch should set upstream and cache existence bits, but got %v", exbits)
+ }
+ if len(vlist) != 1 {
+ t.Errorf("bzr test repo should've produced one version, got %v", len(vlist))
+ } else {
+ v := NewVersion("1.0.0").Is(Revision("matt@mattfarina.com-20150731135137-pbphasfppmygpl68"))
+ if vlist[0] != v {
+ t.Errorf("bzr pair fetch reported incorrect first version, got %s", vlist[0])
+ }
+ }
+ // no svn for now, because...svn
+}
+
+// Regression test for #32
+func TestGetInfoListVersionsOrdering(t *testing.T) {
+ // This test is quite slow, skip it on -short
+ if testing.Short() {
+ t.Skip("Skipping slow test in short mode")
+ }
+
+ cpath, err := ioutil.TempDir("", "smcache")
+ if err != nil {
+ t.Errorf("Failed to create temp dir: %s", err)
+ }
+ sm, err := NewSourceManager(naiveAnalyzer{}, cpath, false)
+
+ if err != nil {
+ t.Errorf("Unexpected error on SourceManager creation: %s", err)
+ t.FailNow()
+ }
+ defer func() {
+ err := removeAll(cpath)
+ if err != nil {
+ t.Errorf("removeAll failed: %s", err)
+ }
+ }()
+ defer sm.Release()
+
+ // setup done, now do the test
+
+ pn := ProjectRoot("github.com/Masterminds/VCSTestRepo")
+
+ _, _, err = sm.GetProjectInfo(pn, NewVersion("1.0.0"))
+ if err != nil {
+ t.Errorf("Unexpected error from GetInfoAt %s", err)
+ }
+
+ v, err := sm.ListVersions(pn)
+ if err != nil {
+ t.Errorf("Unexpected error from ListVersions %s", err)
+ }
+
+ if len(v) != 3 {
+ t.Errorf("Expected three results from ListVersions, got %v", len(v))
+ }
+}
diff --git a/vendor/github.com/sdboyer/gps/manifest.go b/vendor/github.com/sdboyer/gps/manifest.go
new file mode 100644
index 0000000..83fd9d7
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/manifest.go
@@ -0,0 +1,77 @@
+package gps
+
+// Manifest represents manifest-type data for a project at a particular version.
+// That means dependency constraints, both for normal dependencies and for
+// tests. The constraints expressed in a manifest determine the set of versions that
+// are acceptable to try for a given project.
+//
+// Expressing a constraint in a manifest does not guarantee that a particular
+// dependency will be present. It only guarantees that if packages in the
+// project specified by the dependency are discovered through static analysis of
+// the (transitive) import graph, then they will conform to the constraint.
+//
+// This does entail that manifests can express constraints on projects they do
+// not themselves import. This is by design, but its implications are complex.
+// See the gps docs for more information: https://github.com/sdboyer/gps/wiki
+type Manifest interface {
+ // Returns a list of project-level constraints.
+ DependencyConstraints() []ProjectConstraint
+ // Returns a list of constraints applicable to test imports. Note that this
+ // will only be consulted for root manifests.
+ TestDependencyConstraints() []ProjectConstraint
+}
+
+// SimpleManifest is a helper for tools to enumerate manifest data. It's
+// generally intended for ephemeral manifests, such as those Analyzers create on
+// the fly for projects with no manifest metadata, or metadata through a foreign
+// tool's idioms.
+type SimpleManifest struct {
+ Deps []ProjectConstraint
+ TestDeps []ProjectConstraint
+}
+
+var _ Manifest = SimpleManifest{}
+
+// DependencyConstraints returns the project's dependencies.
+func (m SimpleManifest) DependencyConstraints() []ProjectConstraint {
+ return m.Deps
+}
+
+// TestDependencyConstraints returns the project's test dependencies.
+func (m SimpleManifest) TestDependencyConstraints() []ProjectConstraint {
+ return m.TestDeps
+}
+
+// prepManifest ensures a manifest is prepared and safe for use by the solver.
+// This entails two things:
+//
+// * Ensuring that all ProjectIdentifiers are normalized (otherwise matching
+// can get screwy and the queues go out of alignment)
+// * Defensively ensuring that no outside routine can modify the manifest while
+// the solver is in-flight.
+//
+// This is achieved by copying the manifest's data into a new SimpleManifest.
+func prepManifest(m Manifest) Manifest {
+ if m == nil {
+ return SimpleManifest{}
+ }
+
+ deps := m.DependencyConstraints()
+ ddeps := m.TestDependencyConstraints()
+
+ rm := SimpleManifest{
+ Deps: make([]ProjectConstraint, len(deps)),
+ TestDeps: make([]ProjectConstraint, len(ddeps)),
+ }
+
+ for k, d := range deps {
+ d.Ident = d.Ident.normalize()
+ rm.Deps[k] = d
+ }
+ for k, d := range ddeps {
+ d.Ident = d.Ident.normalize()
+ rm.TestDeps[k] = d
+ }
+
+ return rm
+}
diff --git a/vendor/github.com/sdboyer/gps/marker-header.png b/vendor/github.com/sdboyer/gps/marker-header.png
new file mode 100644
index 0000000..66965c5
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/marker-header.png
Binary files differ
diff --git a/vendor/github.com/sdboyer/gps/project_manager.go b/vendor/github.com/sdboyer/gps/project_manager.go
new file mode 100644
index 0000000..e174fde
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/project_manager.go
@@ -0,0 +1,584 @@
+package gps
+
+import (
+ "bytes"
+ "fmt"
+ "go/build"
+ "os"
+ "os/exec"
+ "path"
+ "path/filepath"
+ "strings"
+ "sync"
+
+ "github.com/Masterminds/vcs"
+ "github.com/termie/go-shutil"
+)
+
+type projectManager struct {
+ // The identifier of the project. At this level, corresponds to the
+ // '$GOPATH/src'-relative path, *and* the network name.
+ n ProjectRoot
+
+ // build.Context to use in any analysis, and to pass to the analyzer
+ ctx build.Context
+
+ // Object for the cache repository
+ crepo *repo
+
+ // Indicates the extent to which we have searched for, and verified, the
+ // existence of the project/repo.
+ ex existence
+
+ // Analyzer, injected by way of the SourceManager and originally from the
+ // sm's creator
+ an ProjectAnalyzer
+
+ // Whether the cache has the latest info on versions
+ cvsync bool
+
+ // The project metadata cache. This is persisted to disk, for reuse across
+ // solver runs.
+ // TODO(sdboyer) protect with mutex
+ dc *projectDataCache
+}
+
+type existence struct {
+ // The existence levels for which a search/check has been performed
+ s projectExistence
+
+ // The existence levels verified to be present through searching
+ f projectExistence
+}
+
+// TODO(sdboyer) figure out shape of versions, then implement marshaling/unmarshaling
+type projectDataCache struct {
+ Version string `json:"version"` // TODO(sdboyer) use this
+ Infos map[Revision]projectInfo `json:"infos"`
+ Packages map[Revision]PackageTree `json:"packages"`
+ VMap map[Version]Revision `json:"vmap"`
+ RMap map[Revision][]Version `json:"rmap"`
+}
+
+// projectInfo holds manifest and lock
+type projectInfo struct {
+ Manifest
+ Lock
+}
+
+type repo struct {
+ // Path to the root of the default working copy (NOT the repo itself)
+ rpath string
+
+ // Mutex controlling general access to the repo
+ mut sync.RWMutex
+
+ // Object for direct repo interaction
+ r vcs.Repo
+
+ // Whether or not the cache repo is in sync (think dvcs) with upstream
+ synced bool
+}
+
+func (pm *projectManager) GetInfoAt(v Version) (Manifest, Lock, error) {
+ if err := pm.ensureCacheExistence(); err != nil {
+ return nil, nil, err
+ }
+
+ if r, exists := pm.dc.VMap[v]; exists {
+ if pi, exists := pm.dc.Infos[r]; exists {
+ return pi.Manifest, pi.Lock, nil
+ }
+ }
+
+ pm.crepo.mut.Lock()
+ var err error
+ if !pm.crepo.synced {
+ err = pm.crepo.r.Update()
+ if err != nil {
+ return nil, nil, fmt.Errorf("Could not fetch latest updates into repository")
+ }
+ pm.crepo.synced = true
+ }
+
+ // Always prefer a rev, if it's available
+ if pv, ok := v.(PairedVersion); ok {
+ err = pm.crepo.r.UpdateVersion(pv.Underlying().String())
+ } else {
+ err = pm.crepo.r.UpdateVersion(v.String())
+ }
+ pm.crepo.mut.Unlock()
+ if err != nil {
+ // TODO(sdboyer) More-er proper-er error
+ panic(fmt.Sprintf("canary - why is checkout/whatever failing: %s %s %s", pm.n, v.String(), err))
+ }
+
+ pm.crepo.mut.RLock()
+ m, l, err := pm.an.GetInfo(filepath.Join(pm.ctx.GOPATH, "src", string(pm.n)), pm.n)
+ // TODO(sdboyer) cache results
+ pm.crepo.mut.RUnlock()
+
+ if err == nil {
+ if l != nil {
+ l = prepLock(l)
+ }
+
+ // If m is nil, prepManifest will provide an empty one.
+ pi := projectInfo{
+ Manifest: prepManifest(m),
+ Lock: l,
+ }
+
+ // TODO(sdboyer) this just clobbers all over and ignores the paired/unpaired
+ // distinction; serious fix is needed
+ if r, exists := pm.dc.VMap[v]; exists {
+ pm.dc.Infos[r] = pi
+ }
+
+ return pi.Manifest, pi.Lock, nil
+ }
+
+ return nil, nil, err
+}
+
+func (pm *projectManager) ListPackages(v Version) (ptree PackageTree, err error) {
+ if err = pm.ensureCacheExistence(); err != nil {
+ return
+ }
+
+ // See if we can find it in the cache
+ var r Revision
+ switch v.(type) {
+ case Revision, PairedVersion:
+ var ok bool
+ if r, ok = v.(Revision); !ok {
+ r = v.(PairedVersion).Underlying()
+ }
+
+ if ptree, cached := pm.dc.Packages[r]; cached {
+ return ptree, nil
+ }
+ default:
+ var has bool
+ if r, has = pm.dc.VMap[v]; has {
+ if ptree, cached := pm.dc.Packages[r]; cached {
+ return ptree, nil
+ }
+ }
+ }
+
+ // TODO(sdboyer) handle the case where we have a version w/out rev, and not in cache
+
+ // Not in the cache; check out the version and do the analysis
+ pm.crepo.mut.Lock()
+ // Check out the desired version for analysis
+ if r != "" {
+ // Always prefer a rev, if it's available
+ err = pm.crepo.r.UpdateVersion(string(r))
+ } else {
+ // If we don't have a rev, ensure the repo is up to date, otherwise we
+ // could have a desync issue
+ if !pm.crepo.synced {
+ err = pm.crepo.r.Update()
+ if err != nil {
+ return PackageTree{}, fmt.Errorf("Could not fetch latest updates into repository: %s", err)
+ }
+ pm.crepo.synced = true
+ }
+ err = pm.crepo.r.UpdateVersion(v.String())
+ }
+
+ ptree, err = listPackages(filepath.Join(pm.ctx.GOPATH, "src", string(pm.n)), string(pm.n))
+ pm.crepo.mut.Unlock()
+
+ // TODO(sdboyer) cache errs?
+ if err != nil {
+ pm.dc.Packages[r] = ptree
+ }
+
+ return
+}
+
+func (pm *projectManager) ensureCacheExistence() error {
+ // Technically, methods could could attempt to return straight from the
+ // metadata cache even if the repo cache doesn't exist on disk. But that
+ // would allow weird state inconsistencies (cache exists, but no repo...how
+ // does that even happen?) that it'd be better to just not allow so that we
+ // don't have to think about it elsewhere
+ if !pm.CheckExistence(existsInCache) {
+ if pm.CheckExistence(existsUpstream) {
+ pm.crepo.mut.Lock()
+ err := pm.crepo.r.Get()
+ pm.crepo.mut.Unlock()
+
+ if err != nil {
+ return fmt.Errorf("failed to create repository cache for %s", pm.n)
+ }
+ pm.ex.s |= existsInCache
+ pm.ex.f |= existsInCache
+ } else {
+ return fmt.Errorf("project %s does not exist upstream", pm.n)
+ }
+ }
+
+ return nil
+}
+
+func (pm *projectManager) ListVersions() (vlist []Version, err error) {
+ if !pm.cvsync {
+ // This check only guarantees that the upstream exists, not the cache
+ pm.ex.s |= existsUpstream
+ vpairs, exbits, err := pm.crepo.getCurrentVersionPairs()
+ // But it *may* also check the local existence
+ pm.ex.s |= exbits
+ pm.ex.f |= exbits
+
+ if err != nil {
+ // TODO(sdboyer) More-er proper-er error
+ fmt.Println(err)
+ return nil, err
+ }
+
+ vlist = make([]Version, len(vpairs))
+ // mark our cache as synced if we got ExistsUpstream back
+ if exbits&existsUpstream == existsUpstream {
+ pm.cvsync = true
+ }
+
+ // Process the version data into the cache
+ // TODO(sdboyer) detect out-of-sync data as we do this?
+ for k, v := range vpairs {
+ pm.dc.VMap[v] = v.Underlying()
+ pm.dc.RMap[v.Underlying()] = append(pm.dc.RMap[v.Underlying()], v)
+ vlist[k] = v
+ }
+ } else {
+ vlist = make([]Version, len(pm.dc.VMap))
+ k := 0
+ // TODO(sdboyer) key type of VMap should be string; recombine here
+ //for v, r := range pm.dc.VMap {
+ for v := range pm.dc.VMap {
+ vlist[k] = v
+ k++
+ }
+ }
+
+ return
+}
+
+func (pm *projectManager) RevisionPresentIn(r Revision) (bool, error) {
+ // First and fastest path is to check the data cache to see if the rev is
+ // present. This could give us false positives, but the cases where that can
+ // occur would require a type of cache staleness that seems *exceedingly*
+ // unlikely to occur.
+ if _, has := pm.dc.Infos[r]; has {
+ return true, nil
+ } else if _, has := pm.dc.RMap[r]; has {
+ return true, nil
+ }
+
+ // For now at least, just run GetInfoAt(); it basically accomplishes the
+ // same thing.
+ if _, _, err := pm.GetInfoAt(r); err != nil {
+ return false, err
+ }
+ return true, nil
+}
+
+// CheckExistence provides a direct method for querying existence levels of the
+// project. It will only perform actual searching (local fs or over the network)
+// if no previous attempt at that search has been made.
+//
+// Note that this may perform read-ish operations on the cache repo, and it
+// takes a lock accordingly. Deadlock may result from calling it during a
+// segment where the cache repo mutex is already write-locked.
+func (pm *projectManager) CheckExistence(ex projectExistence) bool {
+ if pm.ex.s&ex != ex {
+ if ex&existsInVendorRoot != 0 && pm.ex.s&existsInVendorRoot == 0 {
+ panic("should now be implemented in bridge")
+ }
+ if ex&existsInCache != 0 && pm.ex.s&existsInCache == 0 {
+ pm.crepo.mut.RLock()
+ pm.ex.s |= existsInCache
+ if pm.crepo.r.CheckLocal() {
+ pm.ex.f |= existsInCache
+ }
+ pm.crepo.mut.RUnlock()
+ }
+ if ex&existsUpstream != 0 && pm.ex.s&existsUpstream == 0 {
+ pm.crepo.mut.RLock()
+ pm.ex.s |= existsUpstream
+ if pm.crepo.r.Ping() {
+ pm.ex.f |= existsUpstream
+ }
+ pm.crepo.mut.RUnlock()
+ }
+ }
+
+ return ex&pm.ex.f == ex
+}
+
+func (pm *projectManager) ExportVersionTo(v Version, to string) error {
+ return pm.crepo.exportVersionTo(v, to)
+}
+
+func (r *repo) getCurrentVersionPairs() (vlist []PairedVersion, exbits projectExistence, err error) {
+ r.mut.Lock()
+ defer r.mut.Unlock()
+
+ switch r.r.(type) {
+ case *vcs.GitRepo:
+ var out []byte
+ c := exec.Command("git", "ls-remote", r.r.Remote())
+ // Ensure no terminal prompting for PWs
+ c.Env = mergeEnvLists([]string{"GIT_TERMINAL_PROMPT=0"}, os.Environ())
+ out, err = c.CombinedOutput()
+
+ all := bytes.Split(bytes.TrimSpace(out), []byte("\n"))
+ if err != nil || len(all) == 0 {
+ // TODO(sdboyer) remove this path? it really just complicates things, for
+ // probably not much benefit
+
+ // ls-remote failed, probably due to bad communication or a faulty
+ // upstream implementation. So fetch updates, then build the list
+ // locally
+ err = r.r.Update()
+ if err != nil {
+ // Definitely have a problem, now - bail out
+ return
+ }
+
+ // Upstream and cache must exist, so add that to exbits
+ exbits |= existsUpstream | existsInCache
+ // Also, local is definitely now synced
+ r.synced = true
+
+ out, err = r.r.RunFromDir("git", "show-ref", "--dereference")
+ if err != nil {
+ return
+ }
+
+ all = bytes.Split(bytes.TrimSpace(out), []byte("\n"))
+ }
+ // Local cache may not actually exist here, but upstream definitely does
+ exbits |= existsUpstream
+
+ tmap := make(map[string]PairedVersion)
+ for _, pair := range all {
+ var v PairedVersion
+ if string(pair[46:51]) == "heads" {
+ v = NewBranch(string(pair[52:])).Is(Revision(pair[:40])).(PairedVersion)
+ vlist = append(vlist, v)
+ } else if string(pair[46:50]) == "tags" {
+ vstr := string(pair[51:])
+ if strings.HasSuffix(vstr, "^{}") {
+ // If the suffix is there, then we *know* this is the rev of
+ // the underlying commit object that we actually want
+ vstr = strings.TrimSuffix(vstr, "^{}")
+ } else if _, exists := tmap[vstr]; exists {
+ // Already saw the deref'd version of this tag, if one
+ // exists, so skip this.
+ continue
+ // Can only hit this branch if we somehow got the deref'd
+ // version first. Which should be impossible, but this
+ // covers us in case of weirdness, anyway.
+ }
+ v = NewVersion(vstr).Is(Revision(pair[:40])).(PairedVersion)
+ tmap[vstr] = v
+ }
+ }
+
+ // Append all the deref'd (if applicable) tags into the list
+ for _, v := range tmap {
+ vlist = append(vlist, v)
+ }
+ case *vcs.BzrRepo:
+ var out []byte
+ // Update the local first
+ err = r.r.Update()
+ if err != nil {
+ return
+ }
+ // Upstream and cache must exist, so add that to exbits
+ exbits |= existsUpstream | existsInCache
+ // Also, local is definitely now synced
+ r.synced = true
+
+ // Now, list all the tags
+ out, err = r.r.RunFromDir("bzr", "tags", "--show-ids", "-v")
+ if err != nil {
+ return
+ }
+
+ all := bytes.Split(bytes.TrimSpace(out), []byte("\n"))
+ for _, line := range all {
+ idx := bytes.IndexByte(line, 32) // space
+ v := NewVersion(string(line[:idx])).Is(Revision(bytes.TrimSpace(line[idx:]))).(PairedVersion)
+ vlist = append(vlist, v)
+ }
+
+ case *vcs.HgRepo:
+ var out []byte
+ err = r.r.Update()
+ if err != nil {
+ return
+ }
+
+ // Upstream and cache must exist, so add that to exbits
+ exbits |= existsUpstream | existsInCache
+ // Also, local is definitely now synced
+ r.synced = true
+
+ out, err = r.r.RunFromDir("hg", "tags", "--debug", "--verbose")
+ if err != nil {
+ return
+ }
+
+ all := bytes.Split(bytes.TrimSpace(out), []byte("\n"))
+ lbyt := []byte("local")
+ nulrev := []byte("0000000000000000000000000000000000000000")
+ for _, line := range all {
+ if bytes.Equal(lbyt, line[len(line)-len(lbyt):]) {
+ // Skip local tags
+ continue
+ }
+
+ // tip is magic, don't include it
+ if bytes.HasPrefix(line, []byte("tip")) {
+ continue
+ }
+
+ // Split on colon; this gets us the rev and the tag plus local revno
+ pair := bytes.Split(line, []byte(":"))
+ if bytes.Equal(nulrev, pair[1]) {
+ // null rev indicates this tag is marked for deletion
+ continue
+ }
+
+ idx := bytes.IndexByte(pair[0], 32) // space
+ v := NewVersion(string(pair[0][:idx])).Is(Revision(pair[1])).(PairedVersion)
+ vlist = append(vlist, v)
+ }
+
+ out, err = r.r.RunFromDir("hg", "branches", "--debug", "--verbose")
+ if err != nil {
+ // better nothing than incomplete
+ vlist = nil
+ return
+ }
+
+ all = bytes.Split(bytes.TrimSpace(out), []byte("\n"))
+ lbyt = []byte("(inactive)")
+ for _, line := range all {
+ if bytes.Equal(lbyt, line[len(line)-len(lbyt):]) {
+ // Skip inactive branches
+ continue
+ }
+
+ // Split on colon; this gets us the rev and the branch plus local revno
+ pair := bytes.Split(line, []byte(":"))
+ idx := bytes.IndexByte(pair[0], 32) // space
+ v := NewBranch(string(pair[0][:idx])).Is(Revision(pair[1])).(PairedVersion)
+ vlist = append(vlist, v)
+ }
+ case *vcs.SvnRepo:
+ // TODO(sdboyer) is it ok to return empty vlist and no error?
+ // TODO(sdboyer) ...gotta do something for svn, right?
+ default:
+ panic("unknown repo type")
+ }
+
+ return
+}
+
+func (r *repo) exportVersionTo(v Version, to string) error {
+ r.mut.Lock()
+ defer r.mut.Unlock()
+
+ switch r.r.(type) {
+ case *vcs.GitRepo:
+ // Back up original index
+ idx, bak := path.Join(r.rpath, ".git", "index"), path.Join(r.rpath, ".git", "origindex")
+ err := os.Rename(idx, bak)
+ if err != nil {
+ return err
+ }
+
+ // TODO(sdboyer) could have an err here
+ defer os.Rename(bak, idx)
+
+ vstr := v.String()
+ if rv, ok := v.(PairedVersion); ok {
+ vstr = rv.Underlying().String()
+ }
+ _, err = r.r.RunFromDir("git", "read-tree", vstr)
+ if err != nil {
+ return err
+ }
+
+ // Ensure we have exactly one trailing slash
+ to = strings.TrimSuffix(to, string(os.PathSeparator)) + string(os.PathSeparator)
+ // Checkout from our temporary index to the desired target location on disk;
+ // now it's git's job to make it fast. Sadly, this approach *does* also
+ // write out vendor dirs. There doesn't appear to be a way to make
+ // checkout-index respect sparse checkout rules (-a supercedes it);
+ // 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.r.RunFromDir("git", "checkout-index", "-a", "--prefix="+to)
+ return err
+ default:
+ // TODO(sdboyer) This is a dumb, slow approach, but we're punting on making these
+ // fast for now because git is the OVERWHELMING case
+ r.r.UpdateVersion(v.String())
+
+ cfg := &shutil.CopyTreeOptions{
+ Symlinks: true,
+ CopyFunction: shutil.Copy,
+ Ignore: func(src string, contents []os.FileInfo) (ignore []string) {
+ for _, fi := range contents {
+ if !fi.IsDir() {
+ continue
+ }
+ n := fi.Name()
+ switch n {
+ case "vendor", ".bzr", ".svn", ".hg":
+ ignore = append(ignore, n)
+ }
+ }
+
+ return
+ },
+ }
+
+ return shutil.CopyTree(r.rpath, to, cfg)
+ }
+}
+
+// This func copied from Masterminds/vcs so we can exec our own commands
+func mergeEnvLists(in, out []string) []string {
+NextVar:
+ for _, inkv := range in {
+ k := strings.SplitAfterN(inkv, "=", 2)[0]
+ for i, outkv := range out {
+ if strings.HasPrefix(outkv, k) {
+ out[i] = inkv
+ continue NextVar
+ }
+ }
+ out = append(out, inkv)
+ }
+ return out
+}
+
+func stripVendor(path string, info os.FileInfo, err error) error {
+ if info.Name() == "vendor" {
+ if _, err := os.Lstat(path); err == nil {
+ if info.IsDir() {
+ return removeAll(path)
+ }
+ }
+ }
+
+ return nil
+}
diff --git a/vendor/github.com/sdboyer/gps/remote.go b/vendor/github.com/sdboyer/gps/remote.go
new file mode 100644
index 0000000..c808d9a
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/remote.go
@@ -0,0 +1,306 @@
+package gps
+
+import (
+ "fmt"
+ "io"
+ "net/http"
+ "net/url"
+ "regexp"
+ "strings"
+)
+
+// A remoteRepo represents a potential remote repository resource.
+//
+// RemoteRepos are based purely on lexical analysis; successfully constructing
+// one is not a guarantee that the resource it identifies actually exists or is
+// accessible.
+type remoteRepo struct {
+ Base string
+ RelPkg string
+ CloneURL *url.URL
+ Schemes []string
+ VCS []string
+}
+
+//type remoteResult struct {
+//r remoteRepo
+//err error
+//}
+
+// TODO(sdboyer) sync access to this map
+//var remoteCache = make(map[string]remoteResult)
+
+// Regexes for the different known import path flavors
+var (
+ // This regex allowed some usernames that github currently disallows. They
+ // may have allowed them in the past; keeping it in case we need to revert.
+ //ghRegex = regexp.MustCompile(`^(?P<root>github\.com/([A-Za-z0-9_.\-]+/[A-Za-z0-9_.\-]+))(/[A-Za-z0-9_.\-]+)*$`)
+ ghRegex = regexp.MustCompile(`^(?P<root>github\.com/([A-Za-z0-9][-A-Za-z0-9]*[A-Za-z0-9]/[A-Za-z0-9_.\-]+))((?:/[A-Za-z0-9_.\-]+)*)$`)
+ gpinNewRegex = regexp.MustCompile(`^(?P<root>gopkg\.in/(?:([a-zA-Z0-9][-a-zA-Z0-9]+)/)?([a-zA-Z][-.a-zA-Z0-9]*)\.((?:v0|v[1-9][0-9]*)(?:\.0|\.[1-9][0-9]*){0,2}(-unstable)?)(?:\.git)?)((?:/[a-zA-Z0-9][-.a-zA-Z0-9]*)*)$`)
+ //gpinOldRegex = regexp.MustCompile(`^(?P<root>gopkg\.in/(?:([a-z0-9][-a-z0-9]+)/)?((?:v0|v[1-9][0-9]*)(?:\.0|\.[1-9][0-9]*){0,2}(-unstable)?)/([a-zA-Z][-a-zA-Z0-9]*)(?:\.git)?)((?:/[a-zA-Z][-a-zA-Z0-9]*)*)$`)
+ bbRegex = regexp.MustCompile(`^(?P<root>bitbucket\.org/(?P<bitname>[A-Za-z0-9_.\-]+/[A-Za-z0-9_.\-]+))((?:/[A-Za-z0-9_.\-]+)*)$`)
+ //lpRegex = regexp.MustCompile(`^(?P<root>launchpad\.net/([A-Za-z0-9-._]+)(/[A-Za-z0-9-._]+)?)(/.+)?`)
+ lpRegex = regexp.MustCompile(`^(?P<root>launchpad\.net/([A-Za-z0-9-._]+))((?:/[A-Za-z0-9_.\-]+)*)?`)
+ //glpRegex = regexp.MustCompile(`^(?P<root>git\.launchpad\.net/([A-Za-z0-9_.\-]+)|~[A-Za-z0-9_.\-]+/(\+git|[A-Za-z0-9_.\-]+)/[A-Za-z0-9_.\-]+)$`)
+ glpRegex = regexp.MustCompile(`^(?P<root>git\.launchpad\.net/([A-Za-z0-9_.\-]+))((?:/[A-Za-z0-9_.\-]+)*)$`)
+ //gcRegex = regexp.MustCompile(`^(?P<root>code\.google\.com/[pr]/(?P<project>[a-z0-9\-]+)(\.(?P<subrepo>[a-z0-9\-]+))?)(/[A-Za-z0-9_.\-]+)*$`)
+ jazzRegex = regexp.MustCompile(`^(?P<root>hub\.jazz\.net/(git/[a-z0-9]+/[A-Za-z0-9_.\-]+))((?:/[A-Za-z0-9_.\-]+)*)$`)
+ apacheRegex = regexp.MustCompile(`^(?P<root>git\.apache\.org/([a-z0-9_.\-]+\.git))((?:/[A-Za-z0-9_.\-]+)*)$`)
+ genericRegex = regexp.MustCompile(`^(?P<root>(?P<repo>([a-z0-9.\-]+\.)+[a-z0-9.\-]+(:[0-9]+)?/[A-Za-z0-9_.\-/~]*?)\.(?P<vcs>bzr|git|hg|svn))((?:/[A-Za-z0-9_.\-]+)*)$`)
+)
+
+// Other helper regexes
+var (
+ scpSyntaxRe = regexp.MustCompile(`^([a-zA-Z0-9_]+)@([a-zA-Z0-9._-]+):(.*)$`)
+ pathvld = regexp.MustCompile(`^([A-Za-z0-9-]+)(\.[A-Za-z0-9-]+)+(/[A-Za-z0-9-_.~]+)*$`)
+)
+
+// deduceRemoteRepo takes a potential import path and returns a RemoteRepo
+// representing the remote location of the source of an import path. Remote
+// repositories can be bare import paths, or urls including a checkout scheme.
+func deduceRemoteRepo(path string) (rr *remoteRepo, err error) {
+ rr = &remoteRepo{}
+ if m := scpSyntaxRe.FindStringSubmatch(path); m != nil {
+ // Match SCP-like syntax and convert it to a URL.
+ // Eg, "git@github.com:user/repo" becomes
+ // "ssh://git@github.com/user/repo".
+ rr.CloneURL = &url.URL{
+ Scheme: "ssh",
+ User: url.User(m[1]),
+ Host: m[2],
+ Path: "/" + m[3],
+ // TODO(sdboyer) This is what stdlib sets; grok why better
+ //RawPath: m[3],
+ }
+ } else {
+ rr.CloneURL, err = url.Parse(path)
+ if err != nil {
+ return nil, fmt.Errorf("%q is not a valid import path", path)
+ }
+ }
+
+ if rr.CloneURL.Host != "" {
+ path = rr.CloneURL.Host + "/" + strings.TrimPrefix(rr.CloneURL.Path, "/")
+ } else {
+ path = rr.CloneURL.Path
+ }
+
+ if !pathvld.MatchString(path) {
+ return nil, fmt.Errorf("%q is not a valid import path", path)
+ }
+
+ if rr.CloneURL.Scheme != "" {
+ rr.Schemes = []string{rr.CloneURL.Scheme}
+ }
+
+ // TODO(sdboyer) instead of a switch, encode base domain in radix tree and pick
+ // detector from there; if failure, then fall back on metadata work
+
+ switch {
+ case ghRegex.MatchString(path):
+ v := ghRegex.FindStringSubmatch(path)
+
+ rr.CloneURL.Host = "github.com"
+ rr.CloneURL.Path = v[2]
+ rr.Base = v[1]
+ rr.RelPkg = strings.TrimPrefix(v[3], "/")
+ rr.VCS = []string{"git"}
+
+ return
+
+ case gpinNewRegex.MatchString(path):
+ v := gpinNewRegex.FindStringSubmatch(path)
+ // Duplicate some logic from the gopkg.in server in order to validate
+ // the import path string without having to hit the server
+ if strings.Contains(v[4], ".") {
+ return nil, fmt.Errorf("%q is not a valid import path; gopkg.in only allows major versions (%q instead of %q)",
+ path, v[4][:strings.Index(v[4], ".")], v[4])
+ }
+
+ // gopkg.in is always backed by github
+ rr.CloneURL.Host = "github.com"
+ // If the third position is empty, it's the shortened form that expands
+ // to the go-pkg github user
+ if v[2] == "" {
+ rr.CloneURL.Path = "go-pkg/" + v[3]
+ } else {
+ rr.CloneURL.Path = v[2] + "/" + v[3]
+ }
+ rr.Base = v[1]
+ rr.RelPkg = strings.TrimPrefix(v[6], "/")
+ rr.VCS = []string{"git"}
+
+ return
+ //case gpinOldRegex.MatchString(path):
+
+ case bbRegex.MatchString(path):
+ v := bbRegex.FindStringSubmatch(path)
+
+ rr.CloneURL.Host = "bitbucket.org"
+ rr.CloneURL.Path = v[2]
+ rr.Base = v[1]
+ rr.RelPkg = strings.TrimPrefix(v[3], "/")
+ rr.VCS = []string{"git", "hg"}
+
+ return
+
+ //case gcRegex.MatchString(path):
+ //v := gcRegex.FindStringSubmatch(path)
+
+ //rr.CloneURL.Host = "code.google.com"
+ //rr.CloneURL.Path = "p/" + v[2]
+ //rr.Base = v[1]
+ //rr.RelPkg = strings.TrimPrefix(v[5], "/")
+ //rr.VCS = []string{"hg", "git"}
+
+ //return
+
+ case lpRegex.MatchString(path):
+ // TODO(sdboyer) lp handling is nasty - there's ambiguities which can only really
+ // be resolved with a metadata request. See https://github.com/golang/go/issues/11436
+ v := lpRegex.FindStringSubmatch(path)
+
+ rr.CloneURL.Host = "launchpad.net"
+ rr.CloneURL.Path = v[2]
+ rr.Base = v[1]
+ rr.RelPkg = strings.TrimPrefix(v[3], "/")
+ rr.VCS = []string{"bzr"}
+
+ return
+
+ case glpRegex.MatchString(path):
+ // TODO(sdboyer) same ambiguity issues as with normal bzr lp
+ v := glpRegex.FindStringSubmatch(path)
+
+ rr.CloneURL.Host = "git.launchpad.net"
+ rr.CloneURL.Path = v[2]
+ rr.Base = v[1]
+ rr.RelPkg = strings.TrimPrefix(v[3], "/")
+ rr.VCS = []string{"git"}
+
+ return
+
+ case jazzRegex.MatchString(path):
+ v := jazzRegex.FindStringSubmatch(path)
+
+ rr.CloneURL.Host = "hub.jazz.net"
+ rr.CloneURL.Path = v[2]
+ rr.Base = v[1]
+ rr.RelPkg = strings.TrimPrefix(v[3], "/")
+ rr.VCS = []string{"git"}
+
+ return
+
+ case apacheRegex.MatchString(path):
+ v := apacheRegex.FindStringSubmatch(path)
+
+ rr.CloneURL.Host = "git.apache.org"
+ rr.CloneURL.Path = v[2]
+ rr.Base = v[1]
+ rr.RelPkg = strings.TrimPrefix(v[3], "/")
+ rr.VCS = []string{"git"}
+
+ return
+
+ // try the general syntax
+ case genericRegex.MatchString(path):
+ v := genericRegex.FindStringSubmatch(path)
+ switch v[5] {
+ case "git", "hg", "bzr":
+ x := strings.SplitN(v[1], "/", 2)
+ // TODO(sdboyer) is this actually correct for bzr?
+ rr.CloneURL.Host = x[0]
+ rr.CloneURL.Path = x[1]
+ rr.VCS = []string{v[5]}
+ rr.Base = v[1]
+ rr.RelPkg = strings.TrimPrefix(v[6], "/")
+ return
+ default:
+ return nil, fmt.Errorf("unknown repository type: %q", v[5])
+ }
+ }
+
+ // No luck so far. maybe it's one of them vanity imports?
+ importroot, vcs, reporoot, err := parseMetadata(path)
+ if err != nil {
+ return nil, fmt.Errorf("unable to deduce repository and source type for: %q", path)
+ }
+
+ // If we got something back at all, then it supercedes the actual input for
+ // the real URL to hit
+ rr.CloneURL, err = url.Parse(reporoot)
+ if err != nil {
+ return nil, fmt.Errorf("server returned bad URL when searching for vanity import: %q", reporoot)
+ }
+
+ // We have a real URL. Set the other values and return.
+ rr.Base = importroot
+ rr.RelPkg = strings.TrimPrefix(path[len(importroot):], "/")
+
+ rr.VCS = []string{vcs}
+ if rr.CloneURL.Scheme != "" {
+ rr.Schemes = []string{rr.CloneURL.Scheme}
+ }
+
+ return rr, nil
+}
+
+// fetchMetadata fetchs the remote metadata for path.
+func fetchMetadata(path string) (rc io.ReadCloser, err error) {
+ defer func() {
+ if err != nil {
+ err = fmt.Errorf("unable to determine remote metadata protocol: %s", err)
+ }
+ }()
+
+ // try https first
+ rc, err = doFetchMetadata("https", path)
+ if err == nil {
+ return
+ }
+
+ rc, err = doFetchMetadata("http", path)
+ return
+}
+
+func doFetchMetadata(scheme, path string) (io.ReadCloser, error) {
+ url := fmt.Sprintf("%s://%s?go-get=1", scheme, path)
+ switch scheme {
+ case "https", "http":
+ resp, err := http.Get(url)
+ if err != nil {
+ return nil, fmt.Errorf("failed to access url %q", url)
+ }
+ return resp.Body, nil
+ default:
+ return nil, fmt.Errorf("unknown remote protocol scheme: %q", scheme)
+ }
+}
+
+// parseMetadata fetches and decodes remote metadata for path.
+func parseMetadata(path string) (string, string, string, error) {
+ rc, err := fetchMetadata(path)
+ if err != nil {
+ return "", "", "", err
+ }
+ defer rc.Close()
+
+ imports, err := parseMetaGoImports(rc)
+ if err != nil {
+ return "", "", "", err
+ }
+ match := -1
+ for i, im := range imports {
+ if !strings.HasPrefix(path, im.Prefix) {
+ continue
+ }
+ if match != -1 {
+ return "", "", "", fmt.Errorf("multiple meta tags match import path %q", path)
+ }
+ match = i
+ }
+ if match == -1 {
+ return "", "", "", fmt.Errorf("go-import metadata not found")
+ }
+ return imports[match].Prefix, imports[match].VCS, imports[match].RepoRoot, nil
+}
diff --git a/vendor/github.com/sdboyer/gps/remote_test.go b/vendor/github.com/sdboyer/gps/remote_test.go
new file mode 100644
index 0000000..17de00f
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/remote_test.go
@@ -0,0 +1,478 @@
+package gps
+
+import (
+ "fmt"
+ "net/url"
+ "reflect"
+ "testing"
+)
+
+func TestDeduceRemotes(t *testing.T) {
+ if testing.Short() {
+ t.Skip("Skipping remote deduction test in short mode")
+ }
+
+ fixtures := []struct {
+ path string
+ want *remoteRepo
+ }{
+ {
+ "github.com/sdboyer/gps",
+ &remoteRepo{
+ Base: "github.com/sdboyer/gps",
+ RelPkg: "",
+ CloneURL: &url.URL{
+ Host: "github.com",
+ Path: "sdboyer/gps",
+ },
+ Schemes: nil,
+ VCS: []string{"git"},
+ },
+ },
+ {
+ "github.com/sdboyer/gps/foo",
+ &remoteRepo{
+ Base: "github.com/sdboyer/gps",
+ RelPkg: "foo",
+ CloneURL: &url.URL{
+ Host: "github.com",
+ Path: "sdboyer/gps",
+ },
+ Schemes: nil,
+ VCS: []string{"git"},
+ },
+ },
+ {
+ "git@github.com:sdboyer/gps",
+ &remoteRepo{
+ Base: "github.com/sdboyer/gps",
+ RelPkg: "",
+ CloneURL: &url.URL{
+ Scheme: "ssh",
+ User: url.User("git"),
+ Host: "github.com",
+ Path: "sdboyer/gps",
+ },
+ Schemes: []string{"ssh"},
+ VCS: []string{"git"},
+ },
+ },
+ {
+ "https://github.com/sdboyer/gps/foo",
+ &remoteRepo{
+ Base: "github.com/sdboyer/gps",
+ RelPkg: "foo",
+ CloneURL: &url.URL{
+ Scheme: "https",
+ Host: "github.com",
+ Path: "sdboyer/gps",
+ },
+ Schemes: []string{"https"},
+ VCS: []string{"git"},
+ },
+ },
+ {
+ "https://github.com/sdboyer/gps/foo/bar",
+ &remoteRepo{
+ Base: "github.com/sdboyer/gps",
+ RelPkg: "foo/bar",
+ CloneURL: &url.URL{
+ Scheme: "https",
+ Host: "github.com",
+ Path: "sdboyer/gps",
+ },
+ Schemes: []string{"https"},
+ VCS: []string{"git"},
+ },
+ },
+ // some invalid github username patterns
+ {
+ "github.com/-sdboyer/gps/foo",
+ nil,
+ },
+ {
+ "github.com/sdboyer-/gps/foo",
+ nil,
+ },
+ {
+ "github.com/sdbo.yer/gps/foo",
+ nil,
+ },
+ {
+ "github.com/sdbo_yer/gps/foo",
+ nil,
+ },
+ {
+ "gopkg.in/sdboyer/gps.v0",
+ &remoteRepo{
+ Base: "gopkg.in/sdboyer/gps.v0",
+ RelPkg: "",
+ CloneURL: &url.URL{
+ Host: "github.com",
+ Path: "sdboyer/gps",
+ },
+ VCS: []string{"git"},
+ },
+ },
+ {
+ "gopkg.in/sdboyer/gps.v0/foo",
+ &remoteRepo{
+ Base: "gopkg.in/sdboyer/gps.v0",
+ RelPkg: "foo",
+ CloneURL: &url.URL{
+ Host: "github.com",
+ Path: "sdboyer/gps",
+ },
+ VCS: []string{"git"},
+ },
+ },
+ {
+ "gopkg.in/sdboyer/gps.v0/foo/bar",
+ &remoteRepo{
+ Base: "gopkg.in/sdboyer/gps.v0",
+ RelPkg: "foo/bar",
+ CloneURL: &url.URL{
+ Host: "github.com",
+ Path: "sdboyer/gps",
+ },
+ VCS: []string{"git"},
+ },
+ },
+ {
+ "gopkg.in/yaml.v1",
+ &remoteRepo{
+ Base: "gopkg.in/yaml.v1",
+ RelPkg: "",
+ CloneURL: &url.URL{
+ Host: "github.com",
+ Path: "go-pkg/yaml",
+ },
+ VCS: []string{"git"},
+ },
+ },
+ {
+ "gopkg.in/yaml.v1/foo/bar",
+ &remoteRepo{
+ Base: "gopkg.in/yaml.v1",
+ RelPkg: "foo/bar",
+ CloneURL: &url.URL{
+ Host: "github.com",
+ Path: "go-pkg/yaml",
+ },
+ VCS: []string{"git"},
+ },
+ },
+ {
+ // gopkg.in only allows specifying major version in import path
+ "gopkg.in/yaml.v1.2",
+ nil,
+ },
+ // IBM hub devops services - fixtures borrowed from go get
+ {
+ "hub.jazz.net/git/user1/pkgname",
+ &remoteRepo{
+ Base: "hub.jazz.net/git/user1/pkgname",
+ RelPkg: "",
+ CloneURL: &url.URL{
+ Host: "hub.jazz.net",
+ Path: "git/user1/pkgname",
+ },
+ VCS: []string{"git"},
+ },
+ },
+ {
+ "hub.jazz.net/git/user1/pkgname/submodule/submodule/submodule",
+ &remoteRepo{
+ Base: "hub.jazz.net/git/user1/pkgname",
+ RelPkg: "submodule/submodule/submodule",
+ CloneURL: &url.URL{
+ Host: "hub.jazz.net",
+ Path: "git/user1/pkgname",
+ },
+ VCS: []string{"git"},
+ },
+ },
+ {
+ "hub.jazz.net",
+ nil,
+ },
+ {
+ "hub2.jazz.net",
+ nil,
+ },
+ {
+ "hub.jazz.net/someotherprefix",
+ nil,
+ },
+ {
+ "hub.jazz.net/someotherprefix/user1/pkgname",
+ nil,
+ },
+ // Spaces are not valid in user names or package names
+ {
+ "hub.jazz.net/git/User 1/pkgname",
+ nil,
+ },
+ {
+ "hub.jazz.net/git/user1/pkg name",
+ nil,
+ },
+ // Dots are not valid in user names
+ {
+ "hub.jazz.net/git/user.1/pkgname",
+ nil,
+ },
+ {
+ "hub.jazz.net/git/user/pkg.name",
+ &remoteRepo{
+ Base: "hub.jazz.net/git/user/pkg.name",
+ RelPkg: "",
+ CloneURL: &url.URL{
+ Host: "hub.jazz.net",
+ Path: "git/user/pkg.name",
+ },
+ VCS: []string{"git"},
+ },
+ },
+ // User names cannot have uppercase letters
+ {
+ "hub.jazz.net/git/USER/pkgname",
+ nil,
+ },
+ {
+ "bitbucket.org/sdboyer/reporoot",
+ &remoteRepo{
+ Base: "bitbucket.org/sdboyer/reporoot",
+ RelPkg: "",
+ CloneURL: &url.URL{
+ Host: "bitbucket.org",
+ Path: "sdboyer/reporoot",
+ },
+ VCS: []string{"git", "hg"},
+ },
+ },
+ {
+ "bitbucket.org/sdboyer/reporoot/foo/bar",
+ &remoteRepo{
+ Base: "bitbucket.org/sdboyer/reporoot",
+ RelPkg: "foo/bar",
+ CloneURL: &url.URL{
+ Host: "bitbucket.org",
+ Path: "sdboyer/reporoot",
+ },
+ VCS: []string{"git", "hg"},
+ },
+ },
+ {
+ "https://bitbucket.org/sdboyer/reporoot/foo/bar",
+ &remoteRepo{
+ Base: "bitbucket.org/sdboyer/reporoot",
+ RelPkg: "foo/bar",
+ CloneURL: &url.URL{
+ Scheme: "https",
+ Host: "bitbucket.org",
+ Path: "sdboyer/reporoot",
+ },
+ Schemes: []string{"https"},
+ VCS: []string{"git", "hg"},
+ },
+ },
+ {
+ "launchpad.net/govcstestbzrrepo",
+ &remoteRepo{
+ Base: "launchpad.net/govcstestbzrrepo",
+ RelPkg: "",
+ CloneURL: &url.URL{
+ Host: "launchpad.net",
+ Path: "govcstestbzrrepo",
+ },
+ VCS: []string{"bzr"},
+ },
+ },
+ {
+ "launchpad.net/govcstestbzrrepo/foo/bar",
+ &remoteRepo{
+ Base: "launchpad.net/govcstestbzrrepo",
+ RelPkg: "foo/bar",
+ CloneURL: &url.URL{
+ Host: "launchpad.net",
+ Path: "govcstestbzrrepo",
+ },
+ VCS: []string{"bzr"},
+ },
+ },
+ {
+ "launchpad.net/repo root",
+ nil,
+ },
+ {
+ "git.launchpad.net/reporoot",
+ &remoteRepo{
+ Base: "git.launchpad.net/reporoot",
+ RelPkg: "",
+ CloneURL: &url.URL{
+ Host: "git.launchpad.net",
+ Path: "reporoot",
+ },
+ VCS: []string{"git"},
+ },
+ },
+ {
+ "git.launchpad.net/reporoot/foo/bar",
+ &remoteRepo{
+ Base: "git.launchpad.net/reporoot",
+ RelPkg: "foo/bar",
+ CloneURL: &url.URL{
+ Host: "git.launchpad.net",
+ Path: "reporoot",
+ },
+ VCS: []string{"git"},
+ },
+ },
+ {
+ "git.launchpad.net/reporoot",
+ &remoteRepo{
+ Base: "git.launchpad.net/reporoot",
+ RelPkg: "",
+ CloneURL: &url.URL{
+ Host: "git.launchpad.net",
+ Path: "reporoot",
+ },
+ VCS: []string{"git"},
+ },
+ },
+ {
+ "git.launchpad.net/repo root",
+ nil,
+ },
+ {
+ "git.apache.org/package-name.git",
+ &remoteRepo{
+ Base: "git.apache.org/package-name.git",
+ RelPkg: "",
+ CloneURL: &url.URL{
+ Host: "git.apache.org",
+ Path: "package-name.git",
+ },
+ VCS: []string{"git"},
+ },
+ },
+ {
+ "git.apache.org/package-name.git/foo/bar",
+ &remoteRepo{
+ Base: "git.apache.org/package-name.git",
+ RelPkg: "foo/bar",
+ CloneURL: &url.URL{
+ Host: "git.apache.org",
+ Path: "package-name.git",
+ },
+ VCS: []string{"git"},
+ },
+ },
+ // Vanity imports
+ {
+ "golang.org/x/exp",
+ &remoteRepo{
+ Base: "golang.org/x/exp",
+ RelPkg: "",
+ CloneURL: &url.URL{
+ Scheme: "https",
+ Host: "go.googlesource.com",
+ Path: "/exp",
+ },
+ Schemes: []string{"https"},
+ VCS: []string{"git"},
+ },
+ },
+ {
+ "golang.org/x/exp/inotify",
+ &remoteRepo{
+ Base: "golang.org/x/exp",
+ RelPkg: "inotify",
+ CloneURL: &url.URL{
+ Scheme: "https",
+ Host: "go.googlesource.com",
+ Path: "/exp",
+ },
+ Schemes: []string{"https"},
+ VCS: []string{"git"},
+ },
+ },
+ {
+ "rsc.io/pdf",
+ &remoteRepo{
+ Base: "rsc.io/pdf",
+ RelPkg: "",
+ CloneURL: &url.URL{
+ Scheme: "https",
+ Host: "github.com",
+ Path: "/rsc/pdf",
+ },
+ Schemes: []string{"https"},
+ VCS: []string{"git"},
+ },
+ },
+ // Regression - gh does allow two-letter usernames
+ {
+ "github.com/kr/pretty",
+ &remoteRepo{
+ Base: "github.com/kr/pretty",
+ RelPkg: "",
+ CloneURL: &url.URL{
+ Host: "github.com",
+ Path: "kr/pretty",
+ },
+ Schemes: nil,
+ VCS: []string{"git"},
+ },
+ },
+ }
+
+ for _, fix := range fixtures {
+ got, err := deduceRemoteRepo(fix.path)
+ want := fix.want
+
+ if want == nil {
+ if err == nil {
+ t.Errorf("deduceRemoteRepo(%q): Error expected but not received", fix.path)
+ }
+ continue
+ }
+
+ if err != nil {
+ t.Errorf("deduceRemoteRepo(%q): %v", fix.path, err)
+ continue
+ }
+
+ if got.Base != want.Base {
+ t.Errorf("deduceRemoteRepo(%q): Base was %s, wanted %s", fix.path, got.Base, want.Base)
+ }
+ if got.RelPkg != want.RelPkg {
+ t.Errorf("deduceRemoteRepo(%q): RelPkg was %s, wanted %s", fix.path, got.RelPkg, want.RelPkg)
+ }
+ if !reflect.DeepEqual(got.CloneURL, want.CloneURL) {
+ // misspelling things is cool when it makes columns line up
+ t.Errorf("deduceRemoteRepo(%q): CloneURL disagreement:\n(GOT) %s\n(WNT) %s", fix.path, ufmt(got.CloneURL), ufmt(want.CloneURL))
+ }
+ if !reflect.DeepEqual(got.VCS, want.VCS) {
+ t.Errorf("deduceRemoteRepo(%q): VCS was %s, wanted %s", fix.path, got.VCS, want.VCS)
+ }
+ if !reflect.DeepEqual(got.Schemes, want.Schemes) {
+ t.Errorf("deduceRemoteRepo(%q): Schemes was %s, wanted %s", fix.path, got.Schemes, want.Schemes)
+ }
+ }
+}
+
+// borrow from stdlib
+// more useful string for debugging than fmt's struct printer
+func ufmt(u *url.URL) string {
+ var user, pass interface{}
+ if u.User != nil {
+ user = u.User.Username()
+ if p, ok := u.User.Password(); ok {
+ pass = p
+ }
+ }
+ return fmt.Sprintf("host=%q, path=%q, opaque=%q, scheme=%q, user=%#v, pass=%#v, rawpath=%q, rawq=%q, frag=%q",
+ u.Host, u.Path, u.Opaque, u.Scheme, user, pass, u.RawPath, u.RawQuery, u.Fragment)
+}
diff --git a/vendor/github.com/sdboyer/gps/remove_go16.go b/vendor/github.com/sdboyer/gps/remove_go16.go
new file mode 100644
index 0000000..8c7844d
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/remove_go16.go
@@ -0,0 +1,38 @@
+// +build !go1.7
+
+package gps
+
+import (
+ "os"
+ "path/filepath"
+ "runtime"
+)
+
+// removeAll removes path and any children it contains. It deals correctly with
+// removal on Windows where, prior to Go 1.7, there were issues when files were
+// set to read-only.
+func removeAll(path string) error {
+ // Only need special handling for windows
+ if runtime.GOOS != "windows" {
+ return os.RemoveAll(path)
+ }
+
+ // Simple case: if Remove works, we're done.
+ err := os.Remove(path)
+ if err == nil || os.IsNotExist(err) {
+ return nil
+ }
+
+ // make sure all files are writable so we can delete them
+ return filepath.Walk(path, func(path string, info os.FileInfo, err error) error {
+ if err != nil {
+ // walk gave us some error, give it back.
+ return err
+ }
+ mode := info.Mode()
+ if mode|0200 == mode {
+ return nil
+ }
+ return os.Chmod(path, mode|0200)
+ })
+}
diff --git a/vendor/github.com/sdboyer/gps/remove_go17.go b/vendor/github.com/sdboyer/gps/remove_go17.go
new file mode 100644
index 0000000..59c19a6
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/remove_go17.go
@@ -0,0 +1,11 @@
+// +build go1.7
+
+package gps
+
+import "os"
+
+// go1.7 and later deal with the file perms issue in os.RemoveAll(), so our
+// workaround is no longer necessary.
+func removeAll(path string) error {
+ return os.RemoveAll(path)
+}
diff --git a/vendor/github.com/sdboyer/gps/result.go b/vendor/github.com/sdboyer/gps/result.go
new file mode 100644
index 0000000..e601de9
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/result.go
@@ -0,0 +1,73 @@
+package gps
+
+import (
+ "fmt"
+ "os"
+ "path"
+ "path/filepath"
+)
+
+// A Solution is returned by a solver run. It is mostly just a Lock, with some
+// additional methods that report information about the solve run.
+type Solution interface {
+ Lock
+ Attempts() int
+}
+
+type solution struct {
+ // A list of the projects selected by the solver.
+ p []LockedProject
+
+ // The number of solutions that were attempted
+ att int
+
+ // The hash digest of the input opts
+ hd []byte
+}
+
+// CreateVendorTree takes a basedir and a Lock, and exports all the projects
+// listed in the lock to the appropriate target location within the basedir.
+//
+// It requires a SourceManager to do the work, and takes a flag indicating
+// whether or not to strip vendor directories contained in the exported
+// dependencies.
+func CreateVendorTree(basedir string, l Lock, sm SourceManager, sv bool) error {
+ err := os.MkdirAll(basedir, 0777)
+ if err != nil {
+ return err
+ }
+
+ // TODO(sdboyer) parallelize
+ for _, p := range l.Projects() {
+ to := path.Join(basedir, string(p.Ident().ProjectRoot))
+
+ err := os.MkdirAll(to, 0777)
+ if err != nil {
+ return err
+ }
+
+ err = sm.ExportProject(p.Ident().ProjectRoot, p.Version(), to)
+ if err != nil {
+ removeAll(basedir)
+ return fmt.Errorf("Error while exporting %s: %s", p.Ident().ProjectRoot, err)
+ }
+ if sv {
+ filepath.Walk(to, stripVendor)
+ }
+ // TODO(sdboyer) dump version metadata file
+ }
+
+ return nil
+}
+
+func (r solution) Projects() []LockedProject {
+ return r.p
+}
+
+func (r solution) Attempts() int {
+ return r.att
+}
+
+func (r solution) InputHash() []byte {
+ return r.hd
+}
diff --git a/vendor/github.com/sdboyer/gps/result_test.go b/vendor/github.com/sdboyer/gps/result_test.go
new file mode 100644
index 0000000..1aed83b
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/result_test.go
@@ -0,0 +1,107 @@
+package gps
+
+import (
+ "os"
+ "path"
+ "testing"
+)
+
+var basicResult solution
+var kub atom
+
+func pi(n string) ProjectIdentifier {
+ return ProjectIdentifier{
+ ProjectRoot: ProjectRoot(n),
+ }
+}
+
+func init() {
+ basicResult = solution{
+ att: 1,
+ p: []LockedProject{
+ pa2lp(atom{
+ id: pi("github.com/sdboyer/testrepo"),
+ v: NewBranch("master").Is(Revision("4d59fb584b15a94d7401e356d2875c472d76ef45")),
+ }, nil),
+ pa2lp(atom{
+ id: pi("github.com/Masterminds/VCSTestRepo"),
+ v: NewVersion("1.0.0").Is(Revision("30605f6ac35fcb075ad0bfa9296f90a7d891523e")),
+ }, nil),
+ },
+ }
+
+ // just in case something needs punishing, kubernetes is happy to oblige
+ kub = atom{
+ id: pi("github.com/kubernetes/kubernetes"),
+ v: NewVersion("1.0.0").Is(Revision("528f879e7d3790ea4287687ef0ab3f2a01cc2718")),
+ }
+}
+
+func TestResultCreateVendorTree(t *testing.T) {
+ // This test is a bit slow, skip it on -short
+ if testing.Short() {
+ t.Skip("Skipping vendor tree creation test in short mode")
+ }
+
+ r := basicResult
+
+ tmp := path.Join(os.TempDir(), "vsolvtest")
+ os.RemoveAll(tmp)
+
+ sm, err := NewSourceManager(naiveAnalyzer{}, path.Join(tmp, "cache"), false)
+ if err != nil {
+ t.Errorf("NewSourceManager errored unexpectedly: %q", err)
+ }
+
+ err = CreateVendorTree(path.Join(tmp, "export"), r, sm, true)
+ if err != nil {
+ t.Errorf("Unexpected error while creating vendor tree: %s", err)
+ }
+
+ // TODO(sdboyer) add more checks
+}
+
+func BenchmarkCreateVendorTree(b *testing.B) {
+ // We're fs-bound here, so restrict to single parallelism
+ b.SetParallelism(1)
+
+ r := basicResult
+ tmp := path.Join(os.TempDir(), "vsolvtest")
+
+ clean := true
+ sm, err := NewSourceManager(naiveAnalyzer{}, path.Join(tmp, "cache"), true)
+ if err != nil {
+ b.Errorf("NewSourceManager errored unexpectedly: %q", err)
+ clean = false
+ }
+
+ // Prefetch the projects before timer starts
+ for _, lp := range r.p {
+ _, _, err := sm.GetProjectInfo(lp.Ident().ProjectRoot, lp.Version())
+ if err != nil {
+ b.Errorf("failed getting project info during prefetch: %s", err)
+ clean = false
+ }
+ }
+
+ if clean {
+ b.ResetTimer()
+ b.StopTimer()
+ exp := path.Join(tmp, "export")
+ for i := 0; i < b.N; i++ {
+ // Order the loop this way to make it easy to disable final cleanup, to
+ // ease manual inspection
+ os.RemoveAll(exp)
+ b.StartTimer()
+ err = CreateVendorTree(exp, r, sm, true)
+ b.StopTimer()
+ if err != nil {
+ b.Errorf("unexpected error after %v iterations: %s", i, err)
+ break
+ }
+ }
+ }
+
+ sm.Release()
+ os.RemoveAll(tmp) // comment this to leave temp dir behind for inspection
+}
diff --git a/vendor/github.com/sdboyer/gps/satisfy.go b/vendor/github.com/sdboyer/gps/satisfy.go
new file mode 100644
index 0000000..8c99f47
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/satisfy.go
@@ -0,0 +1,316 @@
+package gps
+
+// checkProject performs all constraint checks on a new project (with packages)
+// that we want to select. It determines if selecting the atom would result in
+// a state where all solver requirements are still satisfied.
+func (s *solver) checkProject(a atomWithPackages) error {
+ pa := a.a
+ if nilpa == pa {
+ // This shouldn't be able to happen, but if it does, it unequivocally
+ // indicates a logical bug somewhere, so blowing up is preferable
+ panic("canary - checking version of empty ProjectAtom")
+ }
+
+ if err := s.checkAtomAllowable(pa); err != nil {
+ s.logSolve(err)
+ return err
+ }
+
+ if err := s.checkRequiredPackagesExist(a); err != nil {
+ s.logSolve(err)
+ return err
+ }
+
+ deps, err := s.getImportsAndConstraintsOf(a)
+ if err != nil {
+ // An err here would be from the package fetcher; pass it straight back
+ // TODO(sdboyer) can we logSolve this?
+ return err
+ }
+
+ for _, dep := range deps {
+ if err := s.checkIdentMatches(a, dep); err != nil {
+ s.logSolve(err)
+ return err
+ }
+ if err := s.checkDepsConstraintsAllowable(a, dep); err != nil {
+ s.logSolve(err)
+ return err
+ }
+ if err := s.checkDepsDisallowsSelected(a, dep); err != nil {
+ s.logSolve(err)
+ return err
+ }
+ // TODO(sdboyer) decide how to refactor in order to re-enable this. Checking for
+ // revision existence is important...but kinda obnoxious.
+ //if err := s.checkRevisionExists(a, dep); err != nil {
+ //s.logSolve(err)
+ //return err
+ //}
+ if err := s.checkPackageImportsFromDepExist(a, dep); err != nil {
+ s.logSolve(err)
+ return err
+ }
+
+ // TODO(sdboyer) add check that fails if adding this atom would create a loop
+ }
+
+ return nil
+}
+
+// checkPackages performs all constraint checks for new packages being added to
+// an already-selected project. It determines if selecting the packages would
+// result in a state where all solver requirements are still satisfied.
+func (s *solver) checkPackage(a atomWithPackages) error {
+ if nilpa == a.a {
+ // This shouldn't be able to happen, but if it does, it unequivocally
+ // indicates a logical bug somewhere, so blowing up is preferable
+ panic("canary - checking version of empty ProjectAtom")
+ }
+
+ // The base atom was already validated, so we can skip the
+ // checkAtomAllowable step.
+ deps, err := s.getImportsAndConstraintsOf(a)
+ if err != nil {
+ // An err here would be from the package fetcher; pass it straight back
+ // TODO(sdboyer) can we logSolve this?
+ return err
+ }
+
+ for _, dep := range deps {
+ if err := s.checkIdentMatches(a, dep); err != nil {
+ s.logSolve(err)
+ return err
+ }
+ if err := s.checkDepsConstraintsAllowable(a, dep); err != nil {
+ s.logSolve(err)
+ return err
+ }
+ if err := s.checkDepsDisallowsSelected(a, dep); err != nil {
+ s.logSolve(err)
+ return err
+ }
+ // TODO(sdboyer) decide how to refactor in order to re-enable this. Checking for
+ // revision existence is important...but kinda obnoxious.
+ //if err := s.checkRevisionExists(a, dep); err != nil {
+ //s.logSolve(err)
+ //return err
+ //}
+ if err := s.checkPackageImportsFromDepExist(a, dep); err != nil {
+ s.logSolve(err)
+ return err
+ }
+ }
+
+ return nil
+}
+
+// checkAtomAllowable ensures that an atom itself is acceptable with respect to
+// the constraints established by the current solution.
+func (s *solver) checkAtomAllowable(pa atom) error {
+ constraint := s.sel.getConstraint(pa.id)
+ if s.b.matches(pa.id, constraint, pa.v) {
+ return nil
+ }
+ // TODO(sdboyer) collect constraint failure reason (wait...aren't we, below?)
+
+ deps := s.sel.getDependenciesOn(pa.id)
+ var failparent []dependency
+ for _, dep := range deps {
+ if !s.b.matches(pa.id, dep.dep.Constraint, pa.v) {
+ s.fail(dep.depender.id)
+ failparent = append(failparent, dep)
+ }
+ }
+
+ err := &versionNotAllowedFailure{
+ goal: pa,
+ failparent: failparent,
+ c: constraint,
+ }
+
+ return err
+}
+
+// checkRequiredPackagesExist ensures that all required packages enumerated by
+// existing dependencies on this atom are actually present in the atom.
+func (s *solver) checkRequiredPackagesExist(a atomWithPackages) error {
+ ptree, err := s.b.listPackages(a.a.id, a.a.v)
+ if err != nil {
+ // TODO(sdboyer) handle this more gracefully
+ return err
+ }
+
+ deps := s.sel.getDependenciesOn(a.a.id)
+ fp := make(map[string]errDeppers)
+ // We inspect these in a bit of a roundabout way, in order to incrementally
+ // build up the failure we'd return if there is, indeed, a missing package.
+ // TODO(sdboyer) rechecking all of these every time is wasteful. Is there a shortcut?
+ for _, dep := range deps {
+ for _, pkg := range dep.dep.pl {
+ if errdep, seen := fp[pkg]; seen {
+ errdep.deppers = append(errdep.deppers, dep.depender)
+ fp[pkg] = errdep
+ } else {
+ perr, has := ptree.Packages[pkg]
+ if !has || perr.Err != nil {
+ fp[pkg] = errDeppers{
+ err: perr.Err,
+ deppers: []atom{dep.depender},
+ }
+ }
+ }
+ }
+ }
+
+ if len(fp) > 0 {
+ return &checkeeHasProblemPackagesFailure{
+ goal: a.a,
+ failpkg: fp,
+ }
+ }
+ return nil
+}
+
+// checkDepsConstraintsAllowable checks that the constraints of an atom on a
+// given dep are valid with respect to existing constraints.
+func (s *solver) checkDepsConstraintsAllowable(a atomWithPackages, cdep completeDep) error {
+ dep := cdep.ProjectConstraint
+ constraint := s.sel.getConstraint(dep.Ident)
+ // Ensure the constraint expressed by the dep has at least some possible
+ // intersection with the intersection of existing constraints.
+ if s.b.matchesAny(dep.Ident, constraint, dep.Constraint) {
+ return nil
+ }
+
+ siblings := s.sel.getDependenciesOn(dep.Ident)
+ // No admissible versions - visit all siblings and identify the disagreement(s)
+ var failsib []dependency
+ var nofailsib []dependency
+ for _, sibling := range siblings {
+ if !s.b.matchesAny(dep.Ident, sibling.dep.Constraint, dep.Constraint) {
+ s.fail(sibling.depender.id)
+ failsib = append(failsib, sibling)
+ } else {
+ nofailsib = append(nofailsib, sibling)
+ }
+ }
+
+ return &disjointConstraintFailure{
+ goal: dependency{depender: a.a, dep: cdep},
+ failsib: failsib,
+ nofailsib: nofailsib,
+ c: constraint,
+ }
+}
+
+// checkDepsDisallowsSelected ensures that an atom's constraints on a particular
+// dep are not incompatible with the version of that dep that's already been
+// selected.
+func (s *solver) checkDepsDisallowsSelected(a atomWithPackages, cdep completeDep) error {
+ dep := cdep.ProjectConstraint
+ selected, exists := s.sel.selected(dep.Ident)
+ if exists && !s.b.matches(dep.Ident, dep.Constraint, selected.a.v) {
+ s.fail(dep.Ident)
+
+ return &constraintNotAllowedFailure{
+ goal: dependency{depender: a.a, dep: cdep},
+ v: selected.a.v,
+ }
+ }
+ return nil
+}
+
+// checkIdentMatches ensures that the LocalName of a dep introduced by an atom,
+// has the same NetworkName as what's already been selected (assuming anything's
+// been selected).
+//
+// In other words, this ensures that the solver never simultaneously selects two
+// identifiers with the same local name, but that disagree about where their
+// network source is.
+func (s *solver) checkIdentMatches(a atomWithPackages, cdep completeDep) error {
+ dep := cdep.ProjectConstraint
+ if cur, exists := s.names[dep.Ident.ProjectRoot]; exists {
+ if cur != dep.Ident.netName() {
+ deps := s.sel.getDependenciesOn(a.a.id)
+ // Fail all the other deps, as there's no way atom can ever be
+ // compatible with them
+ for _, d := range deps {
+ s.fail(d.depender.id)
+ }
+
+ return &sourceMismatchFailure{
+ shared: dep.Ident.ProjectRoot,
+ sel: deps,
+ current: cur,
+ mismatch: dep.Ident.netName(),
+ prob: a.a,
+ }
+ }
+ }
+
+ return nil
+}
+
+// checkPackageImportsFromDepExist ensures that, if the dep is already selected,
+// the newly-required set of packages being placed on it exist and are valid.
+func (s *solver) checkPackageImportsFromDepExist(a atomWithPackages, cdep completeDep) error {
+ sel, is := s.sel.selected(cdep.ProjectConstraint.Ident)
+ if !is {
+ // dep is not already selected; nothing to do
+ return nil
+ }
+
+ ptree, err := s.b.listPackages(sel.a.id, sel.a.v)
+ if err != nil {
+ // TODO(sdboyer) handle this more gracefully
+ return err
+ }
+
+ e := &depHasProblemPackagesFailure{
+ goal: dependency{
+ depender: a.a,
+ dep: cdep,
+ },
+ v: sel.a.v,
+ prob: make(map[string]error),
+ }
+
+ for _, pkg := range cdep.pl {
+ perr, has := ptree.Packages[pkg]
+ if !has || perr.Err != nil {
+ e.pl = append(e.pl, pkg)
+ if has {
+ e.prob[pkg] = perr.Err
+ }
+ }
+ }
+
+ if len(e.pl) > 0 {
+ return e
+ }
+ return nil
+}
+
+// checkRevisionExists ensures that if a dependency is constrained by a
+// revision, that that revision actually exists.
+func (s *solver) checkRevisionExists(a atomWithPackages, cdep completeDep) error {
+ r, isrev := cdep.Constraint.(Revision)
+ if !isrev {
+ // Constraint is not a revision; nothing to do
+ return nil
+ }
+
+ present, _ := s.b.revisionPresentIn(cdep.Ident, r)
+ if present {
+ return nil
+ }
+
+ return &nonexistentRevisionFailure{
+ goal: dependency{
+ depender: a.a,
+ dep: cdep,
+ },
+ r: r,
+ }
+}
diff --git a/vendor/github.com/sdboyer/gps/selection.go b/vendor/github.com/sdboyer/gps/selection.go
new file mode 100644
index 0000000..6d84643
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/selection.go
@@ -0,0 +1,198 @@
+package gps
+
+type selection struct {
+ projects []selected
+ deps map[ProjectIdentifier][]dependency
+ sm sourceBridge
+}
+
+type selected struct {
+ a atomWithPackages
+ first bool
+}
+
+func (s *selection) getDependenciesOn(id ProjectIdentifier) []dependency {
+ if deps, exists := s.deps[id]; exists {
+ return deps
+ }
+
+ return nil
+}
+
+// pushSelection pushes a new atomWithPackages onto the selection stack, along
+// with an indicator as to whether this selection indicates a new project *and*
+// packages, or merely some new packages on a project that was already selected.
+func (s *selection) pushSelection(a atomWithPackages, first bool) {
+ s.projects = append(s.projects, selected{
+ a: a,
+ first: first,
+ })
+}
+
+// popSelection removes and returns the last atomWithPackages from the selection
+// stack, along with an indication of whether that element was the first from
+// that project - that is, if it represented an addition of both a project and
+// one or more packages to the overall selection.
+func (s *selection) popSelection() (atomWithPackages, bool) {
+ var sel selected
+ sel, s.projects = s.projects[len(s.projects)-1], s.projects[:len(s.projects)-1]
+ return sel.a, sel.first
+}
+
+func (s *selection) pushDep(dep dependency) {
+ s.deps[dep.dep.Ident] = append(s.deps[dep.dep.Ident], dep)
+}
+
+func (s *selection) popDep(id ProjectIdentifier) (dep dependency) {
+ deps := s.deps[id]
+ dep, s.deps[id] = deps[len(deps)-1], deps[:len(deps)-1]
+ return dep
+}
+
+func (s *selection) depperCount(id ProjectIdentifier) int {
+ return len(s.deps[id])
+}
+
+func (s *selection) setDependenciesOn(id ProjectIdentifier, deps []dependency) {
+ s.deps[id] = deps
+}
+
+// Compute a list of the unique packages within the given ProjectIdentifier that
+// have dependers, and the number of dependers they have.
+func (s *selection) getRequiredPackagesIn(id ProjectIdentifier) map[string]int {
+ // TODO(sdboyer) this is horribly inefficient to do on the fly; we need a method to
+ // precompute it on pushing a new dep, and preferably with an immut
+ // structure so that we can pop with zero cost.
+ uniq := make(map[string]int)
+ for _, dep := range s.deps[id] {
+ for _, pkg := range dep.dep.pl {
+ if count, has := uniq[pkg]; has {
+ count++
+ uniq[pkg] = count
+ } else {
+ uniq[pkg] = 1
+ }
+ }
+ }
+
+ return uniq
+}
+
+// Compute a list of the unique packages within the given ProjectIdentifier that
+// are currently selected, and the number of times each package has been
+// independently selected.
+func (s *selection) getSelectedPackagesIn(id ProjectIdentifier) map[string]int {
+ // TODO(sdboyer) this is horribly inefficient to do on the fly; we need a method to
+ // precompute it on pushing a new dep, and preferably with an immut
+ // structure so that we can pop with zero cost.
+ uniq := make(map[string]int)
+ for _, p := range s.projects {
+ if p.a.a.id.eq(id) {
+ for _, pkg := range p.a.pl {
+ if count, has := uniq[pkg]; has {
+ count++
+ uniq[pkg] = count
+ } else {
+ uniq[pkg] = 1
+ }
+ }
+ }
+ }
+
+ return uniq
+}
+
+func (s *selection) getConstraint(id ProjectIdentifier) Constraint {
+ deps, exists := s.deps[id]
+ if !exists || len(deps) == 0 {
+ return any
+ }
+
+ // TODO(sdboyer) recomputing this sucks and is quite wasteful. Precompute/cache it
+ // on changes to the constraint set, instead.
+
+ // The solver itself is expected to maintain the invariant that all the
+ // constraints kept here collectively admit a non-empty set of versions. We
+ // assume this is the case here while assembling a composite constraint.
+
+ // Start with the open set
+ var ret Constraint = any
+ for _, dep := range deps {
+ ret = s.sm.intersect(id, ret, dep.dep.Constraint)
+ }
+
+ return ret
+}
+
+// selected checks to see if the given ProjectIdentifier has been selected, and
+// if so, returns the corresponding atomWithPackages.
+//
+// It walks the projects selection list from front to back and returns the first
+// match it finds, which means it will always and only return the base selection
+// of the project, without any additional package selections that may or may not
+// have happened later.
+func (s *selection) selected(id ProjectIdentifier) (atomWithPackages, bool) {
+ for _, p := range s.projects {
+ if p.a.a.id.eq(id) {
+ return p.a, true
+ }
+ }
+
+ return atomWithPackages{a: nilpa}, false
+}
+
+type unselected struct {
+ sl []bimodalIdentifier
+ cmp func(i, j int) bool
+}
+
+func (u unselected) Len() int {
+ return len(u.sl)
+}
+
+func (u unselected) Less(i, j int) bool {
+ return u.cmp(i, j)
+}
+
+func (u unselected) Swap(i, j int) {
+ u.sl[i], u.sl[j] = u.sl[j], u.sl[i]
+}
+
+func (u *unselected) Push(x interface{}) {
+ u.sl = append(u.sl, x.(bimodalIdentifier))
+}
+
+func (u *unselected) Pop() (v interface{}) {
+ v, u.sl = u.sl[len(u.sl)-1], u.sl[:len(u.sl)-1]
+ return v
+}
+
+// remove takes a ProjectIdentifier out of the priority queue, if present.
+//
+// There are, generally, two ways this gets called: to remove the unselected
+// item from the front of the queue while that item is being unselected, and
+// during backtracking, when an item becomes unnecessary because the item that
+// induced it was popped off.
+//
+// The worst case for both of these is O(n), but in practice the first case is
+// be O(1), as we iterate the queue from front to back.
+func (u *unselected) remove(bmi bimodalIdentifier) {
+ for k, pi := range u.sl {
+ if pi.id.eq(bmi.id) {
+ // Simple slice comparison - assume they're both sorted the same
+ for k, pkg := range pi.pl {
+ if bmi.pl[k] != pkg {
+ break
+ }
+ }
+
+ if k == len(u.sl)-1 {
+ // if we're on the last element, just pop, no splice
+ u.sl = u.sl[:len(u.sl)-1]
+ } else {
+ u.sl = append(u.sl[:k], u.sl[k+1:]...)
+ }
+ break
+ }
+ }
+}
diff --git a/vendor/github.com/sdboyer/gps/solve_basic_test.go b/vendor/github.com/sdboyer/gps/solve_basic_test.go
new file mode 100644
index 0000000..055ecc8
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/solve_basic_test.go
@@ -0,0 +1,1362 @@
+package gps
+
+import (
+ "fmt"
+ "regexp"
+ "strings"
+
+ "github.com/Masterminds/semver"
+)
+
+var regfrom = regexp.MustCompile(`^(\w*) from (\w*) ([0-9\.]*)`)
+
+// nvSplit splits an "info" string on " " into the pair of name and
+// version/constraint, and returns each individually.
+//
+// This is for narrow use - panics if there are less than two resulting items in
+// the slice.
+func nvSplit(info string) (id ProjectIdentifier, version string) {
+ if strings.Contains(info, " from ") {
+ parts := regfrom.FindStringSubmatch(info)
+ info = parts[1] + " " + parts[3]
+ id.NetworkName = parts[2]
+ }
+
+ s := strings.SplitN(info, " ", 2)
+ if len(s) < 2 {
+ panic(fmt.Sprintf("Malformed name/version info string '%s'", info))
+ }
+
+ id.ProjectRoot, version = ProjectRoot(s[0]), s[1]
+ if id.NetworkName == "" {
+ id.NetworkName = string(id.ProjectRoot)
+ }
+ return
+}
+
+// nvrSplit splits an "info" string on " " into the triplet of name,
+// version/constraint, and revision, and returns each individually.
+//
+// It will work fine if only name and version/constraint are provided.
+//
+// This is for narrow use - panics if there are less than two resulting items in
+// the slice.
+func nvrSplit(info string) (id ProjectIdentifier, version string, revision Revision) {
+ if strings.Contains(info, " from ") {
+ parts := regfrom.FindStringSubmatch(info)
+ info = parts[1] + " " + parts[3]
+ id.NetworkName = parts[2]
+ }
+
+ s := strings.SplitN(info, " ", 3)
+ if len(s) < 2 {
+ panic(fmt.Sprintf("Malformed name/version info string '%s'", info))
+ }
+
+ id.ProjectRoot, version = ProjectRoot(s[0]), s[1]
+ if id.NetworkName == "" {
+ id.NetworkName = string(id.ProjectRoot)
+ }
+
+ if len(s) == 3 {
+ revision = Revision(s[2])
+ }
+ return
+}
+
+// mkAtom splits the input string on a space, and uses the first two elements as
+// the project identifier and version, respectively.
+//
+// The version segment may have a leading character indicating the type of
+// version to create:
+//
+// p: create a "plain" (non-semver) version.
+// b: create a branch version.
+// r: create a revision.
+//
+// No prefix is assumed to indicate a semver version.
+//
+// If a third space-delimited element is provided, it will be interepreted as a
+// revision, and used as the underlying version in a PairedVersion. No prefix
+// should be provided in this case. It is an error (and will panic) to try to
+// pass a revision with an underlying revision.
+func mkAtom(info string) atom {
+ id, ver, rev := nvrSplit(info)
+
+ var v Version
+ switch ver[0] {
+ case 'r':
+ if rev != "" {
+ panic("Cannot pair a revision with a revision")
+ }
+ v = Revision(ver[1:])
+ case 'p':
+ v = NewVersion(ver[1:])
+ case 'b':
+ v = NewBranch(ver[1:])
+ default:
+ _, err := semver.NewVersion(ver)
+ if err != nil {
+ // don't want to allow bad test data at this level, so just panic
+ panic(fmt.Sprintf("Error when converting '%s' into semver: %s", ver, err))
+ }
+ v = NewVersion(ver)
+ }
+
+ if rev != "" {
+ v = v.(UnpairedVersion).Is(rev)
+ }
+
+ return atom{
+ id: id,
+ v: v,
+ }
+}
+
+// mkPDep splits the input string on a space, and uses the first two elements
+// as the project identifier and constraint body, respectively.
+//
+// The constraint body may have a leading character indicating the type of
+// version to create:
+//
+// p: create a "plain" (non-semver) version.
+// b: create a branch version.
+// r: create a revision.
+//
+// If no leading character is used, a semver constraint is assumed.
+func mkPDep(info string) ProjectConstraint {
+ id, ver, rev := nvrSplit(info)
+
+ var c Constraint
+ switch ver[0] {
+ case 'r':
+ c = Revision(ver[1:])
+ case 'p':
+ c = NewVersion(ver[1:])
+ case 'b':
+ c = NewBranch(ver[1:])
+ default:
+ // Without one of those leading characters, we know it's a proper semver
+ // expression, so use the other parser that doesn't look for a rev
+ rev = ""
+ id, ver = nvSplit(info)
+ var err error
+ c, err = NewSemverConstraint(ver)
+ if err != nil {
+ // don't want bad test data at this level, so just panic
+ panic(fmt.Sprintf("Error when converting '%s' into semver constraint: %s (full info: %s)", ver, err, info))
+ }
+ }
+
+ // There's no practical reason that a real tool would need to produce a
+ // constraint that's a PairedVersion, but it is a possibility admitted by the
+ // system, so we at least allow for it in our testing harness.
+ if rev != "" {
+ // Of course, this *will* panic if the predicate is a revision or a
+ // semver constraint, neither of which implement UnpairedVersion. This
+ // is as intended, to prevent bad data from entering the system.
+ c = c.(UnpairedVersion).Is(rev)
+ }
+
+ return ProjectConstraint{
+ Ident: id,
+ Constraint: c,
+ }
+}
+
+// A depspec is a fixture representing all the information a SourceManager would
+// ordinarily glean directly from interrogating a repository.
+type depspec struct {
+ n ProjectRoot
+ v Version
+ deps []ProjectConstraint
+ devdeps []ProjectConstraint
+ pkgs []tpkg
+}
+
+// mkDepspec creates a depspec by processing a series of strings, each of which
+// contains an identiifer and version information.
+//
+// The first string is broken out into the name and version of the package being
+// described - see the docs on mkAtom for details. subsequent strings are
+// interpreted as dep constraints of that dep at that version. See the docs on
+// mkPDep for details.
+//
+// If a string other than the first includes a "(dev) " prefix, it will be
+// treated as a test-only dependency.
+func mkDepspec(pi string, deps ...string) depspec {
+ pa := mkAtom(pi)
+ if string(pa.id.ProjectRoot) != pa.id.NetworkName {
+ panic("alternate source on self makes no sense")
+ }
+
+ ds := depspec{
+ n: pa.id.ProjectRoot,
+ v: pa.v,
+ }
+
+ for _, dep := range deps {
+ var sl *[]ProjectConstraint
+ if strings.HasPrefix(dep, "(dev) ") {
+ dep = strings.TrimPrefix(dep, "(dev) ")
+ sl = &ds.devdeps
+ } else {
+ sl = &ds.deps
+ }
+
+ *sl = append(*sl, mkPDep(dep))
+ }
+
+ return ds
+}
+
+// mklock makes a fixLock, suitable to act as a lock file
+func mklock(pairs ...string) fixLock {
+ l := make(fixLock, 0)
+ for _, s := range pairs {
+ pa := mkAtom(s)
+ l = append(l, NewLockedProject(pa.id.ProjectRoot, pa.v, pa.id.netName(), nil))
+ }
+
+ return l
+}
+
+// mkrevlock makes a fixLock, suitable to act as a lock file, with only a name
+// and a rev
+func mkrevlock(pairs ...string) fixLock {
+ l := make(fixLock, 0)
+ for _, s := range pairs {
+ pa := mkAtom(s)
+ l = append(l, NewLockedProject(pa.id.ProjectRoot, pa.v.(PairedVersion).Underlying(), pa.id.netName(), nil))
+ }
+
+ return l
+}
+
+// mksolution makes a result set
+func mksolution(pairs ...string) map[string]Version {
+ m := make(map[string]Version)
+ for _, pair := range pairs {
+ a := mkAtom(pair)
+ // TODO(sdboyer) identifierify
+ m[string(a.id.ProjectRoot)] = a.v
+ }
+
+ return m
+}
+
+// computeBasicReachMap takes a depspec and computes a reach map which is
+// identical to the explicit depgraph.
+//
+// Using a reachMap here is overkill for what the basic fixtures actually need,
+// but we use it anyway for congruence with the more general cases.
+func computeBasicReachMap(ds []depspec) reachMap {
+ rm := make(reachMap)
+
+ for k, d := range ds {
+ n := string(d.n)
+ lm := map[string][]string{
+ n: nil,
+ }
+ v := d.v
+ if k == 0 {
+ // Put the root in with a nil rev, to accommodate the solver
+ v = nil
+ }
+ rm[pident{n: d.n, v: v}] = lm
+
+ for _, dep := range d.deps {
+ lm[n] = append(lm[n], string(dep.Ident.ProjectRoot))
+ }
+
+ // first is root
+ if k == 0 {
+ for _, dep := range d.devdeps {
+ lm[n] = append(lm[n], string(dep.Ident.ProjectRoot))
+ }
+ }
+ }
+
+ return rm
+}
+
+type pident struct {
+ n ProjectRoot
+ v Version
+}
+
+type specfix interface {
+ name() string
+ specs() []depspec
+ maxTries() int
+ expectErrs() []string
+ solution() map[string]Version
+}
+
+// A basicFixture is a declarative test fixture that can cover a wide variety of
+// solver cases. All cases, however, maintain one invariant: package == project.
+// There are no subpackages, and so it is impossible for them to trigger or
+// require bimodal solving.
+//
+// This type is separate from bimodalFixture in part for legacy reasons - many
+// of these were adapted from similar tests in dart's pub lib, where there is no
+// such thing as "bimodal solving".
+//
+// But it's also useful to keep them separate because bimodal solving involves
+// considerably more complexity than simple solving, both in terms of fixture
+// declaration and actual solving mechanics. Thus, we gain a lot of value for
+// contributors and maintainers by keeping comprehension costs relatively low
+// while still covering important cases.
+type basicFixture struct {
+ // name of this fixture datum
+ n string
+ // depspecs. always treat first as root
+ ds []depspec
+ // results; map of name/version pairs
+ r map[string]Version
+ // max attempts the solver should need to find solution. 0 means no limit
+ maxAttempts int
+ // Use downgrade instead of default upgrade sorter
+ downgrade bool
+ // lock file simulator, if one's to be used at all
+ l fixLock
+ // projects expected to have errors, if any
+ errp []string
+ // request up/downgrade to all projects
+ changeall bool
+}
+
+func (f basicFixture) name() string {
+ return f.n
+}
+
+func (f basicFixture) specs() []depspec {
+ return f.ds
+}
+
+func (f basicFixture) maxTries() int {
+ return f.maxAttempts
+}
+
+func (f basicFixture) expectErrs() []string {
+ return f.errp
+}
+
+func (f basicFixture) solution() map[string]Version {
+ return f.r
+}
+
+// A table of basicFixtures, used in the basic solving test set.
+var basicFixtures = map[string]basicFixture{
+ // basic fixtures
+ "no dependencies": {
+ ds: []depspec{
+ mkDepspec("root 0.0.0"),
+ },
+ r: mksolution(),
+ },
+ "simple dependency tree": {
+ ds: []depspec{
+ mkDepspec("root 0.0.0", "a 1.0.0", "b 1.0.0"),
+ mkDepspec("a 1.0.0", "aa 1.0.0", "ab 1.0.0"),
+ mkDepspec("aa 1.0.0"),
+ mkDepspec("ab 1.0.0"),
+ mkDepspec("b 1.0.0", "ba 1.0.0", "bb 1.0.0"),
+ mkDepspec("ba 1.0.0"),
+ mkDepspec("bb 1.0.0"),
+ },
+ r: mksolution(
+ "a 1.0.0",
+ "aa 1.0.0",
+ "ab 1.0.0",
+ "b 1.0.0",
+ "ba 1.0.0",
+ "bb 1.0.0",
+ ),
+ },
+ "shared dependency with overlapping constraints": {
+ ds: []depspec{
+ mkDepspec("root 0.0.0", "a 1.0.0", "b 1.0.0"),
+ mkDepspec("a 1.0.0", "shared >=2.0.0, <4.0.0"),
+ mkDepspec("b 1.0.0", "shared >=3.0.0, <5.0.0"),
+ mkDepspec("shared 2.0.0"),
+ mkDepspec("shared 3.0.0"),
+ mkDepspec("shared 3.6.9"),
+ mkDepspec("shared 4.0.0"),
+ mkDepspec("shared 5.0.0"),
+ },
+ r: mksolution(
+ "a 1.0.0",
+ "b 1.0.0",
+ "shared 3.6.9",
+ ),
+ },
+ "downgrade on overlapping constraints": {
+ ds: []depspec{
+ mkDepspec("root 0.0.0", "a 1.0.0", "b 1.0.0"),
+ mkDepspec("a 1.0.0", "shared >=2.0.0, <=4.0.0"),
+ mkDepspec("b 1.0.0", "shared >=3.0.0, <5.0.0"),
+ mkDepspec("shared 2.0.0"),
+ mkDepspec("shared 3.0.0"),
+ mkDepspec("shared 3.6.9"),
+ mkDepspec("shared 4.0.0"),
+ mkDepspec("shared 5.0.0"),
+ },
+ r: mksolution(
+ "a 1.0.0",
+ "b 1.0.0",
+ "shared 3.0.0",
+ ),
+ downgrade: true,
+ },
+ "shared dependency where dependent version in turn affects other dependencies": {
+ ds: []depspec{
+ mkDepspec("root 0.0.0", "foo <=1.0.2", "bar 1.0.0"),
+ mkDepspec("foo 1.0.0"),
+ mkDepspec("foo 1.0.1", "bang 1.0.0"),
+ mkDepspec("foo 1.0.2", "whoop 1.0.0"),
+ mkDepspec("foo 1.0.3", "zoop 1.0.0"),
+ mkDepspec("bar 1.0.0", "foo <=1.0.1"),
+ mkDepspec("bang 1.0.0"),
+ mkDepspec("whoop 1.0.0"),
+ mkDepspec("zoop 1.0.0"),
+ },
+ r: mksolution(
+ "foo 1.0.1",
+ "bar 1.0.0",
+ "bang 1.0.0",
+ ),
+ },
+ "removed dependency": {
+ ds: []depspec{
+ mkDepspec("root 1.0.0", "foo 1.0.0", "bar *"),
+ mkDepspec("foo 1.0.0"),
+ mkDepspec("foo 2.0.0"),
+ mkDepspec("bar 1.0.0"),
+ mkDepspec("bar 2.0.0", "baz 1.0.0"),
+ mkDepspec("baz 1.0.0", "foo 2.0.0"),
+ },
+ r: mksolution(
+ "foo 1.0.0",
+ "bar 1.0.0",
+ ),
+ maxAttempts: 2,
+ },
+ "with mismatched net addrs": {
+ ds: []depspec{
+ mkDepspec("root 1.0.0", "foo 1.0.0", "bar 1.0.0"),
+ mkDepspec("foo 1.0.0", "bar from baz 1.0.0"),
+ mkDepspec("bar 1.0.0"),
+ },
+ // TODO(sdboyer) ugh; do real error comparison instead of shitty abstraction
+ errp: []string{"foo", "foo", "root"},
+ },
+ // fixtures with locks
+ "with compatible locked dependency": {
+ ds: []depspec{
+ mkDepspec("root 0.0.0", "foo *"),
+ mkDepspec("foo 1.0.0", "bar 1.0.0"),
+ mkDepspec("foo 1.0.1", "bar 1.0.1"),
+ mkDepspec("foo 1.0.2", "bar 1.0.2"),
+ mkDepspec("bar 1.0.0"),
+ mkDepspec("bar 1.0.1"),
+ mkDepspec("bar 1.0.2"),
+ },
+ l: mklock(
+ "foo 1.0.1",
+ ),
+ r: mksolution(
+ "foo 1.0.1",
+ "bar 1.0.1",
+ ),
+ },
+ "upgrade through lock": {
+ ds: []depspec{
+ mkDepspec("root 0.0.0", "foo *"),
+ mkDepspec("foo 1.0.0", "bar 1.0.0"),
+ mkDepspec("foo 1.0.1", "bar 1.0.1"),
+ mkDepspec("foo 1.0.2", "bar 1.0.2"),
+ mkDepspec("bar 1.0.0"),
+ mkDepspec("bar 1.0.1"),
+ mkDepspec("bar 1.0.2"),
+ },
+ l: mklock(
+ "foo 1.0.1",
+ ),
+ r: mksolution(
+ "foo 1.0.2",
+ "bar 1.0.2",
+ ),
+ changeall: true,
+ },
+ "downgrade through lock": {
+ ds: []depspec{
+ mkDepspec("root 0.0.0", "foo *"),
+ mkDepspec("foo 1.0.0", "bar 1.0.0"),
+ mkDepspec("foo 1.0.1", "bar 1.0.1"),
+ mkDepspec("foo 1.0.2", "bar 1.0.2"),
+ mkDepspec("bar 1.0.0"),
+ mkDepspec("bar 1.0.1"),
+ mkDepspec("bar 1.0.2"),
+ },
+ l: mklock(
+ "foo 1.0.1",
+ ),
+ r: mksolution(
+ "foo 1.0.0",
+ "bar 1.0.0",
+ ),
+ changeall: true,
+ downgrade: true,
+ },
+ "with incompatible locked dependency": {
+ ds: []depspec{
+ mkDepspec("root 0.0.0", "foo >1.0.1"),
+ mkDepspec("foo 1.0.0", "bar 1.0.0"),
+ mkDepspec("foo 1.0.1", "bar 1.0.1"),
+ mkDepspec("foo 1.0.2", "bar 1.0.2"),
+ mkDepspec("bar 1.0.0"),
+ mkDepspec("bar 1.0.1"),
+ mkDepspec("bar 1.0.2"),
+ },
+ l: mklock(
+ "foo 1.0.1",
+ ),
+ r: mksolution(
+ "foo 1.0.2",
+ "bar 1.0.2",
+ ),
+ },
+ "with unrelated locked dependency": {
+ ds: []depspec{
+ mkDepspec("root 0.0.0", "foo *"),
+ mkDepspec("foo 1.0.0", "bar 1.0.0"),
+ mkDepspec("foo 1.0.1", "bar 1.0.1"),
+ mkDepspec("foo 1.0.2", "bar 1.0.2"),
+ mkDepspec("bar 1.0.0"),
+ mkDepspec("bar 1.0.1"),
+ mkDepspec("bar 1.0.2"),
+ mkDepspec("baz 1.0.0 bazrev"),
+ },
+ l: mklock(
+ "baz 1.0.0 bazrev",
+ ),
+ r: mksolution(
+ "foo 1.0.2",
+ "bar 1.0.2",
+ ),
+ },
+ "unlocks dependencies if necessary to ensure that a new dependency is satisfied": {
+ ds: []depspec{
+ mkDepspec("root 0.0.0", "foo *", "newdep *"),
+ mkDepspec("foo 1.0.0 foorev", "bar <2.0.0"),
+ mkDepspec("bar 1.0.0 barrev", "baz <2.0.0"),
+ mkDepspec("baz 1.0.0 bazrev", "qux <2.0.0"),
+ mkDepspec("qux 1.0.0 quxrev"),
+ mkDepspec("foo 2.0.0", "bar <3.0.0"),
+ mkDepspec("bar 2.0.0", "baz <3.0.0"),
+ mkDepspec("baz 2.0.0", "qux <3.0.0"),
+ mkDepspec("qux 2.0.0"),
+ mkDepspec("newdep 2.0.0", "baz >=1.5.0"),
+ },
+ l: mklock(
+ "foo 1.0.0 foorev",
+ "bar 1.0.0 barrev",
+ "baz 1.0.0 bazrev",
+ "qux 1.0.0 quxrev",
+ ),
+ r: mksolution(
+ "foo 2.0.0",
+ "bar 2.0.0",
+ "baz 2.0.0",
+ "qux 1.0.0 quxrev",
+ "newdep 2.0.0",
+ ),
+ maxAttempts: 4,
+ },
+ "locked atoms are matched on both local and net name": {
+ ds: []depspec{
+ mkDepspec("root 0.0.0", "foo *"),
+ mkDepspec("foo 1.0.0 foorev"),
+ mkDepspec("foo 2.0.0 foorev2"),
+ },
+ l: mklock(
+ "foo from baz 1.0.0 foorev",
+ ),
+ r: mksolution(
+ "foo 2.0.0 foorev2",
+ ),
+ },
+ "pairs bare revs in lock with versions": {
+ ds: []depspec{
+ mkDepspec("root 0.0.0", "foo ~1.0.1"),
+ mkDepspec("foo 1.0.0", "bar 1.0.0"),
+ mkDepspec("foo 1.0.1 foorev", "bar 1.0.1"),
+ mkDepspec("foo 1.0.2", "bar 1.0.2"),
+ mkDepspec("bar 1.0.0"),
+ mkDepspec("bar 1.0.1"),
+ mkDepspec("bar 1.0.2"),
+ },
+ l: mkrevlock(
+ "foo 1.0.1 foorev", // mkrevlock drops the 1.0.1
+ ),
+ r: mksolution(
+ "foo 1.0.1 foorev",
+ "bar 1.0.1",
+ ),
+ },
+ "pairs bare revs in lock with all versions": {
+ ds: []depspec{
+ mkDepspec("root 0.0.0", "foo ~1.0.1"),
+ mkDepspec("foo 1.0.0", "bar 1.0.0"),
+ mkDepspec("foo 1.0.1 foorev", "bar 1.0.1"),
+ mkDepspec("foo 1.0.2 foorev", "bar 1.0.2"),
+ mkDepspec("bar 1.0.0"),
+ mkDepspec("bar 1.0.1"),
+ mkDepspec("bar 1.0.2"),
+ },
+ l: mkrevlock(
+ "foo 1.0.1 foorev", // mkrevlock drops the 1.0.1
+ ),
+ r: mksolution(
+ "foo 1.0.2 foorev",
+ "bar 1.0.1",
+ ),
+ },
+ "does not pair bare revs in manifest with unpaired lock version": {
+ ds: []depspec{
+ mkDepspec("root 0.0.0", "foo ~1.0.1"),
+ mkDepspec("foo 1.0.0", "bar 1.0.0"),
+ mkDepspec("foo 1.0.1 foorev", "bar 1.0.1"),
+ mkDepspec("foo 1.0.2", "bar 1.0.2"),
+ mkDepspec("bar 1.0.0"),
+ mkDepspec("bar 1.0.1"),
+ mkDepspec("bar 1.0.2"),
+ },
+ l: mkrevlock(
+ "foo 1.0.1 foorev", // mkrevlock drops the 1.0.1
+ ),
+ r: mksolution(
+ "foo 1.0.1 foorev",
+ "bar 1.0.1",
+ ),
+ },
+ "includes root package's dev dependencies": {
+ ds: []depspec{
+ mkDepspec("root 1.0.0", "(dev) foo 1.0.0", "(dev) bar 1.0.0"),
+ mkDepspec("foo 1.0.0"),
+ mkDepspec("bar 1.0.0"),
+ },
+ r: mksolution(
+ "foo 1.0.0",
+ "bar 1.0.0",
+ ),
+ },
+ "includes dev dependency's transitive dependencies": {
+ ds: []depspec{
+ mkDepspec("root 1.0.0", "(dev) foo 1.0.0"),
+ mkDepspec("foo 1.0.0", "bar 1.0.0"),
+ mkDepspec("bar 1.0.0"),
+ },
+ r: mksolution(
+ "foo 1.0.0",
+ "bar 1.0.0",
+ ),
+ },
+ "ignores transitive dependency's dev dependencies": {
+ ds: []depspec{
+ mkDepspec("root 1.0.0", "(dev) foo 1.0.0"),
+ mkDepspec("foo 1.0.0", "(dev) bar 1.0.0"),
+ mkDepspec("bar 1.0.0"),
+ },
+ r: mksolution(
+ "foo 1.0.0",
+ ),
+ },
+ "no version that matches requirement": {
+ ds: []depspec{
+ mkDepspec("root 0.0.0", "foo >=1.0.0, <2.0.0"),
+ mkDepspec("foo 2.0.0"),
+ mkDepspec("foo 2.1.3"),
+ },
+ errp: []string{"foo", "root"},
+ },
+ "no version that matches combined constraint": {
+ ds: []depspec{
+ mkDepspec("root 0.0.0", "foo 1.0.0", "bar 1.0.0"),
+ mkDepspec("foo 1.0.0", "shared >=2.0.0, <3.0.0"),
+ mkDepspec("bar 1.0.0", "shared >=2.9.0, <4.0.0"),
+ mkDepspec("shared 2.5.0"),
+ mkDepspec("shared 3.5.0"),
+ },
+ errp: []string{"shared", "foo", "bar"},
+ },
+ "disjoint constraints": {
+ ds: []depspec{
+ mkDepspec("root 0.0.0", "foo 1.0.0", "bar 1.0.0"),
+ mkDepspec("foo 1.0.0", "shared <=2.0.0"),
+ mkDepspec("bar 1.0.0", "shared >3.0.0"),
+ mkDepspec("shared 2.0.0"),
+ mkDepspec("shared 4.0.0"),
+ },
+ //errp: []string{"shared", "foo", "bar"}, // dart's has this...
+ errp: []string{"foo", "bar"},
+ },
+ "no valid solution": {
+ ds: []depspec{
+ mkDepspec("root 0.0.0", "a *", "b *"),
+ mkDepspec("a 1.0.0", "b 1.0.0"),
+ mkDepspec("a 2.0.0", "b 2.0.0"),
+ mkDepspec("b 1.0.0", "a 2.0.0"),
+ mkDepspec("b 2.0.0", "a 1.0.0"),
+ },
+ errp: []string{"b", "a"},
+ maxAttempts: 2,
+ },
+ "no version that matches while backtracking": {
+ ds: []depspec{
+ mkDepspec("root 0.0.0", "a *", "b >1.0.0"),
+ mkDepspec("a 1.0.0"),
+ mkDepspec("b 1.0.0"),
+ },
+ errp: []string{"b", "root"},
+ },
+ // The latest versions of a and b disagree on c. An older version of either
+ // will resolve the problem. This test validates that b, which is farther
+ // in the dependency graph from myapp is downgraded first.
+ "rolls back leaf versions first": {
+ ds: []depspec{
+ mkDepspec("root 0.0.0", "a *"),
+ mkDepspec("a 1.0.0", "b *"),
+ mkDepspec("a 2.0.0", "b *", "c 2.0.0"),
+ mkDepspec("b 1.0.0"),
+ mkDepspec("b 2.0.0", "c 1.0.0"),
+ mkDepspec("c 1.0.0"),
+ mkDepspec("c 2.0.0"),
+ },
+ r: mksolution(
+ "a 2.0.0",
+ "b 1.0.0",
+ "c 2.0.0",
+ ),
+ maxAttempts: 2,
+ },
+ // Only one version of baz, so foo and bar will have to downgrade until they
+ // reach it.
+ "mutual downgrading": {
+ ds: []depspec{
+ mkDepspec("root 0.0.0", "foo *"),
+ mkDepspec("foo 1.0.0", "bar 1.0.0"),
+ mkDepspec("foo 2.0.0", "bar 2.0.0"),
+ mkDepspec("foo 3.0.0", "bar 3.0.0"),
+ mkDepspec("bar 1.0.0", "baz *"),
+ mkDepspec("bar 2.0.0", "baz 2.0.0"),
+ mkDepspec("bar 3.0.0", "baz 3.0.0"),
+ mkDepspec("baz 1.0.0"),
+ },
+ r: mksolution(
+ "foo 1.0.0",
+ "bar 1.0.0",
+ "baz 1.0.0",
+ ),
+ maxAttempts: 3,
+ },
+ // Ensures the solver doesn't exhaustively search all versions of b when
+ // it's a-2.0.0 whose dependency on c-2.0.0-nonexistent led to the
+ // problem. We make sure b has more versions than a so that the solver
+ // tries a first since it sorts sibling dependencies by number of
+ // versions.
+ "search real failer": {
+ ds: []depspec{
+ mkDepspec("root 0.0.0", "a *", "b *"),
+ mkDepspec("a 1.0.0", "c 1.0.0"),
+ mkDepspec("a 2.0.0", "c 2.0.0"),
+ mkDepspec("b 1.0.0"),
+ mkDepspec("b 2.0.0"),
+ mkDepspec("b 3.0.0"),
+ mkDepspec("c 1.0.0"),
+ },
+ r: mksolution(
+ "a 1.0.0",
+ "b 3.0.0",
+ "c 1.0.0",
+ ),
+ maxAttempts: 2,
+ },
+ // Dependencies are ordered so that packages with fewer versions are tried
+ // first. Here, there are two valid solutions (either a or b must be
+ // downgraded once). The chosen one depends on which dep is traversed first.
+ // Since b has fewer versions, it will be traversed first, which means a
+ // will come later. Since later selections are revised first, a gets
+ // downgraded.
+ "traverse into package with fewer versions first": {
+ ds: []depspec{
+ mkDepspec("root 0.0.0", "a *", "b *"),
+ mkDepspec("a 1.0.0", "c *"),
+ mkDepspec("a 2.0.0", "c *"),
+ mkDepspec("a 3.0.0", "c *"),
+ mkDepspec("a 4.0.0", "c *"),
+ mkDepspec("a 5.0.0", "c 1.0.0"),
+ mkDepspec("b 1.0.0", "c *"),
+ mkDepspec("b 2.0.0", "c *"),
+ mkDepspec("b 3.0.0", "c *"),
+ mkDepspec("b 4.0.0", "c 2.0.0"),
+ mkDepspec("c 1.0.0"),
+ mkDepspec("c 2.0.0"),
+ },
+ r: mksolution(
+ "a 4.0.0",
+ "b 4.0.0",
+ "c 2.0.0",
+ ),
+ maxAttempts: 2,
+ },
+ // This is similar to the preceding fixture. When getting the number of
+ // versions of a package to determine which to traverse first, versions that
+ // are disallowed by the root package's constraints should not be
+ // considered. Here, foo has more versions than bar in total (4), but fewer
+ // that meet myapp"s constraints (only 2). There is no solution, but we will
+ // do less backtracking if foo is tested first.
+ "root constraints pre-eliminate versions": {
+ ds: []depspec{
+ mkDepspec("root 0.0.0", "foo *", "bar *"),
+ mkDepspec("foo 1.0.0", "none 2.0.0"),
+ mkDepspec("foo 2.0.0", "none 2.0.0"),
+ mkDepspec("foo 3.0.0", "none 2.0.0"),
+ mkDepspec("foo 4.0.0", "none 2.0.0"),
+ mkDepspec("bar 1.0.0"),
+ mkDepspec("bar 2.0.0"),
+ mkDepspec("bar 3.0.0"),
+ mkDepspec("none 1.0.0"),
+ },
+ errp: []string{"none", "foo"},
+ maxAttempts: 1,
+ },
+ // If there"s a disjoint constraint on a package, then selecting other
+ // versions of it is a waste of time: no possible versions can match. We
+ // need to jump past it to the most recent package that affected the
+ // constraint.
+ "backjump past failed package on disjoint constraint": {
+ ds: []depspec{
+ mkDepspec("root 0.0.0", "a *", "foo *"),
+ mkDepspec("a 1.0.0", "foo *"),
+ mkDepspec("a 2.0.0", "foo <1.0.0"),
+ mkDepspec("foo 2.0.0"),
+ mkDepspec("foo 2.0.1"),
+ mkDepspec("foo 2.0.2"),
+ mkDepspec("foo 2.0.3"),
+ mkDepspec("foo 2.0.4"),
+ mkDepspec("none 1.0.0"),
+ },
+ r: mksolution(
+ "a 1.0.0",
+ "foo 2.0.4",
+ ),
+ maxAttempts: 2,
+ },
+ // Revision enters vqueue if a dep has a constraint on that revision
+ "revision injected into vqueue": {
+ ds: []depspec{
+ mkDepspec("root 0.0.0", "foo r123abc"),
+ mkDepspec("foo r123abc"),
+ mkDepspec("foo 1.0.0 foorev"),
+ mkDepspec("foo 2.0.0 foorev2"),
+ },
+ r: mksolution(
+ "foo r123abc",
+ ),
+ },
+ // TODO(sdboyer) decide how to refactor the solver in order to re-enable these.
+ // Checking for revision existence is important...but kinda obnoxious.
+ //{
+ //// Solve fails if revision constraint calls for a nonexistent revision
+ //n: "fail on missing revision",
+ //ds: []depspec{
+ //mkDepspec("root 0.0.0", "bar *"),
+ //mkDepspec("bar 1.0.0", "foo r123abc"),
+ //mkDepspec("foo r123nomatch"),
+ //mkDepspec("foo 1.0.0"),
+ //mkDepspec("foo 2.0.0"),
+ //},
+ //errp: []string{"bar", "foo", "bar"},
+ //},
+ //{
+ //// Solve fails if revision constraint calls for a nonexistent revision,
+ //// even if rev constraint is specified by root
+ //n: "fail on missing revision from root",
+ //ds: []depspec{
+ //mkDepspec("root 0.0.0", "foo r123nomatch"),
+ //mkDepspec("foo r123abc"),
+ //mkDepspec("foo 1.0.0"),
+ //mkDepspec("foo 2.0.0"),
+ //},
+ //errp: []string{"foo", "root", "foo"},
+ //},
+
+ // TODO(sdboyer) add fixture that tests proper handling of loops via aliases (where
+ // a project that wouldn't be a loop is aliased to a project that is a loop)
+}
+
+func init() {
+ // This sets up a hundred versions of foo and bar, 0.0.0 through 9.9.0. Each
+ // version of foo depends on a baz with the same major version. Each version
+ // of bar depends on a baz with the same minor version. There is only one
+ // version of baz, 0.0.0, so only older versions of foo and bar will
+ // satisfy it.
+ fix := basicFixture{
+ ds: []depspec{
+ mkDepspec("root 0.0.0", "foo *", "bar *"),
+ mkDepspec("baz 0.0.0"),
+ },
+ r: mksolution(
+ "foo 0.9.0",
+ "bar 9.0.0",
+ "baz 0.0.0",
+ ),
+ maxAttempts: 10,
+ }
+
+ for i := 0; i < 10; i++ {
+ for j := 0; j < 10; j++ {
+ fix.ds = append(fix.ds, mkDepspec(fmt.Sprintf("foo %v.%v.0", i, j), fmt.Sprintf("baz %v.0.0", i)))
+ fix.ds = append(fix.ds, mkDepspec(fmt.Sprintf("bar %v.%v.0", i, j), fmt.Sprintf("baz 0.%v.0", j)))
+ }
+ }
+
+ basicFixtures["complex backtrack"] = fix
+
+ for k, fix := range basicFixtures {
+ // Assign the name into the fixture itself
+ fix.n = k
+ basicFixtures[k] = fix
+ }
+}
+
+// reachMaps contain externalReach()-type data for a given depspec fixture's
+// universe of proejcts, packages, and versions.
+type reachMap map[pident]map[string][]string
+
+type depspecSourceManager struct {
+ specs []depspec
+ rm reachMap
+ ig map[string]bool
+}
+
+type fixSM interface {
+ SourceManager
+ rootSpec() depspec
+ allSpecs() []depspec
+ ignore() map[string]bool
+}
+
+var _ fixSM = &depspecSourceManager{}
+
+func newdepspecSM(ds []depspec, ignore []string) *depspecSourceManager {
+ ig := make(map[string]bool)
+ if len(ignore) > 0 {
+ for _, pkg := range ignore {
+ ig[pkg] = true
+ }
+ }
+
+ return &depspecSourceManager{
+ specs: ds,
+ rm: computeBasicReachMap(ds),
+ ig: ig,
+ }
+}
+
+func (sm *depspecSourceManager) GetProjectInfo(n ProjectRoot, v Version) (Manifest, Lock, error) {
+ for _, ds := range sm.specs {
+ if n == ds.n && v.Matches(ds.v) {
+ return ds, dummyLock{}, nil
+ }
+ }
+
+ // TODO(sdboyer) proper solver-type errors
+ return nil, nil, fmt.Errorf("Project %s at version %s could not be found", n, v)
+}
+
+func (sm *depspecSourceManager) ExternalReach(n ProjectRoot, v Version) (map[string][]string, error) {
+ id := pident{n: n, v: v}
+ if m, exists := sm.rm[id]; exists {
+ return m, nil
+ }
+ return nil, fmt.Errorf("No reach data for %s at version %s", n, v)
+}
+
+func (sm *depspecSourceManager) ListExternal(n ProjectRoot, v Version) ([]string, error) {
+ // This should only be called for the root
+ id := pident{n: n, v: v}
+ if r, exists := sm.rm[id]; exists {
+ return r[string(n)], nil
+ }
+ return nil, fmt.Errorf("No reach data for %s at version %s", n, v)
+}
+
+func (sm *depspecSourceManager) ListPackages(n ProjectRoot, v Version) (PackageTree, error) {
+ id := pident{n: n, v: v}
+ if r, exists := sm.rm[id]; exists {
+ ptree := PackageTree{
+ ImportRoot: string(n),
+ Packages: map[string]PackageOrErr{
+ string(n): {
+ P: Package{
+ ImportPath: string(n),
+ Name: string(n),
+ Imports: r[string(n)],
+ },
+ },
+ },
+ }
+ return ptree, nil
+ }
+
+ return PackageTree{}, fmt.Errorf("Project %s at version %s could not be found", n, v)
+}
+
+func (sm *depspecSourceManager) ListVersions(name ProjectRoot) (pi []Version, err error) {
+ for _, ds := range sm.specs {
+ // To simulate the behavior of the real SourceManager, we do not return
+ // revisions from ListVersions().
+ if _, isrev := ds.v.(Revision); !isrev && name == ds.n {
+ pi = append(pi, ds.v)
+ }
+ }
+
+ if len(pi) == 0 {
+ err = fmt.Errorf("Project %s could not be found", name)
+ }
+
+ return
+}
+
+func (sm *depspecSourceManager) RevisionPresentIn(name ProjectRoot, r Revision) (bool, error) {
+ for _, ds := range sm.specs {
+ if name == ds.n && r == ds.v {
+ return true, nil
+ }
+ }
+
+ return false, fmt.Errorf("Project %s has no revision %s", name, r)
+}
+
+func (sm *depspecSourceManager) RepoExists(name ProjectRoot) (bool, error) {
+ for _, ds := range sm.specs {
+ if name == ds.n {
+ return true, nil
+ }
+ }
+
+ return false, nil
+}
+
+func (sm *depspecSourceManager) VendorCodeExists(name ProjectRoot) (bool, error) {
+ return false, nil
+}
+
+func (sm *depspecSourceManager) Release() {}
+
+func (sm *depspecSourceManager) ExportProject(n ProjectRoot, v Version, to string) error {
+ return fmt.Errorf("dummy sm doesn't support exporting")
+}
+
+func (sm *depspecSourceManager) rootSpec() depspec {
+ return sm.specs[0]
+}
+
+func (sm *depspecSourceManager) allSpecs() []depspec {
+ return sm.specs
+}
+
+func (sm *depspecSourceManager) ignore() map[string]bool {
+ return sm.ig
+}
+
+type depspecBridge struct {
+ *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(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 nil
+}
+
+func (b *depspecBridge) listPackages(id ProjectIdentifier, v Version) (PackageTree, error) {
+ return b.sm.(fixSM).ListPackages(b.key(id), v)
+}
+
+// override deduceRemoteRepo on bridge to make all our pkg/project mappings work
+// as expected
+func (b *depspecBridge) deduceRemoteRepo(path string) (*remoteRepo, error) {
+ for _, ds := range b.sm.(fixSM).allSpecs() {
+ n := string(ds.n)
+ if path == n || strings.HasPrefix(path, n+"/") {
+ return &remoteRepo{
+ Base: n,
+ RelPkg: strings.TrimPrefix(path, n+"/"),
+ }, nil
+ }
+ }
+ return nil, fmt.Errorf("Could not find %s, or any parent, in list of known fixtures", path)
+}
+
+// enforce interfaces
+var _ Manifest = depspec{}
+var _ Lock = dummyLock{}
+var _ Lock = fixLock{}
+
+// impl Spec interface
+func (ds depspec) DependencyConstraints() []ProjectConstraint {
+ return ds.deps
+}
+
+// impl Spec interface
+func (ds depspec) TestDependencyConstraints() []ProjectConstraint {
+ return ds.devdeps
+}
+
+type fixLock []LockedProject
+
+func (fixLock) SolverVersion() string {
+ return "-1"
+}
+
+// impl Lock interface
+func (fixLock) InputHash() []byte {
+ return []byte("fooooorooooofooorooofoo")
+}
+
+// impl Lock interface
+func (l fixLock) Projects() []LockedProject {
+ return l
+}
+
+type dummyLock struct{}
+
+// impl Lock interface
+func (dummyLock) SolverVersion() string {
+ return "-1"
+}
+
+// impl Lock interface
+func (dummyLock) InputHash() []byte {
+ return []byte("fooooorooooofooorooofoo")
+}
+
+// impl Lock interface
+func (dummyLock) Projects() []LockedProject {
+ return nil
+}
+
+// We've borrowed this bestiary from pub's tests:
+// https://github.com/dart-lang/pub/blob/master/test/version_solver_test.dart
+
+// TODO(sdboyer) finish converting all of these
+
+/*
+func basicGraph() {
+ testResolve("circular dependency", {
+ "myapp 1.0.0": {
+ "foo": "1.0.0"
+ },
+ "foo 1.0.0": {
+ "bar": "1.0.0"
+ },
+ "bar 1.0.0": {
+ "foo": "1.0.0"
+ }
+ }, result: {
+ "myapp from root": "1.0.0",
+ "foo": "1.0.0",
+ "bar": "1.0.0"
+ });
+
+}
+
+func withLockFile() {
+
+}
+
+func rootDependency() {
+ testResolve("with root source", {
+ "myapp 1.0.0": {
+ "foo": "1.0.0"
+ },
+ "foo 1.0.0": {
+ "myapp from root": ">=1.0.0"
+ }
+ }, result: {
+ "myapp from root": "1.0.0",
+ "foo": "1.0.0"
+ });
+
+ testResolve("with different source", {
+ "myapp 1.0.0": {
+ "foo": "1.0.0"
+ },
+ "foo 1.0.0": {
+ "myapp": ">=1.0.0"
+ }
+ }, result: {
+ "myapp from root": "1.0.0",
+ "foo": "1.0.0"
+ });
+
+ testResolve("with wrong version", {
+ "myapp 1.0.0": {
+ "foo": "1.0.0"
+ },
+ "foo 1.0.0": {
+ "myapp": "<1.0.0"
+ }
+ }, error: couldNotSolve);
+}
+
+func unsolvable() {
+
+ testResolve("mismatched descriptions", {
+ "myapp 0.0.0": {
+ "foo": "1.0.0",
+ "bar": "1.0.0"
+ },
+ "foo 1.0.0": {
+ "shared-x": "1.0.0"
+ },
+ "bar 1.0.0": {
+ "shared-y": "1.0.0"
+ },
+ "shared-x 1.0.0": {},
+ "shared-y 1.0.0": {}
+ }, error: descriptionMismatch("shared", "foo", "bar"));
+
+ testResolve("mismatched sources", {
+ "myapp 0.0.0": {
+ "foo": "1.0.0",
+ "bar": "1.0.0"
+ },
+ "foo 1.0.0": {
+ "shared": "1.0.0"
+ },
+ "bar 1.0.0": {
+ "shared from mock2": "1.0.0"
+ },
+ "shared 1.0.0": {},
+ "shared 1.0.0 from mock2": {}
+ }, error: sourceMismatch("shared", "foo", "bar"));
+
+
+
+ // This is a regression test for #18300.
+ testResolve("...", {
+ "myapp 0.0.0": {
+ "angular": "any",
+ "collection": "any"
+ },
+ "analyzer 0.12.2": {},
+ "angular 0.10.0": {
+ "di": ">=0.0.32 <0.1.0",
+ "collection": ">=0.9.1 <1.0.0"
+ },
+ "angular 0.9.11": {
+ "di": ">=0.0.32 <0.1.0",
+ "collection": ">=0.9.1 <1.0.0"
+ },
+ "angular 0.9.10": {
+ "di": ">=0.0.32 <0.1.0",
+ "collection": ">=0.9.1 <1.0.0"
+ },
+ "collection 0.9.0": {},
+ "collection 0.9.1": {},
+ "di 0.0.37": {"analyzer": ">=0.13.0 <0.14.0"},
+ "di 0.0.36": {"analyzer": ">=0.13.0 <0.14.0"}
+ }, error: noVersion(["analyzer", "di"]), maxTries: 2);
+}
+
+func badSource() {
+ testResolve("fail if the root package has a bad source in dep", {
+ "myapp 0.0.0": {
+ "foo from bad": "any"
+ },
+ }, error: unknownSource("myapp", "foo", "bad"));
+
+ testResolve("fail if the root package has a bad source in dev dep", {
+ "myapp 0.0.0": {
+ "(dev) foo from bad": "any"
+ },
+ }, error: unknownSource("myapp", "foo", "bad"));
+
+ testResolve("fail if all versions have bad source in dep", {
+ "myapp 0.0.0": {
+ "foo": "any"
+ },
+ "foo 1.0.0": {
+ "bar from bad": "any"
+ },
+ "foo 1.0.1": {
+ "baz from bad": "any"
+ },
+ "foo 1.0.3": {
+ "bang from bad": "any"
+ },
+ }, error: unknownSource("foo", "bar", "bad"), maxTries: 3);
+
+ testResolve("ignore versions with bad source in dep", {
+ "myapp 1.0.0": {
+ "foo": "any"
+ },
+ "foo 1.0.0": {
+ "bar": "any"
+ },
+ "foo 1.0.1": {
+ "bar from bad": "any"
+ },
+ "foo 1.0.3": {
+ "bar from bad": "any"
+ },
+ "bar 1.0.0": {}
+ }, result: {
+ "myapp from root": "1.0.0",
+ "foo": "1.0.0",
+ "bar": "1.0.0"
+ }, maxTries: 3);
+}
+
+func backtracking() {
+ testResolve("circular dependency on older version", {
+ "myapp 0.0.0": {
+ "a": ">=1.0.0"
+ },
+ "a 1.0.0": {},
+ "a 2.0.0": {
+ "b": "1.0.0"
+ },
+ "b 1.0.0": {
+ "a": "1.0.0"
+ }
+ }, result: {
+ "myapp from root": "0.0.0",
+ "a": "1.0.0"
+ }, maxTries: 2);
+}
+*/
diff --git a/vendor/github.com/sdboyer/gps/solve_bimodal_test.go b/vendor/github.com/sdboyer/gps/solve_bimodal_test.go
new file mode 100644
index 0000000..09333e0
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/solve_bimodal_test.go
@@ -0,0 +1,643 @@
+package gps
+
+import (
+ "fmt"
+ "path/filepath"
+)
+
+// dsp - "depspec with packages"
+//
+// Wraps a set of tpkgs onto a depspec, and returns it.
+func dsp(ds depspec, pkgs ...tpkg) depspec {
+ ds.pkgs = pkgs
+ return ds
+}
+
+// pkg makes a tpkg appropriate for use in bimodal testing
+func pkg(path string, imports ...string) tpkg {
+ return tpkg{
+ path: path,
+ imports: imports,
+ }
+}
+
+func init() {
+ for k, fix := range bimodalFixtures {
+ // Assign the name into the fixture itself
+ fix.n = k
+ bimodalFixtures[k] = fix
+ }
+}
+
+// Fixtures that rely on simulated bimodal (project and package-level)
+// analysis for correct operation. The name given in the map gets assigned into
+// the fixture itself in init().
+var bimodalFixtures = map[string]bimodalFixture{
+ // Simple case, ensures that we do the very basics of picking up and
+ // including a single, simple import that is not expressed as a constraint
+ "simple bm-add": {
+ ds: []depspec{
+ dsp(mkDepspec("root 0.0.0"),
+ pkg("root", "a")),
+ dsp(mkDepspec("a 1.0.0"),
+ pkg("a")),
+ },
+ r: mksolution(
+ "a 1.0.0",
+ ),
+ },
+ // Ensure it works when the import jump is not from the package with the
+ // same path as root, but from a subpkg
+ "subpkg bm-add": {
+ ds: []depspec{
+ dsp(mkDepspec("root 0.0.0"),
+ pkg("root", "root/foo"),
+ pkg("root/foo", "a"),
+ ),
+ dsp(mkDepspec("a 1.0.0"),
+ pkg("a"),
+ ),
+ },
+ r: mksolution(
+ "a 1.0.0",
+ ),
+ },
+ // The same, but with a jump through two subpkgs
+ "double-subpkg bm-add": {
+ ds: []depspec{
+ dsp(mkDepspec("root 0.0.0"),
+ pkg("root", "root/foo"),
+ pkg("root/foo", "root/bar"),
+ pkg("root/bar", "a"),
+ ),
+ dsp(mkDepspec("a 1.0.0"),
+ pkg("a"),
+ ),
+ },
+ r: mksolution(
+ "a 1.0.0",
+ ),
+ },
+ // Same again, but now nest the subpkgs
+ "double nested subpkg bm-add": {
+ ds: []depspec{
+ dsp(mkDepspec("root 0.0.0"),
+ pkg("root", "root/foo"),
+ pkg("root/foo", "root/foo/bar"),
+ pkg("root/foo/bar", "a"),
+ ),
+ dsp(mkDepspec("a 1.0.0"),
+ pkg("a"),
+ ),
+ },
+ r: mksolution(
+ "a 1.0.0",
+ ),
+ },
+ // Importing package from project with no root package
+ "bm-add on project with no pkg in root dir": {
+ ds: []depspec{
+ dsp(mkDepspec("root 0.0.0"),
+ pkg("root", "a/foo")),
+ dsp(mkDepspec("a 1.0.0"),
+ pkg("a/foo")),
+ },
+ r: mksolution(
+ "a 1.0.0",
+ ),
+ },
+ // Import jump is in a dep, and points to a transitive dep
+ "transitive bm-add": {
+ ds: []depspec{
+ dsp(mkDepspec("root 0.0.0"),
+ pkg("root", "root/foo"),
+ pkg("root/foo", "a"),
+ ),
+ dsp(mkDepspec("a 1.0.0"),
+ pkg("a", "b"),
+ ),
+ dsp(mkDepspec("b 1.0.0"),
+ pkg("b"),
+ ),
+ },
+ r: mksolution(
+ "a 1.0.0",
+ "b 1.0.0",
+ ),
+ },
+ // Constraints apply only if the project that declares them has a
+ // reachable import
+ "constraints activated by import": {
+ ds: []depspec{
+ dsp(mkDepspec("root 0.0.0", "b 1.0.0"),
+ pkg("root", "root/foo"),
+ pkg("root/foo", "a"),
+ ),
+ dsp(mkDepspec("a 1.0.0"),
+ pkg("a", "b"),
+ ),
+ dsp(mkDepspec("b 1.0.0"),
+ pkg("b"),
+ ),
+ dsp(mkDepspec("b 1.1.0"),
+ pkg("b"),
+ ),
+ },
+ r: mksolution(
+ "a 1.0.0",
+ "b 1.1.0",
+ ),
+ },
+ // Import jump is in a dep, and points to a transitive dep - but only in not
+ // the first version we try
+ "transitive bm-add on older version": {
+ ds: []depspec{
+ dsp(mkDepspec("root 0.0.0", "a ~1.0.0"),
+ pkg("root", "root/foo"),
+ pkg("root/foo", "a"),
+ ),
+ dsp(mkDepspec("a 1.0.0"),
+ pkg("a", "b"),
+ ),
+ dsp(mkDepspec("a 1.1.0"),
+ pkg("a"),
+ ),
+ dsp(mkDepspec("b 1.0.0"),
+ pkg("b"),
+ ),
+ },
+ r: mksolution(
+ "a 1.0.0",
+ "b 1.0.0",
+ ),
+ },
+ // Import jump is in a dep, and points to a transitive dep - but will only
+ // get there via backtracking
+ "backtrack to dep on bm-add": {
+ ds: []depspec{
+ dsp(mkDepspec("root 0.0.0"),
+ pkg("root", "root/foo"),
+ pkg("root/foo", "a", "b"),
+ ),
+ dsp(mkDepspec("a 1.0.0"),
+ pkg("a", "c"),
+ ),
+ dsp(mkDepspec("a 1.1.0"),
+ pkg("a"),
+ ),
+ // Include two versions of b, otherwise it'll be selected first
+ dsp(mkDepspec("b 0.9.0"),
+ pkg("b", "c"),
+ ),
+ dsp(mkDepspec("b 1.0.0"),
+ pkg("b", "c"),
+ ),
+ dsp(mkDepspec("c 1.0.0", "a 1.0.0"),
+ pkg("c", "a"),
+ ),
+ },
+ r: mksolution(
+ "a 1.0.0",
+ "b 1.0.0",
+ "c 1.0.0",
+ ),
+ },
+ // Import jump is in a dep subpkg, and points to a transitive dep
+ "transitive subpkg bm-add": {
+ ds: []depspec{
+ dsp(mkDepspec("root 0.0.0"),
+ pkg("root", "root/foo"),
+ pkg("root/foo", "a"),
+ ),
+ dsp(mkDepspec("a 1.0.0"),
+ pkg("a", "a/bar"),
+ pkg("a/bar", "b"),
+ ),
+ dsp(mkDepspec("b 1.0.0"),
+ pkg("b"),
+ ),
+ },
+ r: mksolution(
+ "a 1.0.0",
+ "b 1.0.0",
+ ),
+ },
+ // Import jump is in a dep subpkg, pointing to a transitive dep, but only in
+ // not the first version we try
+ "transitive subpkg bm-add on older version": {
+ ds: []depspec{
+ dsp(mkDepspec("root 0.0.0", "a ~1.0.0"),
+ pkg("root", "root/foo"),
+ pkg("root/foo", "a"),
+ ),
+ dsp(mkDepspec("a 1.0.0"),
+ pkg("a", "a/bar"),
+ pkg("a/bar", "b"),
+ ),
+ dsp(mkDepspec("a 1.1.0"),
+ pkg("a", "a/bar"),
+ pkg("a/bar"),
+ ),
+ dsp(mkDepspec("b 1.0.0"),
+ pkg("b"),
+ ),
+ },
+ r: mksolution(
+ "a 1.0.0",
+ "b 1.0.0",
+ ),
+ },
+ // Ensure that if a constraint is expressed, but no actual import exists,
+ // then the constraint is disregarded - the project named in the constraint
+ // is not part of the solution.
+ "ignore constraint without import": {
+ ds: []depspec{
+ dsp(mkDepspec("root 0.0.0", "a 1.0.0"),
+ pkg("root", "root/foo"),
+ pkg("root/foo"),
+ ),
+ dsp(mkDepspec("a 1.0.0"),
+ pkg("a"),
+ ),
+ },
+ r: mksolution(),
+ },
+ // Transitive deps from one project (a) get incrementally included as other
+ // deps incorporate its various packages.
+ "multi-stage pkg incorporation": {
+ ds: []depspec{
+ dsp(mkDepspec("root 0.0.0"),
+ pkg("root", "a", "d"),
+ ),
+ dsp(mkDepspec("a 1.0.0"),
+ pkg("a", "b"),
+ pkg("a/second", "c"),
+ ),
+ dsp(mkDepspec("b 2.0.0"),
+ pkg("b"),
+ ),
+ dsp(mkDepspec("c 1.2.0"),
+ pkg("c"),
+ ),
+ dsp(mkDepspec("d 1.0.0"),
+ pkg("d", "a/second"),
+ ),
+ },
+ r: mksolution(
+ "a 1.0.0",
+ "b 2.0.0",
+ "c 1.2.0",
+ "d 1.0.0",
+ ),
+ },
+ // Regression - make sure that the the constraint/import intersector only
+ // accepts a project 'match' if exactly equal, or a separating slash is
+ // present.
+ "radix path separator post-check": {
+ ds: []depspec{
+ dsp(mkDepspec("root 0.0.0"),
+ pkg("root", "foo", "foobar"),
+ ),
+ dsp(mkDepspec("foo 1.0.0"),
+ pkg("foo"),
+ ),
+ dsp(mkDepspec("foobar 1.0.0"),
+ pkg("foobar"),
+ ),
+ },
+ r: mksolution(
+ "foo 1.0.0",
+ "foobar 1.0.0",
+ ),
+ },
+ // Well-formed failure when there's a dependency on a pkg that doesn't exist
+ "fail when imports nonexistent package": {
+ ds: []depspec{
+ dsp(mkDepspec("root 0.0.0", "a 1.0.0"),
+ pkg("root", "a/foo"),
+ ),
+ dsp(mkDepspec("a 1.0.0"),
+ pkg("a"),
+ ),
+ },
+ errp: []string{"a", "root", "a"},
+ },
+ // Transitive deps from one project (a) get incrementally included as other
+ // deps incorporate its various packages, and fail with proper error when we
+ // discover one incrementally that isn't present
+ "fail multi-stage missing pkg": {
+ ds: []depspec{
+ dsp(mkDepspec("root 0.0.0"),
+ pkg("root", "a", "d"),
+ ),
+ dsp(mkDepspec("a 1.0.0"),
+ pkg("a", "b"),
+ pkg("a/second", "c"),
+ ),
+ dsp(mkDepspec("b 2.0.0"),
+ pkg("b"),
+ ),
+ dsp(mkDepspec("c 1.2.0"),
+ pkg("c"),
+ ),
+ dsp(mkDepspec("d 1.0.0"),
+ pkg("d", "a/second"),
+ pkg("d", "a/nonexistent"),
+ ),
+ },
+ errp: []string{"d", "a", "d"},
+ },
+ // Check ignores on the root project
+ "ignore in double-subpkg": {
+ ds: []depspec{
+ dsp(mkDepspec("root 0.0.0"),
+ pkg("root", "root/foo"),
+ pkg("root/foo", "root/bar", "b"),
+ pkg("root/bar", "a"),
+ ),
+ dsp(mkDepspec("a 1.0.0"),
+ pkg("a"),
+ ),
+ dsp(mkDepspec("b 1.0.0"),
+ pkg("b"),
+ ),
+ },
+ ignore: []string{"root/bar"},
+ r: mksolution(
+ "b 1.0.0",
+ ),
+ },
+ // Ignores on a dep pkg
+ "ignore through dep pkg": {
+ ds: []depspec{
+ dsp(mkDepspec("root 0.0.0"),
+ pkg("root", "root/foo"),
+ pkg("root/foo", "a"),
+ ),
+ dsp(mkDepspec("a 1.0.0"),
+ pkg("a", "a/bar"),
+ pkg("a/bar", "b"),
+ ),
+ dsp(mkDepspec("b 1.0.0"),
+ pkg("b"),
+ ),
+ },
+ ignore: []string{"a/bar"},
+ r: mksolution(
+ "a 1.0.0",
+ ),
+ },
+ // Preferred version, as derived from a dep's lock, is attempted first
+ "respect prefv, simple case": {
+ ds: []depspec{
+ dsp(mkDepspec("root 0.0.0"),
+ pkg("root", "a")),
+ dsp(mkDepspec("a 1.0.0"),
+ pkg("a", "b")),
+ dsp(mkDepspec("b 1.0.0 foorev"),
+ pkg("b")),
+ dsp(mkDepspec("b 2.0.0 barrev"),
+ pkg("b")),
+ },
+ lm: map[string]fixLock{
+ "a 1.0.0": mklock(
+ "b 1.0.0 foorev",
+ ),
+ },
+ r: mksolution(
+ "a 1.0.0",
+ "b 1.0.0 foorev",
+ ),
+ },
+ // Preferred version, as derived from a dep's lock, is attempted first, even
+ // if the root also has a direct dep on it (root doesn't need to use
+ // preferreds, because it has direct control AND because the root lock
+ // already supercedes dep lock "preferences")
+ "respect dep prefv with root import": {
+ ds: []depspec{
+ dsp(mkDepspec("root 0.0.0"),
+ pkg("root", "a", "b")),
+ dsp(mkDepspec("a 1.0.0"),
+ pkg("a", "b")),
+ //dsp(newDepspec("a 1.0.1"),
+ //pkg("a", "b")),
+ //dsp(newDepspec("a 1.1.0"),
+ //pkg("a", "b")),
+ dsp(mkDepspec("b 1.0.0 foorev"),
+ pkg("b")),
+ dsp(mkDepspec("b 2.0.0 barrev"),
+ pkg("b")),
+ },
+ lm: map[string]fixLock{
+ "a 1.0.0": mklock(
+ "b 1.0.0 foorev",
+ ),
+ },
+ r: mksolution(
+ "a 1.0.0",
+ "b 1.0.0 foorev",
+ ),
+ },
+ // Preferred versions can only work if the thing offering it has been
+ // selected, or at least marked in the unselected queue
+ "prefv only works if depper is selected": {
+ ds: []depspec{
+ dsp(mkDepspec("root 0.0.0"),
+ pkg("root", "a", "b")),
+ // Three atoms for a, which will mean it gets visited after b
+ dsp(mkDepspec("a 1.0.0"),
+ pkg("a", "b")),
+ dsp(mkDepspec("a 1.0.1"),
+ pkg("a", "b")),
+ dsp(mkDepspec("a 1.1.0"),
+ pkg("a", "b")),
+ dsp(mkDepspec("b 1.0.0 foorev"),
+ pkg("b")),
+ dsp(mkDepspec("b 2.0.0 barrev"),
+ pkg("b")),
+ },
+ lm: map[string]fixLock{
+ "a 1.0.0": mklock(
+ "b 1.0.0 foorev",
+ ),
+ },
+ r: mksolution(
+ "a 1.1.0",
+ "b 2.0.0 barrev",
+ ),
+ },
+}
+
+// tpkg is a representation of a single package. It has its own import path, as
+// well as a list of paths it itself "imports".
+type tpkg struct {
+ // Full import path of this package
+ path string
+ // Slice of full paths to its virtual imports
+ imports []string
+}
+
+type bimodalFixture struct {
+ // name of this fixture datum
+ n string
+ // bimodal project. first is always treated as root project
+ ds []depspec
+ // results; map of name/version pairs
+ r map[string]Version
+ // max attempts the solver should need to find solution. 0 means no limit
+ maxAttempts int
+ // Use downgrade instead of default upgrade sorter
+ downgrade bool
+ // lock file simulator, if one's to be used at all
+ l fixLock
+ // map of locks for deps, if any. keys should be of the form:
+ // "<project> <version>"
+ lm map[string]fixLock
+ // projects expected to have errors, if any
+ errp []string
+ // request up/downgrade to all projects
+ changeall bool
+ // pkgs to ignore
+ ignore []string
+}
+
+func (f bimodalFixture) name() string {
+ return f.n
+}
+
+func (f bimodalFixture) specs() []depspec {
+ return f.ds
+}
+
+func (f bimodalFixture) maxTries() int {
+ return f.maxAttempts
+}
+
+func (f bimodalFixture) expectErrs() []string {
+ return f.errp
+}
+
+func (f bimodalFixture) solution() map[string]Version {
+ return f.r
+}
+
+// bmSourceManager is an SM specifically for the bimodal fixtures. It composes
+// the general depspec SM, and differs from it in how it answers static analysis
+// calls, and its support for package ignores and dep lock data.
+type bmSourceManager struct {
+ depspecSourceManager
+ lm map[string]fixLock
+}
+
+var _ SourceManager = &bmSourceManager{}
+
+func newbmSM(bmf bimodalFixture) *bmSourceManager {
+ sm := &bmSourceManager{
+ depspecSourceManager: *newdepspecSM(bmf.ds, bmf.ignore),
+ }
+ sm.rm = computeBimodalExternalMap(bmf.ds)
+ sm.lm = bmf.lm
+
+ return sm
+}
+
+func (sm *bmSourceManager) ListPackages(n ProjectRoot, v Version) (PackageTree, error) {
+ for k, ds := range sm.specs {
+ // Cheat for root, otherwise we blow up b/c version is empty
+ if n == ds.n && (k == 0 || ds.v.Matches(v)) {
+ ptree := PackageTree{
+ ImportRoot: string(n),
+ Packages: make(map[string]PackageOrErr),
+ }
+ for _, pkg := range ds.pkgs {
+ ptree.Packages[pkg.path] = PackageOrErr{
+ P: Package{
+ ImportPath: pkg.path,
+ Name: filepath.Base(pkg.path),
+ Imports: pkg.imports,
+ },
+ }
+ }
+
+ return ptree, nil
+ }
+ }
+
+ return PackageTree{}, fmt.Errorf("Project %s at version %s could not be found", n, v)
+}
+
+func (sm *bmSourceManager) GetProjectInfo(n ProjectRoot, v Version) (Manifest, Lock, error) {
+ for _, ds := range sm.specs {
+ if n == ds.n && v.Matches(ds.v) {
+ if l, exists := sm.lm[string(n)+" "+v.String()]; exists {
+ return ds, l, nil
+ }
+ return ds, dummyLock{}, nil
+ }
+ }
+
+ // TODO(sdboyer) proper solver-type errors
+ return nil, nil, fmt.Errorf("Project %s at version %s could not be found", n, v)
+}
+
+// computeBimodalExternalMap takes a set of depspecs and computes an
+// internally-versioned external reach map that is useful for quickly answering
+// ListExternal()-type calls.
+//
+// Note that it does not do things like stripping out stdlib packages - these
+// maps are intended for use in SM fixtures, and that's a higher-level
+// responsibility within the system.
+func computeBimodalExternalMap(ds []depspec) map[pident]map[string][]string {
+ // map of project name+version -> map of subpkg name -> external pkg list
+ rm := make(map[pident]map[string][]string)
+
+ // algorithm adapted from externalReach()
+ for _, d := range ds {
+ // Keeps a list of all internal and external reaches for packages within
+ // a given root. We create one on each pass through, rather than doing
+ // them all at once, because the depspec set may (read: is expected to)
+ // have multiple versions of the same base project, and each of those
+ // must be calculated independently.
+ workmap := make(map[string]wm)
+
+ for _, pkg := range d.pkgs {
+ if !checkPrefixSlash(filepath.Clean(pkg.path), string(d.n)) {
+ panic(fmt.Sprintf("pkg %s is not a child of %s, cannot be a part of that project", pkg.path, d.n))
+ }
+
+ w := wm{
+ ex: make(map[string]bool),
+ in: make(map[string]bool),
+ }
+
+ for _, imp := range pkg.imports {
+ if !checkPrefixSlash(filepath.Clean(imp), string(d.n)) {
+ // Easy case - if the import is not a child of the base
+ // project path, put it in the external map
+ w.ex[imp] = true
+ } else {
+ if w2, seen := workmap[imp]; seen {
+ // If it is, and we've seen that path, dereference it
+ // immediately
+ for i := range w2.ex {
+ w.ex[i] = true
+ }
+ for i := range w2.in {
+ w.in[i] = true
+ }
+ } else {
+ // Otherwise, put it in the 'in' map for later
+ // reprocessing
+ w.in[imp] = true
+ }
+ }
+ }
+ workmap[pkg.path] = w
+ }
+
+ drm := wmToReach(workmap, "")
+ rm[pident{n: d.n, v: d.v}] = drm
+ }
+
+ return rm
+}
diff --git a/vendor/github.com/sdboyer/gps/solve_test.go b/vendor/github.com/sdboyer/gps/solve_test.go
new file mode 100644
index 0000000..95db023
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/solve_test.go
@@ -0,0 +1,440 @@
+package gps
+
+import (
+ "flag"
+ "fmt"
+ "io/ioutil"
+ "log"
+ "math/rand"
+ "os"
+ "reflect"
+ "sort"
+ "strconv"
+ "strings"
+ "testing"
+)
+
+var fixtorun string
+
+// 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")
+ overrideMkBridge()
+}
+
+// sets the mkBridge global func to one that allows virtualized RootDirs
+func overrideMkBridge() {
+ // For all tests, override the base bridge with the depspecBridge that skips
+ // verifyRootDir calls
+ mkBridge = func(s *solver, sm SourceManager) sourceBridge {
+ return &depspecBridge{
+ &bridge{
+ sm: sm,
+ s: s,
+ vlists: make(map[ProjectRoot][]Version),
+ },
+ }
+ }
+}
+
+var stderrlog = log.New(os.Stderr, "", 0)
+
+func fixSolve(params SolveParameters, sm SourceManager) (Solution, error) {
+ if testing.Verbose() {
+ params.Trace = true
+ params.TraceLogger = stderrlog
+ }
+
+ s, err := Prepare(params, sm)
+ if err != nil {
+ return nil, err
+ }
+
+ return s.Solve()
+}
+
+// Test all the basic table fixtures.
+//
+// Or, just the one named in the fix arg.
+func TestBasicSolves(t *testing.T) {
+ if fixtorun != "" {
+ if fix, exists := basicFixtures[fixtorun]; exists {
+ solveBasicsAndCheck(fix, t)
+ }
+ } else {
+ // sort them by their keys so we get stable output
+ var names []string
+ for n := range basicFixtures {
+ names = append(names, n)
+ }
+
+ sort.Strings(names)
+ for _, n := range names {
+ solveBasicsAndCheck(basicFixtures[n], t)
+ if testing.Verbose() {
+ // insert a line break between tests
+ stderrlog.Println("")
+ }
+ }
+ }
+}
+
+func solveBasicsAndCheck(fix basicFixture, t *testing.T) (res Solution, err error) {
+ if testing.Verbose() {
+ stderrlog.Printf("[[fixture %q]]", fix.n)
+ }
+ sm := newdepspecSM(fix.ds, nil)
+
+ params := SolveParameters{
+ RootDir: string(fix.ds[0].n),
+ ImportRoot: ProjectRoot(fix.ds[0].n),
+ Manifest: fix.ds[0],
+ Lock: dummyLock{},
+ Downgrade: fix.downgrade,
+ ChangeAll: fix.changeall,
+ }
+
+ if fix.l != nil {
+ params.Lock = fix.l
+ }
+
+ res, err = fixSolve(params, sm)
+
+ return fixtureSolveSimpleChecks(fix, res, err, t)
+}
+
+// Test all the bimodal table fixtures.
+//
+// Or, just the one named in the fix arg.
+func TestBimodalSolves(t *testing.T) {
+ if fixtorun != "" {
+ if fix, exists := bimodalFixtures[fixtorun]; exists {
+ solveBimodalAndCheck(fix, t)
+ }
+ } else {
+ // sort them by their keys so we get stable output
+ var names []string
+ for n := range bimodalFixtures {
+ names = append(names, n)
+ }
+
+ sort.Strings(names)
+ for _, n := range names {
+ solveBimodalAndCheck(bimodalFixtures[n], t)
+ if testing.Verbose() {
+ // insert a line break between tests
+ stderrlog.Println("")
+ }
+ }
+ }
+}
+
+func solveBimodalAndCheck(fix bimodalFixture, t *testing.T) (res Solution, err error) {
+ if testing.Verbose() {
+ stderrlog.Printf("[[fixture %q]]", fix.n)
+ }
+ sm := newbmSM(fix)
+
+ params := SolveParameters{
+ RootDir: string(fix.ds[0].n),
+ ImportRoot: ProjectRoot(fix.ds[0].n),
+ Manifest: fix.ds[0],
+ Lock: dummyLock{},
+ Ignore: fix.ignore,
+ Downgrade: fix.downgrade,
+ ChangeAll: fix.changeall,
+ }
+
+ if fix.l != nil {
+ params.Lock = fix.l
+ }
+
+ res, err = fixSolve(params, sm)
+
+ return fixtureSolveSimpleChecks(fix, res, err, t)
+}
+
+func fixtureSolveSimpleChecks(fix specfix, res Solution, err error, t *testing.T) (Solution, error) {
+ if err != nil {
+ errp := fix.expectErrs()
+ if len(errp) == 0 {
+ t.Errorf("(fixture: %q) Solver failed; error was type %T, text:\n%s", fix.name(), err, err)
+ return res, err
+ }
+
+ switch fail := err.(type) {
+ case *badOptsFailure:
+ t.Errorf("(fixture: %q) Unexpected bad opts failure solve error: %s", fix.name(), err)
+ case *noVersionError:
+ if errp[0] != string(fail.pn.ProjectRoot) { // TODO(sdboyer) identifierify
+ t.Errorf("(fixture: %q) Expected failure on project %s, but was on project %s", fix.name(), errp[0], fail.pn.ProjectRoot)
+ }
+
+ ep := make(map[string]struct{})
+ for _, p := range errp[1:] {
+ ep[p] = struct{}{}
+ }
+
+ found := make(map[string]struct{})
+ for _, vf := range fail.fails {
+ for _, f := range getFailureCausingProjects(vf.f) {
+ found[f] = struct{}{}
+ }
+ }
+
+ var missing []string
+ var extra []string
+ for p := range found {
+ if _, has := ep[p]; !has {
+ extra = append(extra, p)
+ }
+ }
+ if len(extra) > 0 {
+ t.Errorf("(fixture: %q) Expected solve failures due to projects %s, but solve failures also arose from %s", fix.name(), strings.Join(errp[1:], ", "), strings.Join(extra, ", "))
+ }
+
+ for p := range ep {
+ if _, has := found[p]; !has {
+ missing = append(missing, p)
+ }
+ }
+ if len(missing) > 0 {
+ t.Errorf("(fixture: %q) Expected solve failures due to projects %s, but %s had no failures", fix.name(), strings.Join(errp[1:], ", "), strings.Join(missing, ", "))
+ }
+
+ default:
+ // TODO(sdboyer) round these out
+ panic(fmt.Sprintf("unhandled solve failure type: %s", err))
+ }
+ } else if len(fix.expectErrs()) > 0 {
+ t.Errorf("(fixture: %q) Solver succeeded, but expected failure", fix.name())
+ } else {
+ r := res.(solution)
+ if fix.maxTries() > 0 && r.Attempts() > fix.maxTries() {
+ t.Errorf("(fixture: %q) Solver completed in %v attempts, but expected %v or fewer", fix.name(), r.att, fix.maxTries())
+ }
+
+ // Dump result projects into a map for easier interrogation
+ rp := make(map[string]Version)
+ for _, p := range r.p {
+ pa := p.toAtom()
+ rp[string(pa.id.ProjectRoot)] = pa.v
+ }
+
+ fixlen, rlen := len(fix.solution()), len(rp)
+ if fixlen != rlen {
+ // Different length, so they definitely disagree
+ t.Errorf("(fixture: %q) Solver reported %v package results, result expected %v", fix.name(), rlen, fixlen)
+ }
+
+ // Whether or not len is same, still have to verify that results agree
+ // Walk through fixture/expected results first
+ for p, v := range fix.solution() {
+ if av, exists := rp[p]; !exists {
+ t.Errorf("(fixture: %q) Project %q expected but missing from results", fix.name(), p)
+ } else {
+ // 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, p, av)
+ }
+ }
+ }
+
+ // Now walk through remaining actual results
+ for p, v := range rp {
+ if fv, exists := fix.solution()[p]; !exists {
+ t.Errorf("(fixture: %q) Unexpected project %q present in results", fix.name(), p)
+ } else if v != fv {
+ t.Errorf("(fixture: %q) Got version %q of project %q, but expected version was %q", fix.name(), v, p, fv)
+ }
+ }
+ }
+
+ return res, err
+}
+
+// This tests that, when a root lock is underspecified (has only a version) we
+// don't allow a match on that version from a rev in the manifest. We may allow
+// this in the future, but disallow it for now because going from an immutable
+// requirement to a mutable lock automagically is a bad direction that could
+// produce weird side effects.
+func TestRootLockNoVersionPairMatching(t *testing.T) {
+ fix := basicFixture{
+ n: "does not pair bare revs in manifest with unpaired lock version",
+ ds: []depspec{
+ mkDepspec("root 0.0.0", "foo *"), // foo's constraint rewritten below to foorev
+ mkDepspec("foo 1.0.0", "bar 1.0.0"),
+ mkDepspec("foo 1.0.1 foorev", "bar 1.0.1"),
+ mkDepspec("foo 1.0.2 foorev", "bar 1.0.2"),
+ mkDepspec("bar 1.0.0"),
+ mkDepspec("bar 1.0.1"),
+ mkDepspec("bar 1.0.2"),
+ },
+ l: mklock(
+ "foo 1.0.1",
+ ),
+ r: mksolution(
+ "foo 1.0.2 foorev",
+ "bar 1.0.1",
+ ),
+ }
+
+ pd := fix.ds[0].deps[0]
+ pd.Constraint = Revision("foorev")
+ fix.ds[0].deps[0] = pd
+
+ sm := newdepspecSM(fix.ds, nil)
+
+ l2 := make(fixLock, 1)
+ copy(l2, fix.l)
+ l2[0].v = nil
+
+ params := SolveParameters{
+ RootDir: string(fix.ds[0].n),
+ ImportRoot: ProjectRoot(fix.ds[0].n),
+ Manifest: fix.ds[0],
+ Lock: l2,
+ }
+
+ res, err := fixSolve(params, sm)
+
+ fixtureSolveSimpleChecks(fix, res, err, t)
+}
+
+func getFailureCausingProjects(err error) (projs []string) {
+ switch e := err.(type) {
+ case *noVersionError:
+ projs = append(projs, string(e.pn.ProjectRoot)) // TODO(sdboyer) identifierify
+ case *disjointConstraintFailure:
+ for _, f := range e.failsib {
+ projs = append(projs, string(f.depender.id.ProjectRoot))
+ }
+ case *versionNotAllowedFailure:
+ for _, f := range e.failparent {
+ projs = append(projs, string(f.depender.id.ProjectRoot))
+ }
+ case *constraintNotAllowedFailure:
+ // No sane way of knowing why the currently selected version is
+ // selected, so do nothing
+ case *sourceMismatchFailure:
+ projs = append(projs, string(e.prob.id.ProjectRoot))
+ for _, c := range e.sel {
+ projs = append(projs, string(c.depender.id.ProjectRoot))
+ }
+ case *checkeeHasProblemPackagesFailure:
+ projs = append(projs, string(e.goal.id.ProjectRoot))
+ for _, errdep := range e.failpkg {
+ for _, atom := range errdep.deppers {
+ projs = append(projs, string(atom.id.ProjectRoot))
+ }
+ }
+ case *depHasProblemPackagesFailure:
+ projs = append(projs, string(e.goal.depender.id.ProjectRoot), string(e.goal.dep.Ident.ProjectRoot))
+ case *nonexistentRevisionFailure:
+ projs = append(projs, string(e.goal.depender.id.ProjectRoot), string(e.goal.dep.Ident.ProjectRoot))
+ default:
+ panic(fmt.Sprintf("unknown failtype %T, msg: %s", err, err))
+ }
+
+ return
+}
+
+func TestBadSolveOpts(t *testing.T) {
+ pn := strconv.FormatInt(rand.Int63(), 36)
+ fix := basicFixtures["no dependencies"]
+ fix.ds[0].n = ProjectRoot(pn)
+
+ sm := newdepspecSM(fix.ds, nil)
+ params := SolveParameters{}
+
+ _, err := Prepare(params, nil)
+ if err == nil {
+ t.Errorf("Prepare should have errored on nil SourceManager")
+ } else if !strings.Contains(err.Error(), "non-nil SourceManager") {
+ t.Error("Prepare should have given error on nil SourceManager, but gave:", err)
+ }
+
+ _, err = Prepare(params, sm)
+ if err == nil {
+ t.Errorf("Prepare should have errored on empty root")
+ } else if !strings.Contains(err.Error(), "non-empty root directory") {
+ t.Error("Prepare should have given error on empty root, but gave:", err)
+ }
+
+ params.RootDir = pn
+ _, err = Prepare(params, sm)
+ if err == nil {
+ t.Errorf("Prepare should have errored on empty name")
+ } else if !strings.Contains(err.Error(), "non-empty import root") {
+ t.Error("Prepare should have given error on empty import root, but gave:", err)
+ }
+
+ params.ImportRoot = ProjectRoot(pn)
+ params.Trace = true
+ _, err = Prepare(params, sm)
+ if err == nil {
+ t.Errorf("Should have errored on trace with no logger")
+ } else if !strings.Contains(err.Error(), "no logger provided") {
+ t.Error("Prepare should have given error on missing trace logger, but gave:", err)
+ }
+
+ params.TraceLogger = log.New(ioutil.Discard, "", 0)
+ _, err = Prepare(params, sm)
+ if err != nil {
+ t.Error("Basic conditions satisfied, prepare should have completed successfully, err as:", err)
+ }
+
+ // swap out the test mkBridge override temporarily, just to make sure we get
+ // the right error
+ mkBridge = func(s *solver, sm SourceManager) sourceBridge {
+ return &bridge{
+ sm: sm,
+ s: s,
+ vlists: make(map[ProjectRoot][]Version),
+ }
+ }
+
+ _, err = Prepare(params, sm)
+ if err == nil {
+ t.Errorf("Should have errored on nonexistent root")
+ } else if !strings.Contains(err.Error(), "could not read project root") {
+ t.Error("Prepare should have given error nonexistent project root dir, but gave:", err)
+ }
+
+ // Pointing it at a file should also be an err
+ params.RootDir = "solve_test.go"
+ _, err = Prepare(params, sm)
+ if err == nil {
+ t.Errorf("Should have errored on file for RootDir")
+ } else if !strings.Contains(err.Error(), "is a file, not a directory") {
+ t.Error("Prepare should have given error on file as RootDir, but gave:", err)
+ }
+
+ // swap them back...not sure if this matters, but just in case
+ overrideMkBridge()
+}
+
+func TestIgnoreDedupe(t *testing.T) {
+ fix := basicFixtures["no dependencies"]
+
+ ig := []string{"foo", "foo", "bar"}
+ params := SolveParameters{
+ RootDir: string(fix.ds[0].n),
+ ImportRoot: ProjectRoot(fix.ds[0].n),
+ Manifest: fix.ds[0],
+ Ignore: ig,
+ }
+
+ s, _ := Prepare(params, newdepspecSM(basicFixtures["no dependencies"].ds, nil))
+ ts := s.(*solver)
+
+ expect := map[string]bool{
+ "foo": true,
+ "bar": true,
+ }
+
+ if !reflect.DeepEqual(ts.ig, expect) {
+ t.Errorf("Expected solver's ignore list to be deduplicated map, got %v", ts.ig)
+ }
+}
diff --git a/vendor/github.com/sdboyer/gps/solver.go b/vendor/github.com/sdboyer/gps/solver.go
new file mode 100644
index 0000000..121bc81
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/solver.go
@@ -0,0 +1,1246 @@
+package gps
+
+import (
+ "container/heap"
+ "fmt"
+ "log"
+ "os"
+ "sort"
+ "strings"
+
+ "github.com/armon/go-radix"
+)
+
+// SolveParameters hold all arguments to a solver run.
+//
+// Only RootDir and ImportRoot are absolutely required. A nil Manifest is
+// allowed, though it usually makes little sense.
+//
+// Of these properties, only Manifest and Ignore are (directly) incorporated in
+// memoization hashing.
+type SolveParameters struct {
+ // The path to the root of the project on which the solver should operate.
+ // This should point to the directory that should contain the vendor/
+ // directory.
+ //
+ // In general, it is wise for this to be under an active GOPATH, though it
+ // is not (currently) required.
+ //
+ // 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:
+ //
+ // github.com/sdboyer/gps
+ //
+ // 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 root manifest. This contains all the dependencies, constraints, and
+ // other controls available to the root project.
+ //
+ // May be nil, but for most cases, that would be unwise.
+ Manifest Manifest
+
+ // The root lock. Optional. Generally, this lock is the output of a previous
+ // solve run.
+ //
+ // If provided, the solver will attempt to preserve the versions specified
+ // in the lock, unless ToChange or ChangeAll settings indicate otherwise.
+ Lock Lock
+
+ // A list of packages (import paths) to ignore. These can be in the root
+ // project, or from elsewhere. Ignoring a package means that both it and its
+ // imports will be disregarded by all relevant solver operations.
+ Ignore []string
+
+ // ToChange is a list of project names that should be changed - that is, any
+ // versions specified for those projects in the root lock file should be
+ // ignored.
+ //
+ // Passing ChangeAll has subtly different behavior from enumerating all
+ // projects into ToChange. In general, ToChange should *only* be used if the
+ // user expressly requested an upgrade for a specific project.
+ ToChange []ProjectRoot
+
+ // ChangeAll indicates that all projects should be changed - that is, any
+ // versions specified in the root lock file should be ignored.
+ ChangeAll bool
+
+ // Downgrade indicates whether the solver will attempt to upgrade (false) or
+ // downgrade (true) projects that are not locked, or are marked for change.
+ //
+ // Upgrading is, by far, the most typical case. The field is named
+ // 'Downgrade' so that the bool's zero value corresponds to that most
+ // typical case.
+ Downgrade bool
+
+ // Trace controls whether the solver will generate informative trace output
+ // as it moves through the solving process.
+ Trace bool
+
+ // TraceLogger is the logger to use for generating trace output. If Trace is
+ // true but no logger is provided, solving will result in an error.
+ TraceLogger *log.Logger
+}
+
+// solver is a CDCL-style SAT solver with satisfiability conditions hardcoded to
+// the needs of the Go package management problem space.
+type solver struct {
+ // The current number of attempts made over the course of this solve. This
+ // number increments each time the algorithm completes a backtrack and
+ // starts moving forward again.
+ attempts int
+
+ // SolveParameters are the inputs to the solver. They determine both what
+ // data the solver should operate on, and certain aspects of how solving
+ // proceeds.
+ //
+ // Prepare() validates these, so by the time we have a *solver instance, we
+ // know they're valid.
+ params SolveParameters
+
+ // Logger used exclusively for trace output, if the trace option is set.
+ tl *log.Logger
+
+ // A bridge to the standard SourceManager. The adapter does some local
+ // caching of pre-sorted version lists, as well as translation between the
+ // full-on ProjectIdentifiers that the solver deals with and the simplified
+ // names a SourceManager operates on.
+ b sourceBridge
+
+ // A stack containing projects and packages that are currently "selected" -
+ // that is, they have passed all satisfiability checks, and are part of the
+ // current solution.
+ //
+ // The *selection type is mostly just a dumb data container; the solver
+ // itself is responsible for maintaining that invariant.
+ sel *selection
+
+ // The current list of projects that we need to incorporate into the solution in
+ // order for the solution to be complete. This list is implemented as a
+ // priority queue that places projects least likely to induce errors at the
+ // front, in order to minimize the amount of backtracking required to find a
+ // solution.
+ //
+ // Entries are added to and removed from this list by the solver at the same
+ // time that the selected queue is updated, either with an addition or
+ // removal.
+ unsel *unselected
+
+ // Map of packages to ignore. Derived by converting SolveParameters.Ignore
+ // into a map during solver prep - which also, nicely, deduplicates it.
+ ig map[string]bool
+
+ // A stack of all the currently active versionQueues in the solver. The set
+ // of projects represented here corresponds closely to what's in s.sel,
+ // although s.sel will always contain the root project, and s.vqs never
+ // will. Also, s.vqs is only added to (or popped from during backtracking)
+ // when a new project is selected; it is untouched when new packages are
+ // added to an existing project.
+ vqs []*versionQueue
+
+ // A map of the ProjectRoot (local names) that should be allowed to change
+ chng map[ProjectRoot]struct{}
+
+ // A map of the ProjectRoot (local names) that are currently selected, and
+ // the network name to which they currently correspond.
+ names map[ProjectRoot]string
+
+ // A map of the names listed in the root's lock.
+ rlm map[ProjectIdentifier]LockedProject
+
+ // A normalized, copied version of the root manifest.
+ rm Manifest
+
+ // A normalized, copied version of the root lock.
+ rl Lock
+}
+
+// A Solver is the main workhorse of gps: given a set of project inputs, it
+// performs a constraint solving analysis to develop a complete Result that can
+// be used as a lock file, and to populate a vendor directory.
+type Solver interface {
+ HashInputs() ([]byte, error)
+ Solve() (Solution, error)
+}
+
+// Prepare readies a Solver for use.
+//
+// This function reads and validates the provided SolveParameters. If a problem
+// with the inputs is detected, an error is returned. Otherwise, a Solver is
+// returned, ready to hash and check inputs or perform a solving run.
+func Prepare(params SolveParameters, sm SourceManager) (Solver, error) {
+ // local overrides would need to be handled first.
+ // TODO(sdboyer) local overrides! heh
+
+ if sm == nil {
+ return nil, badOptsFailure("must provide non-nil SourceManager")
+ }
+ if params.RootDir == "" {
+ return nil, badOptsFailure("params must specify a non-empty root directory")
+ }
+ if params.ImportRoot == "" {
+ return nil, badOptsFailure("params must include a non-empty import root")
+ }
+ if params.Trace && params.TraceLogger == nil {
+ return nil, badOptsFailure("trace requested, but no logger provided")
+ }
+
+ if params.Manifest == nil {
+ params.Manifest = SimpleManifest{}
+ }
+
+ // Ensure the ignore map is at least initialized
+ ig := make(map[string]bool)
+ if len(params.Ignore) > 0 {
+ for _, pkg := range params.Ignore {
+ ig[pkg] = true
+ }
+ }
+
+ s := &solver{
+ params: params,
+ ig: ig,
+ tl: params.TraceLogger,
+ }
+
+ // Set up the bridge and ensure the root dir is in good, working order
+ // before doing anything else. (This call is stubbed out in tests, via
+ // overriding mkBridge(), so we can run with virtual RootDir.)
+ s.b = mkBridge(s, sm)
+ err := s.b.verifyRootDir(s.params.RootDir)
+ if err != nil {
+ return nil, err
+ }
+
+ // Initialize maps
+ s.chng = make(map[ProjectRoot]struct{})
+ s.rlm = make(map[ProjectIdentifier]LockedProject)
+ s.names = make(map[ProjectRoot]string)
+
+ for _, v := range s.params.ToChange {
+ s.chng[v] = struct{}{}
+ }
+
+ // Initialize stacks and queues
+ s.sel = &selection{
+ deps: make(map[ProjectIdentifier][]dependency),
+ sm: s.b,
+ }
+ s.unsel = &unselected{
+ sl: make([]bimodalIdentifier, 0),
+ cmp: s.unselectedComparator,
+ }
+
+ // Prep safe, normalized versions of root manifest and lock data
+ s.rm = prepManifest(s.params.Manifest)
+ if s.params.Lock != nil {
+ for _, lp := range s.params.Lock.Projects() {
+ s.rlm[lp.Ident().normalize()] = lp
+ }
+
+ // Also keep a prepped one, mostly for the bridge. This is probably
+ // wasteful, but only minimally so, and yay symmetry
+ s.rl = prepLock(s.params.Lock)
+ }
+
+ return s, nil
+}
+
+// Solve attempts to find a dependency solution for the given project, as
+// represented by the SolveParameters with which this Solver was created.
+//
+// This is the entry point to the main gps workhorse.
+func (s *solver) Solve() (Solution, error) {
+ // Prime the queues with the root project
+ err := s.selectRoot()
+ if err != nil {
+ // TODO(sdboyer) this properly with errs, yar
+ return nil, err
+ }
+
+ // Log initial step
+ s.logSolve()
+ all, err := s.solve()
+
+ // Solver finished with an err; return that and we're done
+ if err != nil {
+ return nil, err
+ }
+
+ r := solution{
+ att: s.attempts,
+ }
+
+ // An err here is impossible at this point; we already know the root tree is
+ // fine
+ r.hd, _ = s.HashInputs()
+
+ // Convert ProjectAtoms into LockedProjects
+ r.p = make([]LockedProject, len(all))
+ k := 0
+ for pa, pl := range all {
+ r.p[k] = pa2lp(pa, pl)
+ k++
+ }
+
+ return r, nil
+}
+
+// solve is the top-level loop for the SAT solving process.
+func (s *solver) solve() (map[atom]map[string]struct{}, error) {
+ // Main solving loop
+ for {
+ bmi, has := s.nextUnselected()
+
+ if !has {
+ // no more packages to select - we're done.
+ break
+ }
+
+ // This split is the heart of "bimodal solving": we follow different
+ // 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 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.
+ s.logStart(bmi)
+ queue, err := s.createVersionQueue(bmi)
+ if err != nil {
+ // Err means a failure somewhere down the line; try backtracking.
+ if s.backtrack() {
+ // backtracking succeeded, move to the next unselected id
+ continue
+ }
+ return nil, err
+ }
+
+ if queue.current() == nil {
+ panic("canary - queue is empty, but flow indicates success")
+ }
+
+ s.selectAtomWithPackages(atomWithPackages{
+ a: atom{
+ id: queue.id,
+ v: queue.current(),
+ },
+ pl: bmi.pl,
+ })
+ s.vqs = append(s.vqs, queue)
+ s.logSolve()
+ } else {
+ // We're just trying to add packages to an already-selected project.
+ // That means it's not OK to burn through the version queue for that
+ // project as we do when first selecting a project, as doing so
+ // would upend the guarantees on which all previous selections of
+ // the project are based (both the initial one, and any package-only
+ // ones).
+
+ // Because we can only safely operate within the scope of the
+ // single, currently selected version, we can skip looking for the
+ // queue and just use the version given in what came back from
+ // s.sel.selected().
+ nawp := atomWithPackages{
+ a: atom{
+ id: bmi.id,
+ v: awp.a.v,
+ },
+ pl: bmi.pl,
+ }
+
+ s.logStart(bmi) // TODO(sdboyer) different special start logger for this path
+ err := s.checkPackage(nawp)
+ if err != nil {
+ // Err means a failure somewhere down the line; try backtracking.
+ if s.backtrack() {
+ // backtracking succeeded, move to the next unselected id
+ continue
+ }
+ return nil, err
+ }
+ s.selectPackages(nawp)
+ // We don't add anything to the stack of version queues because the
+ // backtracker knows not to pop the vqstack if it backtracks
+ // across a pure-package addition.
+ s.logSolve()
+ }
+ }
+
+ // Getting this far means we successfully found a solution. Combine the
+ // selected projects and packages.
+ projs := make(map[atom]map[string]struct{})
+
+ // Skip the first project. It's always the root, and that shouldn't be
+ // included in results.
+ for _, sel := range s.sel.projects[1:] {
+ pm, exists := projs[sel.a.a]
+ if !exists {
+ pm = make(map[string]struct{})
+ projs[sel.a.a] = pm
+ }
+
+ for _, path := range sel.a.pl {
+ pm[path] = struct{}{}
+ }
+ }
+ return projs, nil
+}
+
+// selectRoot is a specialized selectAtomWithPackages, used solely to initially
+// populate the queues at the beginning of a solve run.
+func (s *solver) selectRoot() error {
+ pa := atom{
+ id: ProjectIdentifier{
+ ProjectRoot: s.params.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.
+ // We may need a more elegant solution if we discover other side
+ // effects, though.
+ v: Revision(""),
+ }
+
+ ptree, err := s.b.listPackages(pa.id, nil)
+ if err != nil {
+ return err
+ }
+
+ list := make([]string, len(ptree.Packages))
+ k := 0
+ for path := range ptree.Packages {
+ list[k] = path
+ k++
+ }
+
+ a := atomWithPackages{
+ a: pa,
+ pl: list,
+ }
+
+ // Push the root project onto the queue.
+ // TODO(sdboyer) maybe it'd just be better to skip this?
+ s.sel.pushSelection(a, true)
+
+ // If we're looking for root's deps, get it from opts and local root
+ // analysis, rather than having the sm do it
+ mdeps := append(s.rm.DependencyConstraints(), s.rm.TestDependencyConstraints()...)
+
+ // 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()
+
+ deps, err := s.intersectConstraintsWithImports(mdeps, reach)
+ if err != nil {
+ // TODO(sdboyer) this could well happen; handle it with a more graceful error
+ panic(fmt.Sprintf("shouldn't be possible %s", err))
+ }
+
+ for _, dep := range deps {
+ s.sel.pushDep(dependency{depender: pa, dep: dep})
+ // Add all to unselected queue
+ s.names[dep.Ident.ProjectRoot] = dep.Ident.netName()
+ heap.Push(s.unsel, bimodalIdentifier{id: dep.Ident, pl: dep.pl, fromRoot: true})
+ }
+
+ return nil
+}
+
+func (s *solver) getImportsAndConstraintsOf(a atomWithPackages) ([]completeDep, error) {
+ var err error
+
+ if s.params.ImportRoot == a.a.id.ProjectRoot {
+ panic("Should never need to recheck imports/constraints from root during solve")
+ }
+
+ // Work through the source manager to get project info and static analysis
+ // information.
+ m, _, err := s.b.getProjectInfo(a.a)
+ if err != nil {
+ return nil, err
+ }
+
+ ptree, err := s.b.listPackages(a.a.id, a.a.v)
+ if err != nil {
+ return nil, err
+ }
+
+ allex := ptree.ExternalReach(false, false, s.ig)
+ // Use a map to dedupe the unique external packages
+ exmap := make(map[string]struct{})
+ // Add the packages reached by the packages explicitly listed in the atom to
+ // the list
+ for _, pkg := range a.pl {
+ expkgs, exists := allex[pkg]
+ if !exists {
+ // missing package here *should* only happen if the target pkg was
+ // poisoned somehow - check the original ptree.
+ if perr, exists := ptree.Packages[pkg]; exists {
+ if perr.Err != nil {
+ return nil, fmt.Errorf("package %s has errors: %s", pkg, perr.Err)
+ }
+ return nil, fmt.Errorf("package %s depends on some other package within %s with errors", pkg, a.a.id.errString())
+ }
+ // Nope, it's actually not there. This shouldn't happen.
+ return nil, fmt.Errorf("package %s does not exist within project %s", pkg, a.a.id.errString())
+ }
+
+ for _, ex := range expkgs {
+ exmap[ex] = struct{}{}
+ }
+ }
+
+ reach := make([]string, len(exmap))
+ k := 0
+ for pkg := range exmap {
+ reach[k] = pkg
+ k++
+ }
+
+ deps := m.DependencyConstraints()
+ // TODO(sdboyer) add overrides here...if we impl the concept (which we should)
+
+ return s.intersectConstraintsWithImports(deps, reach)
+}
+
+// intersectConstraintsWithImports takes a list of constraints and a list of
+// externally reached packages, and creates a []completeDep that is guaranteed
+// to include all packages named by import reach, using constraints where they
+// are available, or Any() where they are not.
+func (s *solver) intersectConstraintsWithImports(deps []ProjectConstraint, reach []string) ([]completeDep, error) {
+ // Create a radix tree with all the projects we know from the manifest
+ // TODO(sdboyer) make this smarter once we allow non-root inputs as 'projects'
+ xt := radix.New()
+ for _, dep := range deps {
+ xt.Insert(string(dep.Ident.ProjectRoot), dep)
+ }
+
+ // Step through the reached packages; if they have prefix matches in
+ // the trie, assume (mostly) it's a correct correspondence.
+ dmap := make(map[ProjectRoot]completeDep)
+ for _, rp := range reach {
+ // If it's a stdlib package, skip it.
+ // TODO(sdboyer) this just hardcodes us to the packages in tip - should we
+ // have go version magic here, too?
+ if stdlib[rp] {
+ continue
+ }
+
+ // Look for a prefix match; it'll be the root project/repo containing
+ // the reached package
+ if k, idep, match := xt.LongestPrefix(rp); match {
+ // The radix tree gets it mostly right, but we have to guard against
+ // possibilities like this:
+ //
+ // github.com/sdboyer/foo
+ // github.com/sdboyer/foobar/baz
+ //
+ // The latter would incorrectly be conflated in with the former. So,
+ // as we know we're operating on strings that describe paths, guard
+ // against this case by verifying that either the input is the same
+ // length as the match (in which case we know they're equal), or
+ // that the next character is the is the PathSeparator.
+ if len(k) == len(rp) || strings.IndexRune(rp[:len(k)], os.PathSeparator) == 0 {
+ // Match is valid; put it in the dmap, either creating a new
+ // completeDep or appending it to the existing one for this base
+ // project/prefix.
+ dep := idep.(ProjectConstraint)
+ if cdep, exists := dmap[dep.Ident.ProjectRoot]; exists {
+ cdep.pl = append(cdep.pl, rp)
+ dmap[dep.Ident.ProjectRoot] = cdep
+ } else {
+ dmap[dep.Ident.ProjectRoot] = completeDep{
+ ProjectConstraint: dep,
+ pl: []string{rp},
+ }
+ }
+ continue
+ }
+ }
+
+ // No match. Let the SourceManager try to figure out the root
+ root, err := s.b.deduceRemoteRepo(rp)
+ if err != nil {
+ // Nothing we can do if we can't suss out a root
+ return nil, err
+ }
+
+ // Still no matches; make a new completeDep with an open constraint
+ pd := ProjectConstraint{
+ Ident: ProjectIdentifier{
+ ProjectRoot: ProjectRoot(root.Base),
+ NetworkName: root.Base,
+ },
+ Constraint: Any(),
+ }
+
+ // Insert the pd into the trie so that further deps from this
+ // project get caught by the prefix search
+ xt.Insert(root.Base, pd)
+ // And also put the complete dep into the dmap
+ dmap[ProjectRoot(root.Base)] = completeDep{
+ ProjectConstraint: pd,
+ pl: []string{rp},
+ }
+ }
+
+ // Dump all the deps from the map into the expected return slice
+ cdeps := make([]completeDep, len(dmap))
+ k := 0
+ for _, cdep := range dmap {
+ cdeps[k] = cdep
+ k++
+ }
+
+ return cdeps, nil
+}
+
+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 {
+ return newVersionQueue(id, nil, nil, s.b)
+ }
+
+ exists, err := s.b.repoExists(id)
+ if err != nil {
+ return nil, err
+ }
+ if !exists {
+ exists, err = s.b.vendorCodeExists(id)
+ if err != nil {
+ return nil, err
+ }
+ if exists {
+ // Project exists only in vendor (and in some manifest somewhere)
+ // TODO(sdboyer) mark this for special handling, somehow?
+ } else {
+ return nil, newSolveError(fmt.Sprintf("Project '%s' could not be located.", id), cannotResolve)
+ }
+ }
+
+ var lockv Version
+ if len(s.rlm) > 0 {
+ lockv, err = s.getLockVersionIfValid(id)
+ if err != nil {
+ // Can only get an error here if an upgrade was expressly requested on
+ // code that exists only in vendor
+ return nil, err
+ }
+ }
+
+ var prefv Version
+ if bmi.fromRoot {
+ // If this bmi came from the root, then we want to search through things
+ // with a dependency on it in order to see if any have a lock that might
+ // express a prefv
+ //
+ // 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 {
+ continue
+ }
+
+ _, l, err := s.b.getProjectInfo(dep.depender)
+ if err != nil || l == nil {
+ // err being non-nil really shouldn't be possible, but the lock
+ // being nil is quite likely
+ continue
+ }
+
+ for _, lp := range l.Projects() {
+ if lp.Ident().eq(bmi.id) {
+ prefv = lp.Version()
+ }
+ }
+ }
+
+ // OTHER APPROACH - WRONG, BUT MAYBE USEFUL FOR REFERENCE?
+ // If this bmi came from the root, then we want to search the unselected
+ // queue to see if anything *else* wants this ident, in which case we
+ // pick up that prefv
+ //for _, bmi2 := range s.unsel.sl {
+ //// Take the first thing from the queue that's for the same ident,
+ //// and has a non-nil prefv
+ //if bmi.id.eq(bmi2.id) {
+ //if bmi2.prefv != nil {
+ //prefv = bmi2.prefv
+ //}
+ //}
+ //}
+
+ } else {
+ // Otherwise, just use the preferred version expressed in the bmi
+ prefv = bmi.prefv
+ }
+
+ q, err := newVersionQueue(id, lockv, prefv, s.b)
+ if err != nil {
+ // TODO(sdboyer) this particular err case needs to be improved to be ONLY for cases
+ // where there's absolutely nothing findable about a given project name
+ return nil, err
+ }
+
+ // Hack in support for revisions.
+ //
+ // By design, revs aren't returned from ListVersion(). Thus, if the dep in
+ // the bmi was has a rev constraint, it is (almost) guaranteed to fail, even
+ // if that rev does exist in the repo. So, detect a rev and push it into the
+ // vq here, instead.
+ //
+ // Happily, the solver maintains the invariant that constraints on a given
+ // ident cannot be incompatible, so we know that if we find one rev, then
+ // any other deps will have to also be on that rev (or Any).
+ //
+ // TODO(sdboyer) while this does work, it bypasses the interface-implied guarantees
+ // of the version queue, and is therefore not a great strategy for API
+ // coherency. Folding this in to a formal interface would be better.
+ switch tc := s.sel.getConstraint(bmi.id).(type) {
+ case Revision:
+ // We know this is the only thing that could possibly match, so put it
+ // in at the front - if it isn't there already.
+ if q.pi[0] != tc {
+ // Existence of the revision is guaranteed by checkRevisionExists().
+ q.pi = append([]Version{tc}, q.pi...)
+ }
+ }
+
+ // Having assembled the queue, search it for a valid version.
+ return q, s.findValidVersion(q, bmi.pl)
+}
+
+// findValidVersion walks through a versionQueue until it finds a version that
+// satisfies the constraints held in the current state of the solver.
+//
+// The satisfiability checks triggered from here are constrained to operate only
+// on those dependencies induced by the list of packages given in the second
+// parameter.
+func (s *solver) findValidVersion(q *versionQueue, pl []string) error {
+ if nil == q.current() {
+ // this case should not be reachable, but reflects improper solver state
+ // if it is, so panic immediately
+ panic("version queue is empty, should not happen")
+ }
+
+ faillen := len(q.fails)
+
+ for {
+ cur := q.current()
+ err := s.checkProject(atomWithPackages{
+ a: atom{
+ id: q.id,
+ v: cur,
+ },
+ pl: pl,
+ })
+ if err == nil {
+ // we have a good version, can return safely
+ return nil
+ }
+
+ if q.advance(err) != nil {
+ // Error on advance, have to bail out
+ break
+ }
+ if q.isExhausted() {
+ // Queue is empty, bail with error
+ break
+ }
+ }
+
+ s.fail(s.sel.getDependenciesOn(q.id)[0].depender.id)
+
+ // Return a compound error of all the new errors encountered during this
+ // attempt to find a new, valid version
+ return &noVersionError{
+ pn: q.id,
+ fails: q.fails[faillen:],
+ }
+}
+
+// getLockVersionIfValid finds an atom for the given ProjectIdentifier from the
+// root lock, assuming:
+//
+// 1. A root lock was provided
+// 2. The general flag to change all projects was not passed
+// 3. A flag to change this particular ProjectIdentifier was not passed
+//
+// If any of these three conditions are true (or if the id cannot be found in
+// the root lock), then no atom will be returned.
+func (s *solver) getLockVersionIfValid(id ProjectIdentifier) (Version, error) {
+ // If the project is specifically marked for changes, then don't look for a
+ // locked version.
+ if _, explicit := s.chng[id.ProjectRoot]; explicit || s.params.ChangeAll {
+ // For projects with an upstream or cache repository, it's safe to
+ // ignore what's in the lock, because there's presumably more versions
+ // to be found and attempted in the repository. If it's only in vendor,
+ // though, then we have to try to use what's in the lock, because that's
+ // the only version we'll be able to get.
+ if exist, _ := s.b.repoExists(id); exist {
+ return nil, nil
+ }
+
+ // However, if a change was *expressly* requested for something that
+ // exists only in vendor, then that guarantees we don't have enough
+ // information to complete a solution. In that case, error out.
+ if explicit {
+ return nil, &missingSourceFailure{
+ goal: id,
+ prob: "Cannot upgrade %s, as no source repository could be found.",
+ }
+ }
+ }
+
+ lp, exists := s.rlm[id]
+ if !exists {
+ return nil, nil
+ }
+
+ constraint := s.sel.getConstraint(id)
+ v := lp.Version()
+ if !constraint.Matches(v) {
+ var found bool
+ if tv, ok := v.(Revision); ok {
+ // If we only have a revision from the root's lock, allow matching
+ // against other versions that have that revision
+ for _, pv := range s.b.pairRevision(id, tv) {
+ if constraint.Matches(pv) {
+ v = pv
+ found = true
+ break
+ }
+ }
+ //} else if _, ok := constraint.(Revision); ok {
+ //// If the current constraint is itself a revision, and the lock gave
+ //// an unpaired version, see if they match up
+ ////
+ //if u, ok := v.(UnpairedVersion); ok {
+ //pv := s.sm.pairVersion(id, u)
+ //if constraint.Matches(pv) {
+ //v = pv
+ //found = true
+ //}
+ //}
+ }
+
+ if !found {
+ s.logSolve("%s in root lock, but current constraints disallow it", id.errString())
+ return nil, nil
+ }
+ }
+
+ s.logSolve("using root lock's version of %s", id.errString())
+
+ return v, nil
+}
+
+// backtrack works backwards from the current failed solution to find the next
+// solution to try.
+func (s *solver) backtrack() bool {
+ if len(s.vqs) == 0 {
+ // nothing to backtrack to
+ return false
+ }
+
+ for {
+ for {
+ if len(s.vqs) == 0 {
+ // no more versions, nowhere further to backtrack
+ return false
+ }
+ if s.vqs[len(s.vqs)-1].failed {
+ break
+ }
+
+ s.vqs, s.vqs[len(s.vqs)-1] = s.vqs[:len(s.vqs)-1], nil
+
+ // Pop selections off until we get to a project.
+ var proj bool
+ for !proj {
+ _, proj = s.unselectLast()
+ }
+ }
+
+ // Grab the last versionQueue off the list of queues
+ q := s.vqs[len(s.vqs)-1]
+ // Walk back to the next project
+ var awp atomWithPackages
+ var proj bool
+
+ for !proj {
+ awp, proj = s.unselectLast()
+ }
+
+ if !q.id.eq(awp.a.id) {
+ panic("canary - version queue stack and selected project stack are out of alignment")
+ }
+
+ // Advance the queue past the current version, which we know is bad
+ // TODO(sdboyer) is it feasible to make available the failure reason here?
+ if q.advance(nil) == nil && !q.isExhausted() {
+ // Search for another acceptable version of this failed dep in its queue
+ if s.findValidVersion(q, awp.pl) == nil {
+ s.logSolve()
+
+ // Found one! Put it back on the selected queue and stop
+ // backtracking
+ s.selectAtomWithPackages(atomWithPackages{
+ a: atom{
+ id: q.id,
+ v: q.current(),
+ },
+ pl: awp.pl,
+ })
+ break
+ }
+ }
+
+ s.logSolve("no more versions of %s, backtracking", q.id.errString())
+
+ // No solution found; continue backtracking after popping the queue
+ // we just inspected off the list
+ // GC-friendly pop pointer elem in slice
+ s.vqs, s.vqs[len(s.vqs)-1] = s.vqs[:len(s.vqs)-1], nil
+ }
+
+ // Backtracking was successful if loop ended before running out of versions
+ if len(s.vqs) == 0 {
+ return false
+ }
+ s.attempts++
+ return true
+}
+
+func (s *solver) nextUnselected() (bimodalIdentifier, bool) {
+ if len(s.unsel.sl) > 0 {
+ return s.unsel.sl[0], true
+ }
+
+ return bimodalIdentifier{}, false
+}
+
+func (s *solver) unselectedComparator(i, j int) bool {
+ ibmi, jbmi := s.unsel.sl[i], s.unsel.sl[j]
+ iname, jname := ibmi.id, jbmi.id
+
+ // Most important thing is pushing package additions ahead of project
+ // additions. Package additions can't walk their version queue, so all they
+ // do is narrow the possibility of success; better to find out early and
+ // fast if they're going to fail than wait until after we've done real work
+ // on a project and have to backtrack across it.
+
+ // FIXME the impl here is currently O(n) in the number of selections; it
+ // absolutely cannot stay in a hot sorting path like this
+ _, isel := s.sel.selected(iname)
+ _, jsel := s.sel.selected(jname)
+
+ if isel && !jsel {
+ return true
+ }
+ if !isel && jsel {
+ return false
+ }
+
+ if iname.eq(jname) {
+ return false
+ }
+
+ _, ilock := s.rlm[iname]
+ _, jlock := s.rlm[jname]
+
+ switch {
+ case ilock && !jlock:
+ return true
+ case !ilock && jlock:
+ return false
+ case ilock && jlock:
+ return iname.less(jname)
+ }
+
+ // Now, sort by number of available versions. This will trigger network
+ // activity, but at this point we know that the project we're looking at
+ // isn't locked by the root. And, because being locked by root is the only
+ // way avoid that call when making a version queue, we know we're gonna have
+ // to pay that cost anyway.
+
+ // We can safely ignore an err from ListVersions here because, if there is
+ // an actual problem, it'll be noted and handled somewhere else saner in the
+ // solving algorithm.
+ ivl, _ := s.b.listVersions(iname)
+ jvl, _ := s.b.listVersions(jname)
+ iv, jv := len(ivl), len(jvl)
+
+ // Packages with fewer versions to pick from are less likely to benefit from
+ // backtracking, so deal with them earlier in order to minimize the amount
+ // of superfluous backtracking through them we do.
+ switch {
+ case iv == 0 && jv != 0:
+ return true
+ case iv != 0 && jv == 0:
+ return false
+ case iv != jv:
+ return iv < jv
+ }
+
+ // Finally, if all else fails, fall back to comparing by name
+ return iname.less(jname)
+}
+
+func (s *solver) fail(id ProjectIdentifier) {
+ // TODO(sdboyer) does this need updating, now that we have non-project package
+ // selection?
+
+ // skip if the root project
+ if s.params.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 {
+ if vq.id.eq(id) {
+ vq.failed = true
+ return
+ }
+ }
+ }
+}
+
+// selectAtomWithPackages handles the selection case where a new project is
+// being added to the selection queue, alongside some number of its contained
+// packages. This method pushes them onto the selection queue, then adds any
+// new resultant deps to the unselected queue.
+func (s *solver) selectAtomWithPackages(a atomWithPackages) {
+ s.unsel.remove(bimodalIdentifier{
+ id: a.a.id,
+ pl: a.pl,
+ })
+
+ s.sel.pushSelection(a, true)
+
+ deps, err := s.getImportsAndConstraintsOf(a)
+ if err != nil {
+ // This shouldn't be possible; other checks should have ensured all
+ // packages and deps are present for any argument passed to this method.
+ panic(fmt.Sprintf("canary - shouldn't be possible %s", err))
+ }
+
+ // If this atom has a lock, pull it out so that we can potentially inject
+ // preferred versions into any bmis we enqueue
+ _, l, _ := s.b.getProjectInfo(a.a)
+ var lmap map[ProjectIdentifier]Version
+ if l != nil {
+ lmap = make(map[ProjectIdentifier]Version)
+ for _, lp := range l.Projects() {
+ lmap[lp.Ident()] = lp.Version()
+ }
+ }
+
+ for _, dep := range deps {
+ s.sel.pushDep(dependency{depender: a.a, dep: dep})
+ // Go through all the packages introduced on this dep, selecting only
+ // the ones where the only depper on them is what we pushed in. Then,
+ // put those into the unselected queue.
+ rpm := s.sel.getRequiredPackagesIn(dep.Ident)
+ var newp []string
+ for _, pkg := range dep.pl {
+ if rpm[pkg] == 1 {
+ newp = append(newp, pkg)
+ }
+ }
+
+ if len(newp) > 0 {
+ bmi := bimodalIdentifier{
+ id: dep.Ident,
+ pl: newp,
+ // This puts in a preferred version if one's in the map, else
+ // drops in the zero value (nil)
+ prefv: lmap[dep.Ident],
+ }
+ heap.Push(s.unsel, bmi)
+ }
+
+ if s.sel.depperCount(dep.Ident) == 1 {
+ s.names[dep.Ident.ProjectRoot] = dep.Ident.netName()
+ }
+ }
+}
+
+// selectPackages handles the selection case where we're just adding some new
+// packages to a project that was already selected. After pushing the selection,
+// it adds any newly-discovered deps to the unselected queue.
+//
+// It also takes an atomWithPackages because we need that same information in
+// order to enqueue the selection.
+func (s *solver) selectPackages(a atomWithPackages) {
+ s.unsel.remove(bimodalIdentifier{
+ id: a.a.id,
+ pl: a.pl,
+ })
+
+ s.sel.pushSelection(a, false)
+
+ deps, err := s.getImportsAndConstraintsOf(a)
+ if err != nil {
+ // This shouldn't be possible; other checks should have ensured all
+ // packages and deps are present for any argument passed to this method.
+ panic(fmt.Sprintf("canary - shouldn't be possible %s", err))
+ }
+
+ // If this atom has a lock, pull it out so that we can potentially inject
+ // preferred versions into any bmis we enqueue
+ _, l, _ := s.b.getProjectInfo(a.a)
+ var lmap map[ProjectIdentifier]Version
+ if l != nil {
+ lmap = make(map[ProjectIdentifier]Version)
+ for _, lp := range l.Projects() {
+ lmap[lp.Ident()] = lp.Version()
+ }
+ }
+
+ for _, dep := range deps {
+ s.sel.pushDep(dependency{depender: a.a, dep: dep})
+ // Go through all the packages introduced on this dep, selecting only
+ // the ones where the only depper on them is what we pushed in. Then,
+ // put those into the unselected queue.
+ rpm := s.sel.getRequiredPackagesIn(dep.Ident)
+ var newp []string
+ for _, pkg := range dep.pl {
+ if rpm[pkg] == 1 {
+ newp = append(newp, pkg)
+ }
+ }
+
+ if len(newp) > 0 {
+ bmi := bimodalIdentifier{
+ id: dep.Ident,
+ pl: newp,
+ // This puts in a preferred version if one's in the map, else
+ // drops in the zero value (nil)
+ prefv: lmap[dep.Ident],
+ }
+ heap.Push(s.unsel, bmi)
+ }
+
+ if s.sel.depperCount(dep.Ident) == 1 {
+ s.names[dep.Ident.ProjectRoot] = dep.Ident.netName()
+ }
+ }
+}
+
+func (s *solver) unselectLast() (atomWithPackages, bool) {
+ awp, first := s.sel.popSelection()
+ heap.Push(s.unsel, bimodalIdentifier{id: awp.a.id, pl: awp.pl})
+
+ deps, err := s.getImportsAndConstraintsOf(awp)
+ if err != nil {
+ // This shouldn't be possible; other checks should have ensured all
+ // packages and deps are present for any argument passed to this method.
+ panic(fmt.Sprintf("canary - shouldn't be possible %s", err))
+ }
+
+ for _, dep := range deps {
+ s.sel.popDep(dep.Ident)
+
+ // if no parents/importers, remove from unselected queue
+ if s.sel.depperCount(dep.Ident) == 0 {
+ delete(s.names, dep.Ident.ProjectRoot)
+ s.unsel.remove(bimodalIdentifier{id: dep.Ident, pl: dep.pl})
+ }
+ }
+
+ return awp, first
+}
+
+func (s *solver) logStart(bmi bimodalIdentifier) {
+ if !s.params.Trace {
+ return
+ }
+
+ prefix := strings.Repeat("| ", len(s.vqs)+1)
+ // TODO(sdboyer) how...to list the packages in the limited space we have?
+ s.tl.Printf("%s\n", tracePrefix(fmt.Sprintf("? attempting %s (with %v packages)", bmi.id.errString(), len(bmi.pl)), prefix, prefix))
+}
+
+func (s *solver) logSolve(args ...interface{}) {
+ if !s.params.Trace {
+ return
+ }
+
+ preflen := len(s.vqs)
+ var msg string
+ if len(args) == 0 {
+ // Generate message based on current solver state
+ if len(s.vqs) == 0 {
+ msg = "✓ (root)"
+ } else {
+ vq := s.vqs[len(s.vqs)-1]
+ msg = fmt.Sprintf("✓ select %s at %s", vq.id.errString(), vq.current())
+ }
+ } else {
+ // Use longer prefix length for these cases, as they're the intermediate
+ // work
+ preflen++
+ switch data := args[0].(type) {
+ case string:
+ msg = tracePrefix(fmt.Sprintf(data, args[1:]), "| ", "| ")
+ case traceError:
+ // We got a special traceError, use its custom method
+ msg = tracePrefix(data.traceString(), "| ", "✗ ")
+ case error:
+ // Regular error; still use the x leader but default Error() string
+ msg = tracePrefix(data.Error(), "| ", "✗ ")
+ default:
+ // panic here because this can *only* mean a stupid internal bug
+ panic("canary - must pass a string as first arg to logSolve, or no args at all")
+ }
+ }
+
+ prefix := strings.Repeat("| ", preflen)
+ s.tl.Printf("%s\n", tracePrefix(msg, prefix, prefix))
+}
+
+func tracePrefix(msg, sep, fsep string) string {
+ parts := strings.Split(strings.TrimSuffix(msg, "\n"), "\n")
+ for k, str := range parts {
+ if k == 0 {
+ parts[k] = fmt.Sprintf("%s%s", fsep, str)
+ } else {
+ parts[k] = fmt.Sprintf("%s%s", sep, str)
+ }
+ }
+
+ return strings.Join(parts, "\n")
+}
+
+// simple (temporary?) helper just to convert atoms into locked projects
+func pa2lp(pa atom, pkgs map[string]struct{}) LockedProject {
+ lp := LockedProject{
+ pi: pa.id.normalize(), // shouldn't be necessary, but normalize just in case
+ }
+
+ switch v := pa.v.(type) {
+ case UnpairedVersion:
+ lp.v = v
+ case Revision:
+ lp.r = v
+ case versionPair:
+ lp.v = v.v
+ lp.r = v.r
+ default:
+ panic("unreachable")
+ }
+
+ for pkg := range pkgs {
+ lp.pkgs = append(lp.pkgs, strings.TrimPrefix(pkg, string(pa.id.ProjectRoot)+string(os.PathSeparator)))
+ }
+ sort.Strings(lp.pkgs)
+
+ return lp
+}
diff --git a/vendor/github.com/sdboyer/gps/source_manager.go b/vendor/github.com/sdboyer/gps/source_manager.go
new file mode 100644
index 0000000..86627a1
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/source_manager.go
@@ -0,0 +1,297 @@
+package gps
+
+import (
+ "encoding/json"
+ "fmt"
+ "go/build"
+ "os"
+ "path"
+
+ "github.com/Masterminds/vcs"
+)
+
+// A SourceManager is responsible for retrieving, managing, and interrogating
+// source repositories. Its primary purpose is to serve the needs of a Solver,
+// but it is handy for other purposes, as well.
+//
+// gps's built-in SourceManager, accessible via NewSourceManager(), is
+// intended to be generic and sufficient for any purpose. It provides some
+// additional semantics around the methods defined here.
+type SourceManager interface {
+ // RepoExists checks if a repository exists, either upstream or in the
+ // SourceManager's central repository cache.
+ RepoExists(ProjectRoot) (bool, error)
+
+ // ListVersions retrieves a list of the available versions for a given
+ // repository name.
+ ListVersions(ProjectRoot) ([]Version, error)
+
+ // RevisionPresentIn indicates whether the provided Version is present in
+ // the given repository.
+ RevisionPresentIn(ProjectRoot, Revision) (bool, error)
+
+ // ListPackages retrieves a tree of the Go packages at or below the provided
+ // import path, at the provided version.
+ ListPackages(ProjectRoot, Version) (PackageTree, error)
+
+ // GetProjectInfo returns manifest and lock information for the provided
+ // import path. gps currently requires that projects be rooted at their
+ // repository root, which means that this ProjectRoot must also be a
+ // repository root.
+ GetProjectInfo(ProjectRoot, Version) (Manifest, Lock, error)
+
+ // ExportProject writes out the tree of the provided import path, at the
+ // provided version, to the provided directory.
+ ExportProject(ProjectRoot, Version, string) error
+
+ // Release lets go of any locks held by the SourceManager.
+ Release()
+}
+
+// A ProjectAnalyzer is responsible for analyzing a path for Manifest and Lock
+// information. Tools relying on gps must implement one.
+type ProjectAnalyzer interface {
+ GetInfo(string, ProjectRoot) (Manifest, Lock, error)
+}
+
+// SourceMgr is the default SourceManager for gps.
+//
+// There's no (planned) reason why it would need to be reimplemented by other
+// tools; control via dependency injection is intended to be sufficient.
+type SourceMgr struct {
+ cachedir string
+ pms map[ProjectRoot]*pmState
+ an ProjectAnalyzer
+ ctx build.Context
+ //pme map[ProjectRoot]error
+}
+
+var _ SourceManager = &SourceMgr{}
+
+// Holds a projectManager, caches of the managed project's data, and information
+// about the freshness of those caches
+type pmState struct {
+ pm *projectManager
+ cf *os.File // handle for the cache file
+ vcur bool // indicates that we've called ListVersions()
+}
+
+// NewSourceManager produces an instance of gps's built-in SourceManager. It
+// takes a cache directory (where local instances of upstream repositories are
+// stored), a vendor directory for the project currently being worked on, and a
+// force flag indicating whether to overwrite the global cache lock file (if
+// present).
+//
+// The returned SourceManager aggressively caches information wherever possible.
+// It is recommended that, if tools need to do preliminary, work involving
+// upstream repository analysis prior to invoking a solve run, that they create
+// this SourceManager as early as possible and use it to their ends. That way,
+// the solver can benefit from any caches that may have already been warmed.
+//
+// gps's SourceManager is intended to be threadsafe (if it's not, please
+// file a bug!). It should certainly be safe to reuse from one solving run to
+// the next; however, the fact that it takes a basedir as an argument makes it
+// much less useful for simultaneous use by separate solvers operating on
+// different root projects. This architecture may change in the future.
+func NewSourceManager(an ProjectAnalyzer, cachedir string, force bool) (*SourceMgr, error) {
+ if an == nil {
+ return nil, fmt.Errorf("a ProjectAnalyzer must be provided to the SourceManager")
+ }
+
+ err := os.MkdirAll(cachedir, 0777)
+ if err != nil {
+ return nil, err
+ }
+
+ glpath := path.Join(cachedir, "sm.lock")
+ _, err = os.Stat(glpath)
+ if err == nil && !force {
+ return nil, fmt.Errorf("cache lock file %s exists - another process crashed or is still running?", glpath)
+ }
+
+ _, err = os.OpenFile(glpath, os.O_CREATE|os.O_RDONLY, 0700) // is 0700 sane for this purpose?
+ if err != nil {
+ return nil, fmt.Errorf("failed to create global cache lock file at %s with err %s", glpath, err)
+ }
+
+ ctx := build.Default
+ // Replace GOPATH with our cache dir
+ ctx.GOPATH = cachedir
+
+ return &SourceMgr{
+ cachedir: cachedir,
+ pms: make(map[ProjectRoot]*pmState),
+ ctx: ctx,
+ an: an,
+ }, nil
+}
+
+// Release lets go of any locks held by the SourceManager.
+func (sm *SourceMgr) Release() {
+ os.Remove(path.Join(sm.cachedir, "sm.lock"))
+}
+
+// GetProjectInfo returns manifest and lock information for the provided import
+// path. gps currently requires that projects be rooted at their repository
+// root, which means that this ProjectRoot must also be a repository root.
+//
+// The work of producing the manifest and lock information is delegated to the
+// injected ProjectAnalyzer.
+func (sm *SourceMgr) GetProjectInfo(n ProjectRoot, v Version) (Manifest, Lock, error) {
+ pmc, err := sm.getProjectManager(n)
+ if err != nil {
+ return nil, nil, err
+ }
+
+ return pmc.pm.GetInfoAt(v)
+}
+
+// ListPackages retrieves a tree of the Go packages at or below the provided
+// import path, at the provided version.
+func (sm *SourceMgr) ListPackages(n ProjectRoot, v Version) (PackageTree, error) {
+ pmc, err := sm.getProjectManager(n)
+ if err != nil {
+ return PackageTree{}, err
+ }
+
+ return pmc.pm.ListPackages(v)
+}
+
+// ListVersions retrieves a list of the available versions for a given
+// repository name.
+//
+// The list is not sorted; while it may be returned in the order that the
+// underlying VCS reports version information, no guarantee is made. It is
+// expected that the caller either not care about order, or sort the result
+// themselves.
+//
+// This list is always retrieved from upstream; if upstream is not accessible
+// (network outage, access issues, or the resource actually went away), an error
+// will be returned.
+func (sm *SourceMgr) ListVersions(n ProjectRoot) ([]Version, error) {
+ pmc, err := sm.getProjectManager(n)
+ if err != nil {
+ // TODO(sdboyer) More-er proper-er errors
+ return nil, err
+ }
+
+ return pmc.pm.ListVersions()
+}
+
+// RevisionPresentIn indicates whether the provided Revision is present in the given
+// repository.
+func (sm *SourceMgr) RevisionPresentIn(n ProjectRoot, r Revision) (bool, error) {
+ pmc, err := sm.getProjectManager(n)
+ if err != nil {
+ // TODO(sdboyer) More-er proper-er errors
+ return false, err
+ }
+
+ return pmc.pm.RevisionPresentIn(r)
+}
+
+// RepoExists checks if a repository exists, either upstream or in the cache,
+// for the provided ProjectRoot.
+func (sm *SourceMgr) RepoExists(n ProjectRoot) (bool, error) {
+ pms, err := sm.getProjectManager(n)
+ if err != nil {
+ return false, err
+ }
+
+ return pms.pm.CheckExistence(existsInCache) || pms.pm.CheckExistence(existsUpstream), nil
+}
+
+// ExportProject writes out the tree of the provided import path, at the
+// provided version, to the provided directory.
+func (sm *SourceMgr) ExportProject(n ProjectRoot, v Version, to string) error {
+ pms, err := sm.getProjectManager(n)
+ if err != nil {
+ return err
+ }
+
+ return pms.pm.ExportVersionTo(v, to)
+}
+
+// getProjectManager gets the project manager for the given ProjectRoot.
+//
+// If no such manager yet exists, it attempts to create one.
+func (sm *SourceMgr) getProjectManager(n ProjectRoot) (*pmState, error) {
+ // Check pm cache and errcache first
+ if pm, exists := sm.pms[n]; exists {
+ return pm, nil
+ //} else if pme, errexists := sm.pme[name]; errexists {
+ //return nil, pme
+ }
+
+ repodir := path.Join(sm.cachedir, "src", string(n))
+ // TODO(sdboyer) be more robust about this
+ r, err := vcs.NewRepo("https://"+string(n), repodir)
+ if err != nil {
+ // TODO(sdboyer) be better
+ return nil, err
+ }
+ if !r.CheckLocal() {
+ // TODO(sdboyer) cloning the repo here puts it on a blocking, and possibly
+ // unnecessary path. defer it
+ err = r.Get()
+ if err != nil {
+ // TODO(sdboyer) be better
+ return nil, err
+ }
+ }
+
+ // Ensure cache dir exists
+ metadir := path.Join(sm.cachedir, "metadata", string(n))
+ err = os.MkdirAll(metadir, 0777)
+ if err != nil {
+ // TODO(sdboyer) be better
+ return nil, err
+ }
+
+ pms := &pmState{}
+ cpath := path.Join(metadir, "cache.json")
+ fi, err := os.Stat(cpath)
+ var dc *projectDataCache
+ if fi != nil {
+ pms.cf, err = os.OpenFile(cpath, os.O_RDWR, 0777)
+ if err != nil {
+ // TODO(sdboyer) be better
+ return nil, fmt.Errorf("Err on opening metadata cache file: %s", err)
+ }
+
+ err = json.NewDecoder(pms.cf).Decode(dc)
+ if err != nil {
+ // TODO(sdboyer) be better
+ return nil, fmt.Errorf("Err on JSON decoding metadata cache file: %s", err)
+ }
+ } else {
+ // TODO(sdboyer) commented this out for now, until we manage it correctly
+ //pms.cf, err = os.Create(cpath)
+ //if err != nil {
+ //// TODO(sdboyer) be better
+ //return nil, fmt.Errorf("Err on creating metadata cache file: %s", err)
+ //}
+
+ dc = &projectDataCache{
+ Infos: make(map[Revision]projectInfo),
+ Packages: make(map[Revision]PackageTree),
+ VMap: make(map[Version]Revision),
+ RMap: make(map[Revision][]Version),
+ }
+ }
+
+ pm := &projectManager{
+ n: n,
+ ctx: sm.ctx,
+ an: sm.an,
+ dc: dc,
+ crepo: &repo{
+ rpath: repodir,
+ r: r,
+ },
+ }
+
+ pms.pm = pm
+ sm.pms[n] = pms
+ return pms, nil
+}
diff --git a/vendor/github.com/sdboyer/gps/types.go b/vendor/github.com/sdboyer/gps/types.go
new file mode 100644
index 0000000..f720fa2
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/types.go
@@ -0,0 +1,195 @@
+package gps
+
+import (
+ "fmt"
+ "math/rand"
+ "strconv"
+)
+
+// ProjectRoot is the topmost import path in a tree of other import paths - the
+// root of the tree. In gps' current design, ProjectRoots have to correspond to
+// a repository root (mostly), but their real purpose is to identify the root
+// import path of a "project", logically encompassing all child packages.
+//
+// Projects are a crucial unit of operation in gps. Constraints are declared by
+// a project's manifest, and apply to all packages in a ProjectRoot's tree.
+// Solving itself mostly proceeds on a project-by-project basis.
+//
+// Aliasing string types is usually a bit of an anti-pattern. We do it here as a
+// means of clarifying API intent. This is important because Go's package
+// management domain has lots of different path-ish strings floating around:
+//
+// actual directories:
+// /home/sdboyer/go/src/github.com/sdboyer/gps/example
+// URLs:
+// https://github.com/sdboyer/gps
+// import paths:
+// github.com/sdboyer/gps/example
+// portions of import paths that refer to a package:
+// example
+// portions that could not possibly refer to anything sane:
+// github.com/sdboyer
+// portions that correspond to a repository root:
+// github.com/sdboyer/gps
+//
+// While not a panacea, defining ProjectRoot at least allows us to clearly
+// identify when one of these path-ish strings is *supposed* to have certain
+// semantics.
+type ProjectRoot string
+
+// A ProjectIdentifier is, more or less, the name of a dependency. It is related
+// to, but differs in two keys ways from, an import path.
+//
+// First, ProjectIdentifiers do not identify a single package. Rather, they
+// encompasses the whole tree of packages that exist at or below their
+// ProjectRoot. In gps' current design, this ProjectRoot must correspond to the
+// root of a repository, though this may not always be the case.
+//
+// Second, ProjectIdentifiers can optionally carry a NetworkName, which
+// identifies where the underlying source code can be located on the network.
+// These can be either a full URL, including protocol, or plain import paths.
+// So, these are all valid data for NetworkName:
+//
+// github.com/sdboyer/gps
+// github.com/fork/gps
+// git@github.com:sdboyer/gps
+// https://github.com/sdboyer/gps
+//
+// With plain import paths, network addresses are derived purely through an
+// algorithm. By having an explicit network name, it becomes possible to, for
+// example, transparently substitute a fork for an original upstream repository.
+//
+// Note that gps makes no guarantees about the actual import paths contained in
+// a repository aligning with ImportRoot. If tools, or their users, specify an
+// alternate NetworkName that contains a repository with incompatible internal
+// import paths, gps will fail. (gps does no import rewriting.)
+//
+// Also note that if different projects' manifests report a different
+// NetworkName for a given ImportRoot, it is a solve failure. Everyone has to
+// agree on where a given import path should be sourced from.
+//
+// If NetworkName is not explicitly set, gps will derive the network address from
+// the ImportRoot using a similar algorithm to that of the official go tooling.
+type ProjectIdentifier struct {
+ ProjectRoot ProjectRoot
+ NetworkName string
+}
+
+// A ProjectConstraint combines a ProjectIdentifier with a Constraint. It
+// indicates that, if packages contained in the ProjectIdentifier enter the
+// depgraph, they must do so at a version that is allowed by the Constraint.
+type ProjectConstraint struct {
+ Ident ProjectIdentifier
+ Constraint Constraint
+}
+
+func (i ProjectIdentifier) less(j ProjectIdentifier) bool {
+ if i.ProjectRoot < j.ProjectRoot {
+ return true
+ }
+ if j.ProjectRoot < i.ProjectRoot {
+ return false
+ }
+
+ return i.NetworkName < j.NetworkName
+}
+
+func (i ProjectIdentifier) eq(j ProjectIdentifier) bool {
+ if i.ProjectRoot != j.ProjectRoot {
+ return false
+ }
+ if i.NetworkName == j.NetworkName {
+ return true
+ }
+
+ if (i.NetworkName == "" && j.NetworkName == string(j.ProjectRoot)) ||
+ (j.NetworkName == "" && i.NetworkName == string(i.ProjectRoot)) {
+ return true
+ }
+
+ // TODO(sdboyer) attempt conversion to URL and compare base + path
+
+ return false
+}
+
+func (i ProjectIdentifier) netName() string {
+ if i.NetworkName == "" {
+ return string(i.ProjectRoot)
+ }
+ return i.NetworkName
+}
+
+func (i ProjectIdentifier) errString() string {
+ if i.NetworkName == "" || i.NetworkName == string(i.ProjectRoot) {
+ return string(i.ProjectRoot)
+ }
+ return fmt.Sprintf("%s (from %s)", i.ProjectRoot, i.NetworkName)
+}
+
+func (i ProjectIdentifier) normalize() ProjectIdentifier {
+ if i.NetworkName == "" {
+ i.NetworkName = string(i.ProjectRoot)
+ }
+
+ return i
+}
+
+// Package represents a Go package. It contains a subset of the information
+// go/build.Package does.
+type Package struct {
+ ImportPath, CommentPath string
+ Name string
+ Imports []string
+ TestImports []string
+}
+
+// bimodalIdentifiers are used to track work to be done in the unselected queue.
+// TODO(sdboyer) marker for root, to know to ignore prefv...or can we do unselected queue
+// sorting only?
+type bimodalIdentifier struct {
+ id ProjectIdentifier
+ // List of packages required within/under the ProjectIdentifier
+ pl []string
+ // prefv is used to indicate a 'preferred' version. This is expected to be
+ // derived from a dep's lock data, or else is empty.
+ prefv Version
+ // Indicates that the bmi came from the root project originally
+ fromRoot bool
+}
+
+type atom struct {
+ id ProjectIdentifier
+ v Version
+}
+
+// With a random revision and no name, collisions are...unlikely
+var nilpa = atom{
+ v: Revision(strconv.FormatInt(rand.Int63(), 36)),
+}
+
+type atomWithPackages struct {
+ a atom
+ pl []string
+}
+
+//type byImportPath []Package
+
+//func (s byImportPath) Len() int { return len(s) }
+//func (s byImportPath) Less(i, j int) bool { return s[i].ImportPath < s[j].ImportPath }
+//func (s byImportPath) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
+
+// completeDep (name hopefully to change) provides the whole picture of a
+// dependency - the root (repo and project, since currently we assume the two
+// are the same) name, a constraint, and the actual packages needed that are
+// under that root.
+type completeDep struct {
+ // The base ProjectDep
+ ProjectConstraint
+ // The specific packages required from the ProjectDep
+ pl []string
+}
+
+type dependency struct {
+ depender atom
+ dep completeDep
+}
diff --git a/vendor/github.com/sdboyer/gps/version.go b/vendor/github.com/sdboyer/gps/version.go
new file mode 100644
index 0000000..57d37ec
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/version.go
@@ -0,0 +1,512 @@
+package gps
+
+import "github.com/Masterminds/semver"
+
+// Version represents one of the different types of versions used by gps.
+//
+// Version composes Constraint, because all versions can be used as a constraint
+// (where they allow one, and only one, version - themselves), but constraints
+// are not necessarily discrete versions.
+//
+// Version is an interface, but it contains private methods, which restricts it
+// to gps's own internal implementations. We do this for the confluence of
+// two reasons: the implementation of Versions is complete (there is no case in
+// which we'd need other types), and the implementation relies on type magic
+// under the hood, which would be unsafe to do if other dynamic types could be
+// hiding behind the interface.
+type Version interface {
+ Constraint
+ // Indicates the type of version - Revision, Branch, Version, or Semver
+ Type() string
+}
+
+// PairedVersion represents a normal Version, but paired with its corresponding,
+// underlying Revision.
+type PairedVersion interface {
+ Version
+ // Underlying returns the immutable Revision that identifies this Version.
+ Underlying() Revision
+ // Ensures it is impossible to be both a PairedVersion and an
+ // UnpairedVersion
+ _pair(int)
+}
+
+// UnpairedVersion represents a normal Version, with a method for creating a
+// VersionPair by indicating the version's corresponding, underlying Revision.
+type UnpairedVersion interface {
+ Version
+ // Is takes the underlying Revision that this UnpairedVersion corresponds
+ // to and unites them into a PairedVersion.
+ Is(Revision) PairedVersion
+ // Ensures it is impossible to be both a PairedVersion and an
+ // UnpairedVersion
+ _pair(bool)
+}
+
+// types are weird
+func (branchVersion) _private() {}
+func (branchVersion) _pair(bool) {}
+func (plainVersion) _private() {}
+func (plainVersion) _pair(bool) {}
+func (semVersion) _private() {}
+func (semVersion) _pair(bool) {}
+func (versionPair) _private() {}
+func (versionPair) _pair(int) {}
+func (Revision) _private() {}
+
+// NewBranch creates a new Version to represent a floating version (in
+// general, a branch).
+func NewBranch(body string) UnpairedVersion {
+ return branchVersion(body)
+}
+
+// NewVersion creates a Semver-typed Version if the provided version string is
+// valid semver, and a plain/non-semver version if not.
+func NewVersion(body string) UnpairedVersion {
+ sv, err := semver.NewVersion(body)
+
+ if err != nil {
+ return plainVersion(body)
+ }
+ return semVersion{sv: sv}
+}
+
+// A Revision represents an immutable versioning identifier.
+type Revision string
+
+// String converts the Revision back into a string.
+func (r Revision) String() string {
+ return string(r)
+}
+
+func (r Revision) Type() string {
+ return "rev"
+}
+
+// Matches is the Revision acting as a constraint; it checks to see if the provided
+// version is the same Revision as itself.
+func (r Revision) Matches(v Version) bool {
+ switch tv := v.(type) {
+ case versionTypeUnion:
+ return tv.Matches(r)
+ case Revision:
+ return r == tv
+ case versionPair:
+ return r == tv.r
+ }
+
+ return false
+}
+
+// MatchesAny is the Revision acting as a constraint; it checks to see if the provided
+// version is the same Revision as itself.
+func (r Revision) MatchesAny(c Constraint) bool {
+ switch tc := c.(type) {
+ case anyConstraint:
+ return true
+ case noneConstraint:
+ return false
+ case versionTypeUnion:
+ return tc.MatchesAny(r)
+ case Revision:
+ return r == tc
+ case versionPair:
+ return r == tc.r
+ }
+
+ return false
+}
+
+func (r Revision) Intersect(c Constraint) Constraint {
+ switch tc := c.(type) {
+ case anyConstraint:
+ return r
+ case noneConstraint:
+ return none
+ case versionTypeUnion:
+ return tc.Intersect(r)
+ case Revision:
+ if r == tc {
+ return r
+ }
+ case versionPair:
+ if r == tc.r {
+ return r
+ }
+ }
+
+ return none
+}
+
+type branchVersion string
+
+func (v branchVersion) String() string {
+ return string(v)
+}
+
+func (r branchVersion) Type() string {
+ return "branch"
+}
+
+func (v branchVersion) Matches(v2 Version) bool {
+ switch tv := v2.(type) {
+ case versionTypeUnion:
+ return tv.Matches(v)
+ case branchVersion:
+ return v == tv
+ case versionPair:
+ if tv2, ok := tv.v.(branchVersion); ok {
+ return tv2 == v
+ }
+ }
+ return false
+}
+
+func (v branchVersion) MatchesAny(c Constraint) bool {
+ switch tc := c.(type) {
+ case anyConstraint:
+ return true
+ case noneConstraint:
+ return false
+ case versionTypeUnion:
+ return tc.MatchesAny(v)
+ case branchVersion:
+ return v == tc
+ case versionPair:
+ if tc2, ok := tc.v.(branchVersion); ok {
+ return tc2 == v
+ }
+ }
+
+ return false
+}
+
+func (v branchVersion) Intersect(c Constraint) Constraint {
+ switch tc := c.(type) {
+ case anyConstraint:
+ return v
+ case noneConstraint:
+ return none
+ case versionTypeUnion:
+ return tc.Intersect(v)
+ case branchVersion:
+ if v == tc {
+ return v
+ }
+ case versionPair:
+ if tc2, ok := tc.v.(branchVersion); ok {
+ if v == tc2 {
+ return v
+ }
+ }
+ }
+
+ return none
+}
+
+func (v branchVersion) Is(r Revision) PairedVersion {
+ return versionPair{
+ v: v,
+ r: r,
+ }
+}
+
+type plainVersion string
+
+func (v plainVersion) String() string {
+ return string(v)
+}
+
+func (r plainVersion) Type() string {
+ return "version"
+}
+
+func (v plainVersion) Matches(v2 Version) bool {
+ switch tv := v2.(type) {
+ case versionTypeUnion:
+ return tv.Matches(v)
+ case plainVersion:
+ return v == tv
+ case versionPair:
+ if tv2, ok := tv.v.(plainVersion); ok {
+ return tv2 == v
+ }
+ }
+ return false
+}
+
+func (v plainVersion) MatchesAny(c Constraint) bool {
+ switch tc := c.(type) {
+ case anyConstraint:
+ return true
+ case noneConstraint:
+ return false
+ case versionTypeUnion:
+ return tc.MatchesAny(v)
+ case plainVersion:
+ return v == tc
+ case versionPair:
+ if tc2, ok := tc.v.(plainVersion); ok {
+ return tc2 == v
+ }
+ }
+
+ return false
+}
+
+func (v plainVersion) Intersect(c Constraint) Constraint {
+ switch tc := c.(type) {
+ case anyConstraint:
+ return v
+ case noneConstraint:
+ return none
+ case versionTypeUnion:
+ return tc.Intersect(v)
+ case plainVersion:
+ if v == tc {
+ return v
+ }
+ case versionPair:
+ if tc2, ok := tc.v.(plainVersion); ok {
+ if v == tc2 {
+ return v
+ }
+ }
+ }
+
+ return none
+}
+
+func (v plainVersion) Is(r Revision) PairedVersion {
+ return versionPair{
+ v: v,
+ r: r,
+ }
+}
+
+type semVersion struct {
+ sv *semver.Version
+}
+
+func (v semVersion) String() string {
+ return v.sv.Original()
+}
+
+func (r semVersion) Type() string {
+ return "semver"
+}
+
+func (v semVersion) Matches(v2 Version) bool {
+ switch tv := v2.(type) {
+ case versionTypeUnion:
+ return tv.Matches(v)
+ case semVersion:
+ return v.sv.Equal(tv.sv)
+ case versionPair:
+ if tv2, ok := tv.v.(semVersion); ok {
+ return tv2.sv.Equal(v.sv)
+ }
+ }
+ return false
+}
+
+func (v semVersion) MatchesAny(c Constraint) bool {
+ switch tc := c.(type) {
+ case anyConstraint:
+ return true
+ case noneConstraint:
+ return false
+ case versionTypeUnion:
+ return tc.MatchesAny(v)
+ case semVersion:
+ return v.sv.Equal(tc.sv)
+ case semverConstraint:
+ return tc.Intersect(v) != none
+ case versionPair:
+ if tc2, ok := tc.v.(semVersion); ok {
+ return tc2.sv.Equal(v.sv)
+ }
+ }
+
+ return false
+}
+
+func (v semVersion) Intersect(c Constraint) Constraint {
+ switch tc := c.(type) {
+ case anyConstraint:
+ return v
+ case noneConstraint:
+ return none
+ case versionTypeUnion:
+ return tc.Intersect(v)
+ case semVersion:
+ if v.sv.Equal(tc.sv) {
+ return v
+ }
+ case semverConstraint:
+ return tc.Intersect(v)
+ case versionPair:
+ if tc2, ok := tc.v.(semVersion); ok {
+ if v.sv.Equal(tc2.sv) {
+ return v
+ }
+ }
+ }
+
+ return none
+}
+
+func (v semVersion) Is(r Revision) PairedVersion {
+ return versionPair{
+ v: v,
+ r: r,
+ }
+}
+
+type versionPair struct {
+ v UnpairedVersion
+ r Revision
+}
+
+func (v versionPair) String() string {
+ return v.v.String()
+}
+
+func (v versionPair) Type() string {
+ return v.v.Type()
+}
+
+func (v versionPair) Underlying() Revision {
+ return v.r
+}
+
+func (v versionPair) Matches(v2 Version) bool {
+ switch tv2 := v2.(type) {
+ case versionTypeUnion:
+ return tv2.Matches(v)
+ case versionPair:
+ return v.r == tv2.r
+ case Revision:
+ return v.r == tv2
+ }
+
+ switch tv := v.v.(type) {
+ case plainVersion:
+ if tv.Matches(v2) {
+ return true
+ }
+ case branchVersion:
+ if tv.Matches(v2) {
+ return true
+ }
+ case semVersion:
+ if tv2, ok := v2.(semVersion); ok {
+ if tv.sv.Equal(tv2.sv) {
+ return true
+ }
+ }
+ }
+
+ return false
+}
+
+func (v versionPair) MatchesAny(c2 Constraint) bool {
+ return c2.Matches(v)
+}
+
+func (v versionPair) Intersect(c2 Constraint) Constraint {
+ switch tc := c2.(type) {
+ case anyConstraint:
+ return v
+ case noneConstraint:
+ return none
+ case versionTypeUnion:
+ return tc.Intersect(v)
+ case versionPair:
+ if v.r == tc.r {
+ return v.r
+ }
+ case Revision:
+ if v.r == tc {
+ return v.r
+ }
+ case semverConstraint:
+ if tv, ok := v.v.(semVersion); ok {
+ if tc.Intersect(tv) == v.v {
+ return v
+ }
+ }
+ // If the semver intersection failed, we know nothing could work
+ return none
+ }
+
+ switch tv := v.v.(type) {
+ case plainVersion, branchVersion:
+ if c2.Matches(v) {
+ return v
+ }
+ case semVersion:
+ if tv2, ok := c2.(semVersion); ok {
+ if tv.sv.Equal(tv2.sv) {
+ return v
+ }
+ }
+ }
+
+ return none
+}
+
+// compareVersionType is a sort func helper that makes a coarse-grained sorting
+// decision based on version type.
+//
+// Make sure that l and r have already been converted from versionPair (if
+// applicable).
+func compareVersionType(l, r Version) int {
+ // Big fugly double type switch. No reflect, because this can be smack in a hot loop
+ switch l.(type) {
+ case Revision:
+ switch r.(type) {
+ case Revision:
+ return 0
+ case branchVersion, plainVersion, semVersion:
+ return 1
+ default:
+ panic("unknown version type")
+ }
+ case branchVersion:
+ switch r.(type) {
+ case Revision:
+ return -1
+ case branchVersion:
+ return 0
+ case plainVersion, semVersion:
+ return 1
+ default:
+ panic("unknown version type")
+ }
+
+ case plainVersion:
+ switch r.(type) {
+ case Revision, branchVersion:
+ return -1
+ case plainVersion:
+ return 0
+ case semVersion:
+ return 1
+ default:
+ panic("unknown version type")
+ }
+
+ case semVersion:
+ switch r.(type) {
+ case Revision, branchVersion, plainVersion:
+ return -1
+ case semVersion:
+ return 0
+ default:
+ panic("unknown version type")
+ }
+ default:
+ panic("unknown version type")
+ }
+}
diff --git a/vendor/github.com/sdboyer/gps/version_queue.go b/vendor/github.com/sdboyer/gps/version_queue.go
new file mode 100644
index 0000000..e74a1da
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/version_queue.go
@@ -0,0 +1,142 @@
+package gps
+
+import (
+ "fmt"
+ "strings"
+)
+
+type failedVersion struct {
+ v Version
+ f error
+}
+
+type versionQueue struct {
+ id ProjectIdentifier
+ pi []Version
+ lockv, prefv Version
+ fails []failedVersion
+ b sourceBridge
+ failed bool
+ allLoaded bool
+}
+
+func newVersionQueue(id ProjectIdentifier, lockv, prefv Version, b sourceBridge) (*versionQueue, error) {
+ vq := &versionQueue{
+ id: id,
+ b: b,
+ }
+
+ // Lock goes in first, if present
+ if lockv != nil {
+ vq.lockv = lockv
+ vq.pi = append(vq.pi, lockv)
+ }
+
+ // Preferred version next
+ if prefv != nil {
+ vq.prefv = prefv
+ vq.pi = append(vq.pi, prefv)
+ }
+
+ if len(vq.pi) == 0 {
+ var err error
+ vq.pi, err = vq.b.listVersions(vq.id)
+ if err != nil {
+ // TODO(sdboyer) pushing this error this early entails that we
+ // unconditionally deep scan (e.g. vendor), as well as hitting the
+ // network.
+ return nil, err
+ }
+ vq.allLoaded = true
+ }
+
+ return vq, nil
+}
+
+func (vq *versionQueue) current() Version {
+ if len(vq.pi) > 0 {
+ return vq.pi[0]
+ }
+
+ return nil
+}
+
+// advance moves the versionQueue forward to the next available version,
+// recording the failure that eliminated the current version.
+func (vq *versionQueue) advance(fail error) (err error) {
+ // Nothing in the queue means...nothing in the queue, nicely enough
+ if len(vq.pi) == 0 {
+ return
+ }
+
+ // Record the fail reason and pop the queue
+ vq.fails = append(vq.fails, failedVersion{
+ v: vq.pi[0],
+ f: fail,
+ })
+ vq.pi = vq.pi[1:]
+
+ // *now*, if the queue is empty, ensure all versions have been loaded
+ if len(vq.pi) == 0 {
+ if vq.allLoaded {
+ // This branch gets hit when the queue is first fully exhausted,
+ // after having been populated by ListVersions() on a previous
+ // advance()
+ return
+ }
+
+ vq.allLoaded = true
+ vq.pi, err = vq.b.listVersions(vq.id)
+ if err != nil {
+ return err
+ }
+
+ // search for and remove locked and pref versions
+ //
+ // could use the version comparator for binary search here to avoid
+ // O(n) each time...if it matters
+ for k, pi := range vq.pi {
+ if pi == vq.lockv || pi == vq.prefv {
+ // GC-safe deletion for slice w/pointer elements
+ vq.pi, vq.pi[len(vq.pi)-1] = append(vq.pi[:k], vq.pi[k+1:]...), nil
+ //vq.pi = append(vq.pi[:k], vq.pi[k+1:]...)
+ }
+ }
+
+ if len(vq.pi) == 0 {
+ // If listing versions added nothing (new), then return now
+ return
+ }
+ }
+
+ // We're finally sure that there's something in the queue. Remove the
+ // failure marker, as the current version may have failed, but the next one
+ // hasn't yet
+ vq.failed = false
+
+ // If all have been loaded and the queue is empty, we're definitely out
+ // of things to try. Return empty, though, because vq semantics dictate
+ // that we don't explicitly indicate the end of the queue here.
+ return
+}
+
+// isExhausted indicates whether or not the queue has definitely been exhausted,
+// in which case it will return true.
+//
+// It may return false negatives - suggesting that there is more in the queue
+// when a subsequent call to current() will be empty. Plan accordingly.
+func (vq *versionQueue) isExhausted() bool {
+ if !vq.allLoaded {
+ return false
+ }
+ return len(vq.pi) == 0
+}
+
+func (vq *versionQueue) String() string {
+ var vs []string
+
+ for _, v := range vq.pi {
+ vs = append(vs, v.String())
+ }
+ return fmt.Sprintf("[%s]", strings.Join(vs, ", "))
+}
diff --git a/vendor/github.com/sdboyer/gps/version_test.go b/vendor/github.com/sdboyer/gps/version_test.go
new file mode 100644
index 0000000..f8b9b89
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/version_test.go
@@ -0,0 +1,103 @@
+package gps
+
+import (
+ "sort"
+ "testing"
+)
+
+func TestVersionSorts(t *testing.T) {
+ rev := Revision("flooboofoobooo")
+ v1 := NewBranch("master").Is(rev)
+ v2 := NewBranch("test").Is(rev)
+ v3 := NewVersion("1.0.0").Is(rev)
+ v4 := NewVersion("1.0.1")
+ v5 := NewVersion("v2.0.5")
+ v6 := NewVersion("2.0.5.2")
+ v7 := NewBranch("unwrapped")
+ v8 := NewVersion("20.0.5.2")
+
+ start := []Version{
+ v1,
+ v2,
+ v3,
+ v4,
+ v5,
+ v6,
+ v7,
+ v8,
+ rev,
+ }
+
+ down := make([]Version, len(start))
+ copy(down, start)
+ up := make([]Version, len(start))
+ copy(up, start)
+
+ edown := []Version{
+ v3, v4, v5, // semvers
+ v6, v8, // plain versions
+ v1, v2, v7, // floating/branches
+ rev, // revs
+ }
+
+ eup := []Version{
+ v5, v4, v3, // semvers
+ v6, v8, // plain versions
+ v1, v2, v7, // floating/branches
+ rev, // revs
+ }
+
+ sort.Sort(upgradeVersionSorter(up))
+ var wrong []int
+ for k, v := range up {
+ if eup[k] != v {
+ wrong = append(wrong, k)
+ t.Errorf("Expected version %s in position %v on upgrade sort, but got %s", eup[k], k, v)
+ }
+ }
+ if len(wrong) > 0 {
+ // Just helps with readability a bit
+ t.Errorf("Upgrade sort positions with wrong versions: %v", wrong)
+ }
+
+ sort.Sort(downgradeVersionSorter(down))
+ wrong = wrong[:0]
+ for k, v := range down {
+ if edown[k] != v {
+ wrong = append(wrong, k)
+ t.Errorf("Expected version %s in position %v on downgrade sort, but got %s", edown[k], k, v)
+ }
+ }
+ if len(wrong) > 0 {
+ // Just helps with readability a bit
+ t.Errorf("Downgrade sort positions with wrong versions: %v", wrong)
+ }
+
+ // Now make sure we sort back the other way correctly...just because
+ sort.Sort(upgradeVersionSorter(down))
+ wrong = wrong[:0]
+ for k, v := range down {
+ if eup[k] != v {
+ wrong = append(wrong, k)
+ t.Errorf("Expected version %s in position %v on down-then-upgrade sort, but got %s", eup[k], k, v)
+ }
+ }
+ if len(wrong) > 0 {
+ // Just helps with readability a bit
+ t.Errorf("Down-then-upgrade sort positions with wrong versions: %v", wrong)
+ }
+
+ // Now make sure we sort back the other way correctly...just because
+ sort.Sort(downgradeVersionSorter(up))
+ wrong = wrong[:0]
+ for k, v := range up {
+ if edown[k] != v {
+ wrong = append(wrong, k)
+ t.Errorf("Expected version %s in position %v on up-then-downgrade sort, but got %s", edown[k], k, v)
+ }
+ }
+ if len(wrong) > 0 {
+ // Just helps with readability a bit
+ t.Errorf("Up-then-downgrade sort positions with wrong versions: %v", wrong)
+ }
+}
diff --git a/vendor/github.com/termie/go-shutil/.gitignore b/vendor/github.com/termie/go-shutil/.gitignore
new file mode 100644
index 0000000..139b1ee
--- /dev/null
+++ b/vendor/github.com/termie/go-shutil/.gitignore
@@ -0,0 +1 @@
+test/testfile3
diff --git a/vendor/github.com/termie/go-shutil/LICENSE b/vendor/github.com/termie/go-shutil/LICENSE
new file mode 100644
index 0000000..3890b94
--- /dev/null
+++ b/vendor/github.com/termie/go-shutil/LICENSE
@@ -0,0 +1 @@
+I guess Python's? If that doesn't apply then MIT. Have fun.
diff --git a/vendor/github.com/termie/go-shutil/README.rst b/vendor/github.com/termie/go-shutil/README.rst
new file mode 100644
index 0000000..b63b016
--- /dev/null
+++ b/vendor/github.com/termie/go-shutil/README.rst
@@ -0,0 +1,24 @@
+=========================================
+High-level Filesystem Operations (for Go)
+=========================================
+
+
+A direct port of a few of the functions from Python's shutil package for
+high-level filesystem operations.
+
+This project pretty much only exists so that other people don't have to keep
+re-writing this code in their projects, at this time we have been unable to
+find any helpful packages for this in the stdlib or elsewhere.
+
+We don't expect it to be perfect, just better than whatever your first draft
+would have been. Patches welcome.
+
+See also: https://docs.python.org/3.5/library/shutil.html
+
+================
+Functions So Far
+================
+
+We support Copy, CopyFile, CopyMode, and CopyTree. CopyStat would be nice if
+anybody wants to write that. Also the other functions that might be useful in
+the python library :D
diff --git a/vendor/github.com/termie/go-shutil/shutil.go b/vendor/github.com/termie/go-shutil/shutil.go
new file mode 100644
index 0000000..09fcd38
--- /dev/null
+++ b/vendor/github.com/termie/go-shutil/shutil.go
@@ -0,0 +1,326 @@
+package shutil
+
+import (
+ "fmt"
+ "io"
+ "io/ioutil"
+ "os"
+ "path/filepath"
+)
+
+
+type SameFileError struct {
+ Src string
+ Dst string
+}
+
+func (e SameFileError) Error() string {
+ return fmt.Sprintf("%s and %s are the same file", e.Src, e.Dst)
+}
+
+type SpecialFileError struct {
+ File string
+ FileInfo os.FileInfo
+}
+
+func (e SpecialFileError) Error() string {
+ return fmt.Sprintf("`%s` is a named pipe", e.File)
+}
+
+type NotADirectoryError struct {
+ Src string
+}
+
+func (e NotADirectoryError) Error() string {
+ return fmt.Sprintf("`%s` is not a directory", e.Src)
+}
+
+
+type AlreadyExistsError struct {
+ Dst string
+}
+
+func (e AlreadyExistsError) Error() string {
+ return fmt.Sprintf("`%s` already exists", e.Dst)
+}
+
+
+func samefile(src string, dst string) bool {
+ srcInfo, _ := os.Stat(src)
+ dstInfo, _ := os.Stat(dst)
+ return os.SameFile(srcInfo, dstInfo)
+}
+
+func specialfile(fi os.FileInfo) bool {
+ return (fi.Mode() & os.ModeNamedPipe) == os.ModeNamedPipe
+}
+
+func stringInSlice(a string, list []string) bool {
+ for _, b := range list {
+ if b == a {
+ return true
+ }
+ }
+ return false
+}
+
+func IsSymlink(fi os.FileInfo) bool {
+ return (fi.Mode() & os.ModeSymlink) == os.ModeSymlink
+}
+
+
+// Copy data from src to dst
+//
+// If followSymlinks is not set and src is a symbolic link, a
+// new symlink will be created instead of copying the file it points
+// to.
+func CopyFile(src, dst string, followSymlinks bool) (error) {
+ if samefile(src, dst) {
+ return &SameFileError{src, dst}
+ }
+
+ // Make sure src exists and neither are special files
+ srcStat, err := os.Lstat(src)
+ if err != nil {
+ return err
+ }
+ if specialfile(srcStat) {
+ return &SpecialFileError{src, srcStat}
+ }
+
+ dstStat, err := os.Stat(dst)
+ if err != nil && !os.IsNotExist(err) {
+ return err
+ } else if err == nil {
+ if specialfile(dstStat) {
+ return &SpecialFileError{dst, dstStat}
+ }
+ }
+
+ // If we don't follow symlinks and it's a symlink, just link it and be done
+ if !followSymlinks && IsSymlink(srcStat) {
+ return os.Symlink(src, dst)
+ }
+
+ // If we are a symlink, follow it
+ if IsSymlink(srcStat) {
+ src, err = os.Readlink(src)
+ if err != nil {
+ return err
+ }
+ srcStat, err = os.Stat(src)
+ if err != nil {
+ return err
+ }
+ }
+
+ // Do the actual copy
+ fsrc, err := os.Open(src)
+ if err != nil {
+ return err
+ }
+ defer fsrc.Close()
+
+ fdst, err := os.Create(dst)
+ if err != nil {
+ return err
+ }
+ defer fdst.Close()
+
+ size, err := io.Copy(fdst, fsrc)
+ if err != nil {
+ return err
+ }
+
+ if size != srcStat.Size() {
+ return fmt.Errorf("%s: %d/%d copied", src, size, srcStat.Size())
+ }
+
+ return nil
+}
+
+
+// Copy mode bits from src to dst.
+//
+// If followSymlinks is false, symlinks aren't followed if and only
+// if both `src` and `dst` are symlinks. If `lchmod` isn't available
+// and both are symlinks this does nothing. (I don't think lchmod is
+// available in Go)
+func CopyMode(src, dst string, followSymlinks bool) error {
+ srcStat, err := os.Lstat(src)
+ if err != nil {
+ return err
+ }
+
+ dstStat, err := os.Lstat(dst)
+ if err != nil {
+ return err
+ }
+
+ // They are both symlinks and we can't change mode on symlinks.
+ if !followSymlinks && IsSymlink(srcStat) && IsSymlink(dstStat) {
+ return nil
+ }
+
+ // Atleast one is not a symlink, get the actual file stats
+ srcStat, _ = os.Stat(src)
+ err = os.Chmod(dst, srcStat.Mode())
+ return err
+}
+
+
+// Copy data and mode bits ("cp src dst"). Return the file's destination.
+//
+// The destination may be a directory.
+//
+// If followSymlinks is false, symlinks won't be followed. This
+// resembles GNU's "cp -P src dst".
+//
+// If source and destination are the same file, a SameFileError will be
+// rased.
+func Copy(src, dst string, followSymlinks bool) (string, error){
+ dstInfo, err := os.Stat(dst)
+
+ if err == nil && dstInfo.Mode().IsDir() {
+ dst = filepath.Join(dst, filepath.Base(src))
+ }
+
+ if err != nil && !os.IsNotExist(err) {
+ return dst, err
+ }
+
+ err = CopyFile(src, dst, followSymlinks)
+ if err != nil {
+ return dst, err
+ }
+
+ err = CopyMode(src, dst, followSymlinks)
+ if err != nil {
+ return dst, err
+ }
+
+ return dst, nil
+}
+
+type CopyTreeOptions struct {
+ Symlinks bool
+ IgnoreDanglingSymlinks bool
+ CopyFunction func (string, string, bool) (string, error)
+ Ignore func (string, []os.FileInfo) []string
+}
+
+// Recursively copy a directory tree.
+//
+// The destination directory must not already exist.
+//
+// If the optional Symlinks flag is true, symbolic links in the
+// source tree result in symbolic links in the destination tree; if
+// it is false, the contents of the files pointed to by symbolic
+// links are copied. If the file pointed by the symlink doesn't
+// exist, an error will be returned.
+//
+// You can set the optional IgnoreDanglingSymlinks flag to true if you
+// want to silence this error. Notice that this has no effect on
+// platforms that don't support os.Symlink.
+//
+// The optional ignore argument is a callable. If given, it
+// is called with the `src` parameter, which is the directory
+// being visited by CopyTree(), and `names` which is the list of
+// `src` contents, as returned by ioutil.ReadDir():
+//
+// callable(src, entries) -> ignoredNames
+//
+// Since CopyTree() is called recursively, the callable will be
+// called once for each directory that is copied. It returns a
+// list of names relative to the `src` directory that should
+// not be copied.
+//
+// The optional copyFunction argument is a callable that will be used
+// to copy each file. It will be called with the source path and the
+// destination path as arguments. By default, Copy() is used, but any
+// function that supports the same signature (like Copy2() when it
+// exists) can be used.
+func CopyTree(src, dst string, options *CopyTreeOptions) error {
+ if options == nil {
+ options = &CopyTreeOptions{Symlinks:false,
+ Ignore:nil,
+ CopyFunction:Copy,
+ IgnoreDanglingSymlinks:false}
+ }
+
+
+ srcFileInfo, err := os.Stat(src)
+ if err != nil {
+ return err
+ }
+
+ if !srcFileInfo.IsDir() {
+ return &NotADirectoryError{src}
+ }
+
+ _, err = os.Open(dst)
+ if !os.IsNotExist(err) {
+ return &AlreadyExistsError{dst}
+ }
+
+ entries, err := ioutil.ReadDir(src)
+ if err != nil {
+ return err
+ }
+
+ err = os.MkdirAll(dst, srcFileInfo.Mode())
+ if err != nil {
+ return err
+ }
+
+ ignoredNames := []string{}
+ if options.Ignore != nil {
+ ignoredNames = options.Ignore(src, entries)
+ }
+
+ for _, entry := range entries {
+ if stringInSlice(entry.Name(), ignoredNames) {
+ continue
+ }
+ srcPath := filepath.Join(src, entry.Name())
+ dstPath := filepath.Join(dst, entry.Name())
+
+ entryFileInfo, err := os.Lstat(srcPath)
+ if err != nil {
+ return err
+ }
+
+ // Deal with symlinks
+ if IsSymlink(entryFileInfo) {
+ linkTo, err := os.Readlink(srcPath)
+ if err != nil {
+ return err
+ }
+ if options.Symlinks {
+ os.Symlink(linkTo, dstPath)
+ //CopyStat(srcPath, dstPath, false)
+ } else {
+ // ignore dangling symlink if flag is on
+ _, err = os.Stat(linkTo)
+ if os.IsNotExist(err) && options.IgnoreDanglingSymlinks {
+ continue
+ }
+ _, err = options.CopyFunction(srcPath, dstPath, false)
+ if err != nil {
+ return err
+ }
+ }
+ } else if entryFileInfo.IsDir() {
+ err = CopyTree(srcPath, dstPath, options)
+ if err != nil {
+ return err
+ }
+ } else {
+ _, err = options.CopyFunction(srcPath, dstPath, false)
+ if err != nil {
+ return err
+ }
+ }
+ }
+ return nil
+}
diff --git a/vendor/github.com/termie/go-shutil/shutil_test.go b/vendor/github.com/termie/go-shutil/shutil_test.go
new file mode 100644
index 0000000..f6ec261
--- /dev/null
+++ b/vendor/github.com/termie/go-shutil/shutil_test.go
@@ -0,0 +1,156 @@
+package shutil
+
+import (
+ "bytes"
+ "io/ioutil"
+ "os"
+ "testing"
+)
+
+
+func filesMatch(src, dst string) (bool, error) {
+ srcContents, err := ioutil.ReadFile(src)
+ if err != nil {
+ return false, err
+ }
+
+ dstContents, err := ioutil.ReadFile(dst)
+ if err != nil {
+ return false, err
+ }
+
+ if bytes.Compare(srcContents, dstContents) != 0 {
+ return false, nil
+ }
+ return true, nil
+}
+
+
+func TestSameFileError(t *testing.T) {
+ _, err := Copy("test/testfile", "test/testfile", false)
+ _, ok := err.(*SameFileError)
+ if !ok {
+ t.Error(err)
+ }
+}
+
+
+func TestCopyFile(t *testing.T) {
+ // clear out existing files if they exist
+ os.Remove("test/testfile3")
+
+ err := CopyFile("test/testfile", "test/testfile3", false)
+ if err != nil {
+ t.Error(err)
+ return
+ }
+
+ match, err := filesMatch("test/testfile", "test/testfile3")
+ if err != nil {
+ t.Error(err)
+ return
+ }
+ if !match {
+ t.Fail()
+ return
+ }
+
+ // And again without clearing the files
+ err = CopyFile("test/testfile2", "test/testfile3", false)
+ if err != nil {
+ t.Error(err)
+ return
+ }
+
+ match2, err := filesMatch("test/testfile2", "test/testfile3")
+ if err != nil {
+ t.Error(err)
+ return
+ }
+
+ if !match2 {
+ t.Fail()
+ return
+ }
+}
+
+
+func TestCopy(t *testing.T) {
+ // clear out existing files if they exist
+ os.Remove("test/testfile3")
+
+ _, err := Copy("test/testfile", "test/testfile3", false)
+ if err != nil {
+ t.Error(err)
+ return
+ }
+
+ match, err := filesMatch("test/testfile", "test/testfile3")
+ if err != nil {
+ t.Error(err)
+ return
+ }
+ if !match {
+ t.Fail()
+ return
+ }
+
+ // And again without clearing the files
+ _, err = Copy("test/testfile2", "test/testfile3", false)
+ if err != nil {
+ t.Error(err)
+ return
+ }
+
+ match2, err := filesMatch("test/testfile2", "test/testfile3")
+ if err != nil {
+ t.Error(err)
+ return
+ }
+
+ if !match2 {
+ t.Fail()
+ return
+ }
+}
+
+
+func TestCopyTree(t *testing.T) {
+ // clear out existing files if they exist
+ os.RemoveAll("test/testdir3")
+
+ err := CopyTree("test/testdir", "test/testdir3", nil)
+ if err != nil {
+ t.Error(err)
+ return
+ }
+
+ match, err := filesMatch("test/testdir/file1", "test/testdir3/file1")
+ if err != nil {
+ t.Error(err)
+ return
+ }
+ if !match {
+ t.Fail()
+ return
+ }
+
+ // // And again without clearing the files
+ // _, err = Copy("test/testfile2", "test/testfile3", false)
+ // if err != nil {
+ // t.Error(err)
+ // return
+ // }
+
+ // match2, err := filesMatch("test/testfile2", "test/testfile3")
+ // if err != nil {
+ // t.Error(err)
+ // return
+ // }
+
+ // if !match2 {
+ // t.Fail()
+ // return
+ // }
+}
+
diff --git a/vendor/github.com/termie/go-shutil/test/testdir/file1 b/vendor/github.com/termie/go-shutil/test/testdir/file1
new file mode 100644
index 0000000..e212970
--- /dev/null
+++ b/vendor/github.com/termie/go-shutil/test/testdir/file1
@@ -0,0 +1 @@
+file1
diff --git a/vendor/github.com/termie/go-shutil/test/testdir/file2 b/vendor/github.com/termie/go-shutil/test/testdir/file2
new file mode 100644
index 0000000..6c493ff
--- /dev/null
+++ b/vendor/github.com/termie/go-shutil/test/testdir/file2
@@ -0,0 +1 @@
+file2
diff --git a/vendor/github.com/termie/go-shutil/test/testfile b/vendor/github.com/termie/go-shutil/test/testfile
new file mode 100644
index 0000000..2691857
--- /dev/null
+++ b/vendor/github.com/termie/go-shutil/test/testfile
@@ -0,0 +1 @@
+testfile
diff --git a/vendor/github.com/termie/go-shutil/test/testfile2 b/vendor/github.com/termie/go-shutil/test/testfile2
new file mode 100644
index 0000000..7d57647
--- /dev/null
+++ b/vendor/github.com/termie/go-shutil/test/testfile2
@@ -0,0 +1 @@
+testfile2
