diff --git a/glide.lock b/glide.lock
index 49bed7b..e9e7e6b 100644
--- a/glide.lock
+++ b/glide.lock
@@ -10,7 +10,7 @@
 - name: github.com/Masterminds/vcs
   version: fbe9fb6ad5b5f35b3e82a7c21123cfc526cbf895
 - name: github.com/sdboyer/gps
-  version: a868c10855893c21ed05d0f50d6f9acb12b6366d
+  version: 63a033c13497e9f5ca47f5f6d4e02455f5d4d85d
 - name: github.com/termie/go-shutil
   version: bcacb06fecaeec8dc42af03c87c6949f4a05c74c
 - name: gopkg.in/yaml.v2
diff --git a/vendor/github.com/sdboyer/gps/README.md b/vendor/github.com/sdboyer/gps/README.md
index 227bf6b..2cd2d99 100644
--- a/vendor/github.com/sdboyer/gps/README.md
+++ b/vendor/github.com/sdboyer/gps/README.md
@@ -1,91 +1,110 @@
-# gps
-![map-marker-icon copy](https://cloud.githubusercontent.com/assets/21599/16779217/4f5cdc6c-483f-11e6-9de3-661f13d9b215.png)
+<p align="center">
+<img 
+    src="header.png"
+    width="800" height="255" border="0" alt="gps">
+<br>
+<a href="https://circleci.com/gh/sdboyer/gps"><img src="https://circleci.com/gh/sdboyer/gps.svg?style=svg" alt="Build Status"></a>
+<a href="https://ci.appveyor.com/project/sdboyer/gps"><img src="https://ci.appveyor.com/api/projects/status/github/sdboyer/gps?svg=true&branch=master&passingText=Windows%20-%20OK&failingText=Windows%20-%20failed&pendingText=Windows%20-%20pending" alt="Windows Build Status"></a>
+<a href="https://goreportcard.com/report/github.com/sdboyer/gps"><img src="https://goreportcard.com/badge/github.com/sdboyer/gps" alt="Build Status"></a>
+<a href="https://codecov.io/gh/sdboyer/gps"><img src="https://codecov.io/gh/sdboyer/gps/branch/master/graph/badge.svg" alt="Codecov" /></a>
+<a href="https://godoc.org/github.com/sdboyer/gps"><img src="https://godoc.org/github.com/sdboyer/gps?status.svg" alt="GoDoc"></a>
+</p>
+
 --
 
-[![CircleCI](https://circleci.com/gh/sdboyer/gps.svg?style=svg)](https://circleci.com/gh/sdboyer/gps) [![Go Report Card](https://goreportcard.com/badge/github.com/sdboyer/gps)](https://goreportcard.com/report/github.com/sdboyer/gps) [![GoDoc](https://godoc.org/github.com/sdboyer/gps?status.svg)](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`.
+management problems in Go. It is trivial - [about 35 lines of
+code](https://github.com/sdboyer/gps/blob/master/example.go) - to replicate the
+fetching bits of `go get` using `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).
+way. It is a distillation of the ideas behind language package managers like
+[bundler](http://bundler.io), [npm](https://www.npmjs.com/),
+[elm-package](https://github.com/elm-lang/elm-package),
+[cargo](https://crates.io/) (and others) into a library, artisanally
+handcrafted with ❤️ for Go's specific requirements.
+
+`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).
+to contribute](https://github.com/sdboyer/gps/wiki/gps-for-Contributors).
 
-**`gps` is progressing rapidly, but still beta, with a liberal sprinkling of panics.**
+**`gps` is progressing rapidly, but still in beta, with a concomitantly liberal sprinkling of panics.**
 
 ## Wait...a package management _library_?!
 
-Yup. Because it's what the Go ecosystem needs right now.
+Yup. See [the rationale](https://github.com/sdboyer/gps/wiki/Rationale).
 
-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.
+## Features
 
-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.
+A feature list for a package management library is a bit different than one for
+a package management tool. Instead of listing the things an end-user can do,
+we list the choices a tool *can* make and offer, in some form, to its users, as
+well as the non-choices/assumptions/constraints that `gps` imposes on a tool.
 
-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.
+### Non-Choices
 
-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.
+We'd love for `gps`'s non-choices to be noncontroversial. But that's not always
+the case.
 
-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.
+Nevertheless, these non-choices remain because, taken as a whole, they make
+experiments and discussion around Go package management coherent and
+productive.
 
-### Assumptions
+* Go >=1.6, or 1.5 with `GO15VENDOREXPERIMENT = 1` set
+* Everything under `vendor/` is volatile and controlled solely by the tool
+* A central cache of repositories is used (cannot be `GOPATH`)
+* A [**project**](https://godoc.org/github.com/sdboyer/gps#ProjectRoot) concept:
+  a tree of packages, all covered by one `vendor` directory
+* A [**manifest** and
+  **lock**](https://github.com/sdboyer/gps/wiki/gps-for-Implementors#manifests-and-locks)
+  approach to tracking version and constraint information
+* Source repositories can be `git`, `bzr`, `hg` or `svn` (Most of the work here is through a [separate lib](https://github.com/Masterminds/vcs))
+* What the available versions are for a given project/repository (all branches, tags, or revs are eligible)
+  * In general, semver tags are preferred to plain tags, are preferred to branches
+* The actual packages required (determined through import graph static analysis)
+  * How the import graph is statically analyzed (Similar to `go/build`, but with a combinatorial view of build tags)
+* Package import cycles are not allowed ([not yet implemented](https://github.com/sdboyer/gps/issues/66))
 
-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.
+There are also some current non-choices that we would like to push into the realm of choice:
 
-* 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.
+* Different versions of packages from the same repository cannot be used
+* Importable projects that are not bound to the repository root
+* Source inference around different import path patterns (e.g., how `github.com/*` or `my_company/*` are handled)
 
-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.
+### Choices
+
+These choices represent many of the ways that `gps`-based tools could
+substantively differ from each other.
+
+Some of these are choices designed to encompass all options for topics on which
+reasonable people have disagreed. Others are simply important controls that no
+general library could know _a priori_.
+
+* How to store manifest and lock information (file(s)? a db?)
+* Which of the other package managers to interoperate with
+* Which types of version constraints to allow the user to specify (e.g., allowing [semver ranges](https://docs.npmjs.com/misc/semver) or not)
+* Whether or not to strip nested `vendor` directories
+* Which packages in the import graph to [ignore](https://github.com/sdboyer/gps/wiki/gps-for-Implementors#ignoring-packages) (if any)
+* What constraint [overrides](https://github.com/sdboyer/gps/wiki/gps-for-Implementors#overrides) to apply (if any)
+* What [informational output](https://github.com/sdboyer/gps/wiki/gps-for-Implementors#trace-and-tracelogger) to show the end user
+* What dependency version constraints are declared by the [root project](https://github.com/sdboyer/gps/wiki/gps-for-Implementors#manifest-data)
+* What dependency version constraints are declared by [all dependencies](https://github.com/sdboyer/gps/wiki/gps-for-Implementors#the-projectanalyzer)
+* Given a [previous solution](https://github.com/sdboyer/gps/wiki/gps-for-Implementors#lock-data), [which versions to let change, and how](https://github.com/sdboyer/gps/wiki/gps-for-Implementors#tochange-changeall-and-downgrade)
+  * In the absence of a previous solution, whether or not to use [preferred versions](https://github.com/sdboyer/gps/wiki/gps-for-Implementors#preferred-versions)
+* Allowing, or not, the user to [swap in different network names](https://github.com/sdboyer/gps/wiki/gps-for-Implementors#projectidentifier) for import paths (e.g. forks)
+* Specifying additional input/source packages not reachable from the root import graph ([not complete](https://github.com/sdboyer/gps/issues/42))
+
+This list may not be exhaustive - see the
+[implementor's guide](https://github.com/sdboyer/gps/wiki/gps-for-Implementors)
+for a proper treatment.
 
 ## Contributing
 
diff --git a/vendor/github.com/sdboyer/gps/appveyor.yml b/vendor/github.com/sdboyer/gps/appveyor.yml
index 9bf23a3..8c6b1fd 100644
--- a/vendor/github.com/sdboyer/gps/appveyor.yml
+++ b/vendor/github.com/sdboyer/gps/appveyor.yml
@@ -12,7 +12,7 @@
 install:
   - go version
   - go env
-  - choco install bzr hg
+  - choco install bzr
   - set PATH=C:\Program Files (x86)\Bazaar\;C:\Program Files\Mercurial\;%PATH%
 build_script:
   - go get github.com/Masterminds/glide
@@ -20,5 +20,6 @@
 
 test_script:
   - go test
+  - go build example.go
 
 deploy: off
diff --git a/vendor/github.com/sdboyer/gps/bridge.go b/vendor/github.com/sdboyer/gps/bridge.go
index 8b26e6b..2aae74b 100644
--- a/vendor/github.com/sdboyer/gps/bridge.go
+++ b/vendor/github.com/sdboyer/gps/bridge.go
@@ -5,37 +5,27 @@
 	"os"
 	"path/filepath"
 	"sort"
+
+	"github.com/Masterminds/semver"
 )
 
 // 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)
+	SourceManager // composes SourceManager
+	verifyRootDir(path string) 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.
@@ -60,7 +50,7 @@
 	// 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
+	vlists map[ProjectIdentifier][]Version
 }
 
 // Global factory func to create a bridge. This exists solely to allow tests to
@@ -69,34 +59,27 @@
 	return &bridge{
 		sm:     sm,
 		s:      s,
-		vlists: make(map[ProjectRoot][]Version),
+		vlists: make(map[ProjectIdentifier][]Version),
 	}
 }
 
-func (b *bridge) getProjectInfo(pa atom) (Manifest, Lock, error) {
-	if pa.id.ProjectRoot == b.s.params.ImportRoot {
+func (b *bridge) GetManifestAndLock(id ProjectIdentifier, v Version) (Manifest, Lock, error) {
+	if id.ProjectRoot == b.s.params.ImportRoot {
 		return b.s.rm, b.s.rl, nil
 	}
-	return b.sm.GetProjectInfo(ProjectRoot(pa.id.netName()), pa.v)
+	return b.sm.GetManifestAndLock(id, v)
 }
 
-func (b *bridge) key(id ProjectIdentifier) ProjectRoot {
-	k := ProjectRoot(id.NetworkName)
-	if k == "" {
-		k = id.ProjectRoot
-	}
-
-	return k
+func (b *bridge) AnalyzerInfo() (string, *semver.Version) {
+	return b.sm.AnalyzerInfo()
 }
 
-func (b *bridge) listVersions(id ProjectIdentifier) ([]Version, error) {
-	k := b.key(id)
-
-	if vl, exists := b.vlists[k]; exists {
+func (b *bridge) ListVersions(id ProjectIdentifier) ([]Version, error) {
+	if vl, exists := b.vlists[id]; exists {
 		return vl, nil
 	}
 
-	vl, err := b.sm.ListVersions(k)
+	vl, err := b.sm.ListVersions(id)
 	// TODO(sdboyer) cache errors, too?
 	if err != nil {
 		return nil, err
@@ -108,18 +91,16 @@
 		sort.Sort(upgradeVersionSorter(vl))
 	}
 
-	b.vlists[k] = vl
+	b.vlists[id] = 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) RevisionPresentIn(id ProjectIdentifier, r Revision) (bool, error) {
+	return b.sm.RevisionPresentIn(id, r)
 }
 
-func (b *bridge) repoExists(id ProjectIdentifier) (bool, error) {
-	k := b.key(id)
-	return b.sm.RepoExists(k)
+func (b *bridge) SourceExists(id ProjectIdentifier) (bool, error) {
+	return b.sm.SourceExists(id)
 }
 
 func (b *bridge) vendorCodeExists(id ProjectIdentifier) (bool, error) {
@@ -134,7 +115,7 @@
 }
 
 func (b *bridge) pairVersion(id ProjectIdentifier, v UnpairedVersion) PairedVersion {
-	vl, err := b.listVersions(id)
+	vl, err := b.ListVersions(id)
 	if err != nil {
 		return nil
 	}
@@ -152,7 +133,7 @@
 }
 
 func (b *bridge) pairRevision(id ProjectIdentifier, r Revision) []Version {
-	vl, err := b.listVersions(id)
+	vl, err := b.ListVersions(id)
 	if err != nil {
 		return nil
 	}
@@ -402,14 +383,17 @@
 //
 // 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) {
+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)
+	return b.sm.ListPackages(id, v)
+}
+
+func (b *bridge) ExportProject(id ProjectIdentifier, v Version, path string) error {
+	//return b.sm.ExportProject(id, v, path)
+	panic("bridge should never be used to ExportProject")
 }
 
 // verifyRoot ensures that the provided path to the project root is in good
@@ -425,10 +409,8 @@
 	return nil
 }
 
-// deduceRemoteRepo deduces certain network-oriented properties about an import
-// path.
-func (b *bridge) deduceRemoteRepo(path string) (*remoteRepo, error) {
-	return deduceRemoteRepo(path)
+func (b *bridge) DeduceProjectRoot(ip string) (ProjectRoot, error) {
+	return b.sm.DeduceProjectRoot(ip)
 }
 
 // versionTypeUnion represents a set of versions that are, within the scope of
diff --git a/vendor/github.com/sdboyer/gps/circle.yml b/vendor/github.com/sdboyer/gps/circle.yml
index 5723c35..8be1609 100644
--- a/vendor/github.com/sdboyer/gps/circle.yml
+++ b/vendor/github.com/sdboyer/gps/circle.yml
@@ -1,19 +1,23 @@
 machine:
-    environment:
-        GO15VENDOREXPERIMENT: 1
-checkout:
-    post:
+  environment:
+    GO15VENDOREXPERIMENT: 1
+    PROJECT_ROOT: "github.com/$CIRCLE_PROJECT_USERNAME/$CIRCLE_PROJECT_REPONAME"
+    RD: "$HOME/.go_workspace/src/$PROJECT_ROOT"
 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"
+  pre:
+    - 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
+  override:
+    - glide --home $HOME/.glide -y glide.yaml install --cache
+    - mkdir -p $RD
+    - rsync -azC --delete ./ $RD
+    #- ln -Tsf "$HOME/$CIRCLE_PROJECT_REPONAME" "$HOME/.go_workspace/src/$PROJECT_ROOT"
+  cache_directories:
+    - "~/.glide"
 test:
-    override:
-        - cd $HOME/.go_workspace/src/github.com/$CIRCLE_PROJECT_USERNAME/$CIRCLE_PROJECT_REPONAME && go test
+  pre:
+    - go vet
+  override:
+    - cd $RD && go test -v -coverprofile=coverage.txt -covermode=atomic
+    - cd $RD && go build example.go
+    - cd $RD && bash <(curl -s https://codecov.io/bash)
diff --git a/vendor/github.com/sdboyer/gps/codecov.yml b/vendor/github.com/sdboyer/gps/codecov.yml
new file mode 100644
index 0000000..263381f
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/codecov.yml
@@ -0,0 +1,5 @@
+coverage:
+  ignore:
+  - remove_go16.go
+  - remove_go17.go
+  - errors.go
diff --git a/vendor/github.com/sdboyer/gps/constraints.go b/vendor/github.com/sdboyer/gps/constraints.go
index 43b8b09..affde86 100644
--- a/vendor/github.com/sdboyer/gps/constraints.go
+++ b/vendor/github.com/sdboyer/gps/constraints.go
@@ -2,6 +2,7 @@
 
 import (
 	"fmt"
+	"sort"
 
 	"github.com/Masterminds/semver"
 )
@@ -164,3 +165,126 @@
 func (noneConstraint) Intersect(Constraint) Constraint {
 	return none
 }
+
+// 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
+}
+
+type workingConstraint struct {
+	Ident                     ProjectIdentifier
+	Constraint                Constraint
+	overrNet, overrConstraint bool
+}
+
+type ProjectConstraints map[ProjectRoot]ProjectProperties
+
+func pcSliceToMap(l []ProjectConstraint, r ...[]ProjectConstraint) ProjectConstraints {
+	final := make(ProjectConstraints)
+
+	for _, pc := range l {
+		final[pc.Ident.ProjectRoot] = ProjectProperties{
+			NetworkName: pc.Ident.netName(),
+			Constraint:  pc.Constraint,
+		}
+	}
+
+	for _, pcs := range r {
+		for _, pc := range pcs {
+			if pp, exists := final[pc.Ident.ProjectRoot]; exists {
+				// Technically this should be done through a bridge for
+				// cross-version-type matching...but this is a one off for root and
+				// that's just ridiculous for this.
+				pp.Constraint = pp.Constraint.Intersect(pc.Constraint)
+				final[pc.Ident.ProjectRoot] = pp
+			} else {
+				final[pc.Ident.ProjectRoot] = ProjectProperties{
+					NetworkName: pc.Ident.netName(),
+					Constraint:  pc.Constraint,
+				}
+			}
+		}
+	}
+
+	return final
+}
+
+func (m ProjectConstraints) asSortedSlice() []ProjectConstraint {
+	pcs := make([]ProjectConstraint, len(m))
+
+	k := 0
+	for pr, pp := range m {
+		pcs[k] = ProjectConstraint{
+			Ident: ProjectIdentifier{
+				ProjectRoot: pr,
+				NetworkName: pp.NetworkName,
+			},
+			Constraint: pp.Constraint,
+		}
+		k++
+	}
+
+	sort.Stable(sortedConstraints(pcs))
+	return pcs
+}
+
+// overrideAll treats the ProjectConstraints map as an override map, and applies
+// overridden values to the input.
+//
+// A slice of workingConstraint is returned, allowing differentiation between
+// values that were or were not overridden.
+func (m ProjectConstraints) overrideAll(in []ProjectConstraint) (out []workingConstraint) {
+	out = make([]workingConstraint, len(in))
+	k := 0
+	for _, pc := range in {
+		out[k] = m.override(pc)
+		k++
+	}
+
+	return
+}
+
+// override replaces a single ProjectConstraint with a workingConstraint,
+// overriding its values if a corresponding entry exists in the
+// ProjectConstraints map.
+func (m ProjectConstraints) override(pc ProjectConstraint) workingConstraint {
+	wc := workingConstraint{
+		Ident:      pc.Ident.normalize(), // necessary to normalize?
+		Constraint: pc.Constraint,
+	}
+
+	if pp, has := m[pc.Ident.ProjectRoot]; has {
+		// The rule for overrides is that *any* non-zero value for the prop
+		// should be considered an override, even if it's equal to what's
+		// already there.
+		if pp.Constraint != nil {
+			wc.Constraint = pp.Constraint
+			wc.overrConstraint = true
+		}
+
+		if pp.NetworkName != "" {
+			wc.Ident.NetworkName = pp.NetworkName
+			wc.overrNet = true
+		}
+
+	}
+
+	return wc
+}
+
+type sortedConstraints []ProjectConstraint
+
+func (s sortedConstraints) Len() int {
+	return len(s)
+}
+
+func (s sortedConstraints) Swap(i, j int) {
+	s[i], s[j] = s[j], s[i]
+}
+
+func (s sortedConstraints) Less(i, j int) bool {
+	return s[i].Ident.less(s[j].Ident)
+}
diff --git a/vendor/github.com/sdboyer/gps/deduce.go b/vendor/github.com/sdboyer/gps/deduce.go
new file mode 100644
index 0000000..25dc93d
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/deduce.go
@@ -0,0 +1,777 @@
+package gps
+
+import (
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"path"
+	"regexp"
+	"strings"
+)
+
+var (
+	gitSchemes = []string{"https", "ssh", "git", "http"}
+	bzrSchemes = []string{"https", "bzr+ssh", "bzr", "http"}
+	hgSchemes  = []string{"https", "ssh", "http"}
+	svnSchemes = []string{"https", "http", "svn", "svn+ssh"}
+)
+
+func validateVCSScheme(scheme, typ string) bool {
+	// everything allows plain ssh
+	if scheme == "ssh" {
+		return true
+	}
+
+	var schemes []string
+	switch typ {
+	case "git":
+		schemes = gitSchemes
+	case "bzr":
+		schemes = bzrSchemes
+	case "hg":
+		schemes = hgSchemes
+	case "svn":
+		schemes = svnSchemes
+	default:
+		panic(fmt.Sprint("unsupported vcs type", scheme))
+	}
+
+	for _, valid := range schemes {
+		if scheme == valid {
+			return true
+		}
+	}
+	return false
+}
+
+// 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_.\-]+)*)$`)
+	vcsExtensionRegex = regexp.MustCompile(`^(?P<root>([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-_.~]+)*$`)
+)
+
+func pathDeducerTrie() deducerTrie {
+	dxt := newDeducerTrie()
+
+	dxt.Insert("github.com/", githubDeducer{regexp: ghRegex})
+	dxt.Insert("gopkg.in/", gopkginDeducer{regexp: gpinNewRegex})
+	dxt.Insert("bitbucket.org/", bitbucketDeducer{regexp: bbRegex})
+	dxt.Insert("launchpad.net/", launchpadDeducer{regexp: lpRegex})
+	dxt.Insert("git.launchpad.net/", launchpadGitDeducer{regexp: glpRegex})
+	dxt.Insert("hub.jazz.net/", jazzDeducer{regexp: jazzRegex})
+	dxt.Insert("git.apache.org/", apacheDeducer{regexp: apacheRegex})
+
+	return dxt
+}
+
+type pathDeducer interface {
+	deduceRoot(string) (string, error)
+	deduceSource(string, *url.URL) (maybeSource, error)
+}
+
+type githubDeducer struct {
+	regexp *regexp.Regexp
+}
+
+func (m githubDeducer) deduceRoot(path string) (string, error) {
+	v := m.regexp.FindStringSubmatch(path)
+	if v == nil {
+		return "", fmt.Errorf("%s is not a valid path for a source on github.com", path)
+	}
+
+	return "github.com" + v[2], nil
+}
+
+func (m githubDeducer) deduceSource(path string, u *url.URL) (maybeSource, error) {
+	v := m.regexp.FindStringSubmatch(path)
+	if v == nil {
+		return nil, fmt.Errorf("%s is not a valid path for a source on github.com", path)
+	}
+
+	u.Host = "github.com"
+	u.Path = v[2]
+
+	if u.Scheme == "ssh" && u.User != nil && u.User.Username() != "git" {
+		return nil, fmt.Errorf("github ssh must be accessed via the 'git' user; %s was provided", u.User.Username())
+	} else if u.Scheme != "" {
+		if !validateVCSScheme(u.Scheme, "git") {
+			return nil, fmt.Errorf("%s is not a valid scheme for accessing a git repository", u.Scheme)
+		}
+		if u.Scheme == "ssh" {
+			u.User = url.User("git")
+		}
+		return maybeGitSource{url: u}, nil
+	}
+
+	mb := make(maybeSources, len(gitSchemes))
+	for k, scheme := range gitSchemes {
+		u2 := *u
+		if scheme == "ssh" {
+			u2.User = url.User("git")
+		}
+		u2.Scheme = scheme
+		mb[k] = maybeGitSource{url: &u2}
+	}
+
+	return mb, nil
+}
+
+type bitbucketDeducer struct {
+	regexp *regexp.Regexp
+}
+
+func (m bitbucketDeducer) deduceRoot(path string) (string, error) {
+	v := m.regexp.FindStringSubmatch(path)
+	if v == nil {
+		return "", fmt.Errorf("%s is not a valid path for a source on bitbucket.org", path)
+	}
+
+	return "bitbucket.org" + v[2], nil
+}
+
+func (m bitbucketDeducer) deduceSource(path string, u *url.URL) (maybeSource, error) {
+	v := m.regexp.FindStringSubmatch(path)
+	if v == nil {
+		return nil, fmt.Errorf("%s is not a valid path for a source on bitbucket.org", path)
+	}
+
+	u.Host = "bitbucket.org"
+	u.Path = v[2]
+
+	// This isn't definitive, but it'll probably catch most
+	isgit := strings.HasSuffix(u.Path, ".git") || (u.User != nil && u.User.Username() == "git")
+	ishg := strings.HasSuffix(u.Path, ".hg") || (u.User != nil && u.User.Username() == "hg")
+
+	// TODO(sdboyer) resolve scm ambiguity if needed by querying bitbucket's REST API
+	if u.Scheme != "" {
+		validgit, validhg := validateVCSScheme(u.Scheme, "git"), validateVCSScheme(u.Scheme, "hg")
+		if isgit {
+			if !validgit {
+				// This is unreachable for now, as the git schemes are a
+				// superset of the hg schemes
+				return nil, fmt.Errorf("%s is not a valid scheme for accessing a git repository", u.Scheme)
+			}
+			return maybeGitSource{url: u}, nil
+		} else if ishg {
+			if !validhg {
+				return nil, fmt.Errorf("%s is not a valid scheme for accessing an hg repository", u.Scheme)
+			}
+			return maybeHgSource{url: u}, nil
+		} else if !validgit && !validhg {
+			return nil, fmt.Errorf("%s is not a valid scheme for accessing either a git or hg repository", u.Scheme)
+		}
+
+		// No other choice, make an option for both git and hg
+		return maybeSources{
+			maybeHgSource{url: u},
+			maybeGitSource{url: u},
+		}, nil
+	}
+
+	mb := make(maybeSources, 0)
+	// git is probably more common, even on bitbucket. however, bitbucket
+	// appears to fail _extremely_ slowly on git pings (ls-remote) when the
+	// underlying repository is actually an hg repository, so it's better
+	// to try hg first.
+	if !isgit {
+		for _, scheme := range hgSchemes {
+			u2 := *u
+			if scheme == "ssh" {
+				u2.User = url.User("hg")
+			}
+			u2.Scheme = scheme
+			mb = append(mb, maybeHgSource{url: &u2})
+		}
+	}
+
+	if !ishg {
+		for _, scheme := range gitSchemes {
+			u2 := *u
+			if scheme == "ssh" {
+				u2.User = url.User("git")
+			}
+			u2.Scheme = scheme
+			mb = append(mb, maybeGitSource{url: &u2})
+		}
+	}
+
+	return mb, nil
+}
+
+type gopkginDeducer struct {
+	regexp *regexp.Regexp
+}
+
+func (m gopkginDeducer) deduceRoot(p string) (string, error) {
+	v, err := m.parseAndValidatePath(p)
+	if err != nil {
+		return "", err
+	}
+
+	return v[1], nil
+}
+
+func (m gopkginDeducer) parseAndValidatePath(p string) ([]string, error) {
+	v := m.regexp.FindStringSubmatch(p)
+	if v == nil {
+		return nil, fmt.Errorf("%s is not a valid path for a source on gopkg.in", p)
+	}
+
+	// We duplicate some logic from the gopkg.in server in order to validate the
+	// import path string without having to make a network request
+	if strings.Contains(v[4], ".") {
+		return nil, fmt.Errorf("%s is not a valid import path; gopkg.in only allows major versions (%q instead of %q)",
+			p, v[4][:strings.Index(v[4], ".")], v[4])
+	}
+
+	return v, nil
+}
+
+func (m gopkginDeducer) deduceSource(p string, u *url.URL) (maybeSource, error) {
+	// Reuse root detection logic for initial validation
+	v, err := m.parseAndValidatePath(p)
+	if err != nil {
+		return nil, err
+	}
+
+	// Putting a scheme on gopkg.in would be really weird, disallow it
+	if u.Scheme != "" {
+		return nil, fmt.Errorf("Specifying alternate schemes on gopkg.in imports is not permitted")
+	}
+
+	// gopkg.in is always backed by github
+	u.Host = "github.com"
+	if v[2] == "" {
+		elem := v[3][1:]
+		u.Path = path.Join("/go-"+elem, elem)
+	} else {
+		u.Path = path.Join(v[2], v[3])
+	}
+
+	mb := make(maybeSources, len(gitSchemes))
+	for k, scheme := range gitSchemes {
+		u2 := *u
+		if scheme == "ssh" {
+			u2.User = url.User("git")
+		}
+		u2.Scheme = scheme
+		mb[k] = maybeGitSource{url: &u2}
+	}
+
+	return mb, nil
+}
+
+type launchpadDeducer struct {
+	regexp *regexp.Regexp
+}
+
+func (m launchpadDeducer) deduceRoot(path string) (string, error) {
+	// 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 := m.regexp.FindStringSubmatch(path)
+	if v == nil {
+		return "", fmt.Errorf("%s is not a valid path for a source on launchpad.net", path)
+	}
+
+	return "launchpad.net" + v[2], nil
+}
+
+func (m launchpadDeducer) deduceSource(path string, u *url.URL) (maybeSource, error) {
+	v := m.regexp.FindStringSubmatch(path)
+	if v == nil {
+		return nil, fmt.Errorf("%s is not a valid path for a source on launchpad.net", path)
+	}
+
+	u.Host = "launchpad.net"
+	u.Path = v[2]
+
+	if u.Scheme != "" {
+		if !validateVCSScheme(u.Scheme, "bzr") {
+			return nil, fmt.Errorf("%s is not a valid scheme for accessing a bzr repository", u.Scheme)
+		}
+		return maybeBzrSource{url: u}, nil
+	}
+
+	mb := make(maybeSources, len(bzrSchemes))
+	for k, scheme := range bzrSchemes {
+		u2 := *u
+		u2.Scheme = scheme
+		mb[k] = maybeBzrSource{url: &u2}
+	}
+
+	return mb, nil
+}
+
+type launchpadGitDeducer struct {
+	regexp *regexp.Regexp
+}
+
+func (m launchpadGitDeducer) deduceRoot(path string) (string, error) {
+	// TODO(sdboyer) same ambiguity issues as with normal bzr lp
+	v := m.regexp.FindStringSubmatch(path)
+	if v == nil {
+		return "", fmt.Errorf("%s is not a valid path for a source on git.launchpad.net", path)
+	}
+
+	return "git.launchpad.net" + v[2], nil
+}
+
+func (m launchpadGitDeducer) deduceSource(path string, u *url.URL) (maybeSource, error) {
+	v := m.regexp.FindStringSubmatch(path)
+	if v == nil {
+		return nil, fmt.Errorf("%s is not a valid path for a source on git.launchpad.net", path)
+	}
+
+	u.Host = "git.launchpad.net"
+	u.Path = v[2]
+
+	if u.Scheme != "" {
+		if !validateVCSScheme(u.Scheme, "git") {
+			return nil, fmt.Errorf("%s is not a valid scheme for accessing a git repository", u.Scheme)
+		}
+		return maybeGitSource{url: u}, nil
+	}
+
+	mb := make(maybeSources, len(gitSchemes))
+	for k, scheme := range gitSchemes {
+		u2 := *u
+		u2.Scheme = scheme
+		mb[k] = maybeGitSource{url: &u2}
+	}
+
+	return mb, nil
+}
+
+type jazzDeducer struct {
+	regexp *regexp.Regexp
+}
+
+func (m jazzDeducer) deduceRoot(path string) (string, error) {
+	v := m.regexp.FindStringSubmatch(path)
+	if v == nil {
+		return "", fmt.Errorf("%s is not a valid path for a source on hub.jazz.net", path)
+	}
+
+	return "hub.jazz.net" + v[2], nil
+}
+
+func (m jazzDeducer) deduceSource(path string, u *url.URL) (maybeSource, error) {
+	v := m.regexp.FindStringSubmatch(path)
+	if v == nil {
+		return nil, fmt.Errorf("%s is not a valid path for a source on hub.jazz.net", path)
+	}
+
+	u.Host = "hub.jazz.net"
+	u.Path = v[2]
+
+	switch u.Scheme {
+	case "":
+		u.Scheme = "https"
+		fallthrough
+	case "https":
+		return maybeGitSource{url: u}, nil
+	default:
+		return nil, fmt.Errorf("IBM's jazz hub only supports https, %s is not allowed", u.String())
+	}
+}
+
+type apacheDeducer struct {
+	regexp *regexp.Regexp
+}
+
+func (m apacheDeducer) deduceRoot(path string) (string, error) {
+	v := m.regexp.FindStringSubmatch(path)
+	if v == nil {
+		return "", fmt.Errorf("%s is not a valid path for a source on git.apache.org", path)
+	}
+
+	return "git.apache.org" + v[2], nil
+}
+
+func (m apacheDeducer) deduceSource(path string, u *url.URL) (maybeSource, error) {
+	v := m.regexp.FindStringSubmatch(path)
+	if v == nil {
+		return nil, fmt.Errorf("%s is not a valid path for a source on git.apache.org", path)
+	}
+
+	u.Host = "git.apache.org"
+	u.Path = v[2]
+
+	if u.Scheme != "" {
+		if !validateVCSScheme(u.Scheme, "git") {
+			return nil, fmt.Errorf("%s is not a valid scheme for accessing a git repository", u.Scheme)
+		}
+		return maybeGitSource{url: u}, nil
+	}
+
+	mb := make(maybeSources, len(gitSchemes))
+	for k, scheme := range gitSchemes {
+		u2 := *u
+		u2.Scheme = scheme
+		mb[k] = maybeGitSource{url: &u2}
+	}
+
+	return mb, nil
+}
+
+type vcsExtensionDeducer struct {
+	regexp *regexp.Regexp
+}
+
+func (m vcsExtensionDeducer) deduceRoot(path string) (string, error) {
+	v := m.regexp.FindStringSubmatch(path)
+	if v == nil {
+		return "", fmt.Errorf("%s contains no vcs extension hints for matching", path)
+	}
+
+	return v[1], nil
+}
+
+func (m vcsExtensionDeducer) deduceSource(path string, u *url.URL) (maybeSource, error) {
+	v := m.regexp.FindStringSubmatch(path)
+	if v == nil {
+		return nil, fmt.Errorf("%s contains no vcs extension hints for matching", path)
+	}
+
+	switch v[4] {
+	case "git", "hg", "bzr":
+		x := strings.SplitN(v[1], "/", 2)
+		// TODO(sdboyer) is this actually correct for bzr?
+		u.Host = x[0]
+		u.Path = "/" + x[1]
+
+		if u.Scheme != "" {
+			if !validateVCSScheme(u.Scheme, v[4]) {
+				return nil, fmt.Errorf("%s is not a valid scheme for accessing %s repositories (path %s)", u.Scheme, v[4], path)
+			}
+
+			switch v[4] {
+			case "git":
+				return maybeGitSource{url: u}, nil
+			case "bzr":
+				return maybeBzrSource{url: u}, nil
+			case "hg":
+				return maybeHgSource{url: u}, nil
+			}
+		}
+
+		var schemes []string
+		var mb maybeSources
+		var f func(k int, u *url.URL)
+
+		switch v[4] {
+		case "git":
+			schemes = gitSchemes
+			f = func(k int, u *url.URL) {
+				mb[k] = maybeGitSource{url: u}
+			}
+		case "bzr":
+			schemes = bzrSchemes
+			f = func(k int, u *url.URL) {
+				mb[k] = maybeBzrSource{url: u}
+			}
+		case "hg":
+			schemes = hgSchemes
+			f = func(k int, u *url.URL) {
+				mb[k] = maybeHgSource{url: u}
+			}
+		}
+
+		mb = make(maybeSources, len(schemes))
+		for k, scheme := range schemes {
+			u2 := *u
+			u2.Scheme = scheme
+			f(k, &u2)
+		}
+
+		return mb, nil
+	default:
+		return nil, fmt.Errorf("unknown repository type: %q", v[4])
+	}
+}
+
+type stringFuture func() (string, error)
+type sourceFuture func() (source, string, error)
+type partialSourceFuture func(string, ProjectAnalyzer) sourceFuture
+
+type deductionFuture struct {
+	// rslow indicates that the root future may be a slow call (that it has to
+	// hit the network for some reason)
+	rslow bool
+	root  stringFuture
+	psf   partialSourceFuture
+}
+
+// deduceFromPath takes an import path and attempts to deduce various
+// metadata about it - what type of source should handle it, and where its
+// "root" is (for vcs repositories, the repository root).
+//
+// The results are wrapped in futures, as most of these operations require at
+// least some network activity to complete. For the first return value, network
+// activity will be triggered when the future is called. For the second,
+// network activity is triggered only when calling the sourceFuture returned
+// from the partialSourceFuture.
+func (sm *SourceMgr) deduceFromPath(path string) (deductionFuture, error) {
+	opath := path
+	u, path, err := normalizeURI(path)
+	if err != nil {
+		return deductionFuture{}, err
+	}
+
+	// Helpers to futurize the results from deducers
+	strfut := func(s string) stringFuture {
+		return func() (string, error) {
+			return s, nil
+		}
+	}
+
+	srcfut := func(mb maybeSource) partialSourceFuture {
+		return func(cachedir string, an ProjectAnalyzer) sourceFuture {
+			var src source
+			var ident string
+			var err error
+
+			c := make(chan struct{}, 1)
+			go func() {
+				defer close(c)
+				src, ident, err = mb.try(cachedir, an)
+			}()
+
+			return func() (source, string, error) {
+				<-c
+				return src, ident, err
+			}
+		}
+	}
+
+	// First, try the root path-based matches
+	if _, mtchi, has := sm.dxt.LongestPrefix(path); has {
+		mtch := mtchi.(pathDeducer)
+		root, err := mtch.deduceRoot(path)
+		if err != nil {
+			return deductionFuture{}, err
+		}
+		mb, err := mtch.deduceSource(path, u)
+		if err != nil {
+			return deductionFuture{}, err
+		}
+
+		return deductionFuture{
+			rslow: false,
+			root:  strfut(root),
+			psf:   srcfut(mb),
+		}, nil
+	}
+
+	// Next, try the vcs extension-based (infix) matcher
+	exm := vcsExtensionDeducer{regexp: vcsExtensionRegex}
+	if root, err := exm.deduceRoot(path); err == nil {
+		mb, err := exm.deduceSource(path, u)
+		if err != nil {
+			return deductionFuture{}, err
+		}
+
+		return deductionFuture{
+			rslow: false,
+			root:  strfut(root),
+			psf:   srcfut(mb),
+		}, nil
+	}
+
+	// No luck so far. maybe it's one of them vanity imports?
+	// We have to get a little fancier for the metadata lookup by chaining the
+	// source future onto the metadata future
+
+	// Declare these out here so they're available for the source future
+	var vcs string
+	var ru *url.URL
+
+	// Kick off the vanity metadata fetch
+	var importroot string
+	var futerr error
+	c := make(chan struct{}, 1)
+	go func() {
+		defer close(c)
+		var reporoot string
+		importroot, vcs, reporoot, futerr = parseMetadata(path)
+		if futerr != nil {
+			futerr = fmt.Errorf("unable to deduce repository and source type for: %q", opath)
+			return
+		}
+
+		// If we got something back at all, then it supercedes the actual input for
+		// the real URL to hit
+		ru, futerr = url.Parse(reporoot)
+		if futerr != nil {
+			futerr = fmt.Errorf("server returned bad URL when searching for vanity import: %q", reporoot)
+			importroot = ""
+			return
+		}
+	}()
+
+	// Set up the root func to catch the result
+	root := func() (string, error) {
+		<-c
+		return importroot, futerr
+	}
+
+	src := func(cachedir string, an ProjectAnalyzer) sourceFuture {
+		var src source
+		var ident string
+		var err error
+
+		c := make(chan struct{}, 1)
+		go func() {
+			defer close(c)
+			// make sure the metadata future is finished (without errors), thus
+			// guaranteeing that ru and vcs will be populated
+			_, err := root()
+			if err != nil {
+				return
+			}
+			ident = ru.String()
+
+			var m maybeSource
+			switch vcs {
+			case "git":
+				m = maybeGitSource{url: ru}
+			case "bzr":
+				m = maybeBzrSource{url: ru}
+			case "hg":
+				m = maybeHgSource{url: ru}
+			}
+
+			if m != nil {
+				src, ident, err = m.try(cachedir, an)
+			} else {
+				err = fmt.Errorf("unsupported vcs type %s", vcs)
+			}
+		}()
+
+		return func() (source, string, error) {
+			<-c
+			return src, ident, err
+		}
+	}
+
+	return deductionFuture{
+		rslow: true,
+		root:  root,
+		psf:   src,
+	}, nil
+}
+
+func normalizeURI(p string) (u *url.URL, newpath string, err error) {
+	if m := scpSyntaxRe.FindStringSubmatch(p); 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".
+		u = &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 {
+		u, err = url.Parse(p)
+		if err != nil {
+			return nil, "", fmt.Errorf("%q is not a valid URI", p)
+		}
+	}
+
+	// If no scheme was passed, then the entire path will have been put into
+	// u.Path. Either way, construct the normalized path correctly.
+	if u.Host == "" {
+		newpath = p
+	} else {
+		newpath = path.Join(u.Host, u.Path)
+	}
+
+	if !pathvld.MatchString(newpath) {
+		return nil, "", fmt.Errorf("%q is not a valid import path", newpath)
+	}
+
+	return
+}
+
+// fetchMetadata fetches 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/deduce_test.go b/vendor/github.com/sdboyer/gps/deduce_test.go
new file mode 100644
index 0000000..23ffe38
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/deduce_test.go
@@ -0,0 +1,619 @@
+package gps
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"net/url"
+	"reflect"
+	"sync"
+	"testing"
+)
+
+type pathDeductionFixture struct {
+	in     string
+	root   string
+	rerr   error
+	mb     maybeSource
+	srcerr error
+}
+
+// helper func to generate testing *url.URLs, panicking on err
+func mkurl(s string) (u *url.URL) {
+	var err error
+	u, err = url.Parse(s)
+	if err != nil {
+		panic(fmt.Sprint("string is not a valid URL:", s))
+	}
+	return
+}
+
+var pathDeductionFixtures = map[string][]pathDeductionFixture{
+	"github": []pathDeductionFixture{
+		{
+			in:   "github.com/sdboyer/gps",
+			root: "github.com/sdboyer/gps",
+			mb: maybeSources{
+				maybeGitSource{url: mkurl("https://github.com/sdboyer/gps")},
+				maybeGitSource{url: mkurl("ssh://git@github.com/sdboyer/gps")},
+				maybeGitSource{url: mkurl("git://github.com/sdboyer/gps")},
+				maybeGitSource{url: mkurl("http://github.com/sdboyer/gps")},
+			},
+		},
+		{
+			in:   "github.com/sdboyer/gps/foo",
+			root: "github.com/sdboyer/gps",
+			mb: maybeSources{
+				maybeGitSource{url: mkurl("https://github.com/sdboyer/gps")},
+				maybeGitSource{url: mkurl("ssh://git@github.com/sdboyer/gps")},
+				maybeGitSource{url: mkurl("git://github.com/sdboyer/gps")},
+				maybeGitSource{url: mkurl("http://github.com/sdboyer/gps")},
+			},
+		},
+		{
+			// TODO(sdboyer) is this a problem for enforcing uniqueness? do we
+			// need to collapse these extensions?
+			in:   "github.com/sdboyer/gps.git/foo",
+			root: "github.com/sdboyer/gps.git",
+			mb: maybeSources{
+				maybeGitSource{url: mkurl("https://github.com/sdboyer/gps.git")},
+				maybeGitSource{url: mkurl("ssh://git@github.com/sdboyer/gps.git")},
+				maybeGitSource{url: mkurl("git://github.com/sdboyer/gps.git")},
+				maybeGitSource{url: mkurl("http://github.com/sdboyer/gps.git")},
+			},
+		},
+		{
+			in:   "git@github.com:sdboyer/gps",
+			root: "github.com/sdboyer/gps",
+			mb:   maybeGitSource{url: mkurl("ssh://git@github.com/sdboyer/gps")},
+		},
+		{
+			in:   "https://github.com/sdboyer/gps",
+			root: "github.com/sdboyer/gps",
+			mb:   maybeGitSource{url: mkurl("https://github.com/sdboyer/gps")},
+		},
+		{
+			in:   "https://github.com/sdboyer/gps/foo/bar",
+			root: "github.com/sdboyer/gps",
+			mb:   maybeGitSource{url: mkurl("https://github.com/sdboyer/gps")},
+		},
+		// some invalid github username patterns
+		{
+			in:   "github.com/-sdboyer/gps/foo",
+			rerr: errors.New("github.com/-sdboyer/gps/foo is not a valid path for a source on github.com"),
+		},
+		{
+			in:   "github.com/sdboyer-/gps/foo",
+			rerr: errors.New("github.com/sdboyer-/gps/foo is not a valid path for a source on github.com"),
+		},
+		{
+			in:   "github.com/sdbo.yer/gps/foo",
+			rerr: errors.New("github.com/sdbo.yer/gps/foo is not a valid path for a source on github.com"),
+		},
+		{
+			in:   "github.com/sdbo_yer/gps/foo",
+			rerr: errors.New("github.com/sdbo_yer/gps/foo is not a valid path for a source on github.com"),
+		},
+		// Regression - gh does allow two-letter usernames
+		{
+			in:   "github.com/kr/pretty",
+			root: "github.com/kr/pretty",
+			mb: maybeSources{
+				maybeGitSource{url: mkurl("https://github.com/kr/pretty")},
+				maybeGitSource{url: mkurl("ssh://git@github.com/kr/pretty")},
+				maybeGitSource{url: mkurl("git://github.com/kr/pretty")},
+				maybeGitSource{url: mkurl("http://github.com/kr/pretty")},
+			},
+		},
+	},
+	"gopkg.in": []pathDeductionFixture{
+		{
+			in:   "gopkg.in/sdboyer/gps.v0",
+			root: "gopkg.in/sdboyer/gps.v0",
+			mb: maybeSources{
+				maybeGitSource{url: mkurl("https://github.com/sdboyer/gps")},
+				maybeGitSource{url: mkurl("ssh://git@github.com/sdboyer/gps")},
+				maybeGitSource{url: mkurl("git://github.com/sdboyer/gps")},
+				maybeGitSource{url: mkurl("http://github.com/sdboyer/gps")},
+			},
+		},
+		{
+			in:   "gopkg.in/sdboyer/gps.v0/foo",
+			root: "gopkg.in/sdboyer/gps.v0",
+			mb: maybeSources{
+				maybeGitSource{url: mkurl("https://github.com/sdboyer/gps")},
+				maybeGitSource{url: mkurl("ssh://git@github.com/sdboyer/gps")},
+				maybeGitSource{url: mkurl("git://github.com/sdboyer/gps")},
+				maybeGitSource{url: mkurl("http://github.com/sdboyer/gps")},
+			},
+		},
+		{
+			in:   "gopkg.in/sdboyer/gps.v1/foo/bar",
+			root: "gopkg.in/sdboyer/gps.v1",
+			mb: maybeSources{
+				maybeGitSource{url: mkurl("https://github.com/sdboyer/gps")},
+				maybeGitSource{url: mkurl("ssh://git@github.com/sdboyer/gps")},
+				maybeGitSource{url: mkurl("git://github.com/sdboyer/gps")},
+				maybeGitSource{url: mkurl("http://github.com/sdboyer/gps")},
+			},
+		},
+		{
+			in:   "gopkg.in/yaml.v1",
+			root: "gopkg.in/yaml.v1",
+			mb: maybeSources{
+				maybeGitSource{url: mkurl("https://github.com/go-yaml/yaml")},
+				maybeGitSource{url: mkurl("ssh://git@github.com/go-yaml/yaml")},
+				maybeGitSource{url: mkurl("git://github.com/go-yaml/yaml")},
+				maybeGitSource{url: mkurl("http://github.com/go-yaml/yaml")},
+			},
+		},
+		{
+			in:   "gopkg.in/yaml.v1/foo/bar",
+			root: "gopkg.in/yaml.v1",
+			mb: maybeSources{
+				maybeGitSource{url: mkurl("https://github.com/go-yaml/yaml")},
+				maybeGitSource{url: mkurl("ssh://git@github.com/go-yaml/yaml")},
+				maybeGitSource{url: mkurl("git://github.com/go-yaml/yaml")},
+				maybeGitSource{url: mkurl("http://github.com/go-yaml/yaml")},
+			},
+		},
+		{
+			in:   "gopkg.in/inf.v0",
+			root: "gopkg.in/inf.v0",
+			mb: maybeSources{
+				maybeGitSource{url: mkurl("https://github.com/go-inf/inf")},
+				maybeGitSource{url: mkurl("ssh://git@github.com/go-inf/inf")},
+				maybeGitSource{url: mkurl("git://github.com/go-inf/inf")},
+				maybeGitSource{url: mkurl("http://github.com/go-inf/inf")},
+			},
+		},
+		{
+			// gopkg.in only allows specifying major version in import path
+			in:   "gopkg.in/yaml.v1.2",
+			rerr: errors.New("gopkg.in/yaml.v1.2 is not a valid import path; gopkg.in only allows major versions (\"v1\" instead of \"v1.2\")"),
+		},
+	},
+	"jazz": []pathDeductionFixture{
+		// IBM hub devops services - fixtures borrowed from go get
+		{
+			in:   "hub.jazz.net/git/user1/pkgname",
+			root: "hub.jazz.net/git/user1/pkgname",
+			mb:   maybeGitSource{url: mkurl("https://hub.jazz.net/git/user1/pkgname")},
+		},
+		{
+			in:   "hub.jazz.net/git/user1/pkgname/submodule/submodule/submodule",
+			root: "hub.jazz.net/git/user1/pkgname",
+			mb:   maybeGitSource{url: mkurl("https://hub.jazz.net/git/user1/pkgname")},
+		},
+		{
+			in:   "hub.jazz.net/someotherprefix",
+			rerr: errors.New("hub.jazz.net/someotherprefix is not a valid path for a source on hub.jazz.net"),
+		},
+		{
+			in:   "hub.jazz.net/someotherprefix/user1/packagename",
+			rerr: errors.New("hub.jazz.net/someotherprefix/user1/packagename is not a valid path for a source on hub.jazz.net"),
+		},
+		// Spaces are not valid in user names or package names
+		{
+			in:   "hub.jazz.net/git/User 1/pkgname",
+			rerr: errors.New("hub.jazz.net/git/User 1/pkgname is not a valid path for a source on hub.jazz.net"),
+		},
+		{
+			in:   "hub.jazz.net/git/user1/pkg name",
+			rerr: errors.New("hub.jazz.net/git/user1/pkg name is not a valid path for a source on hub.jazz.net"),
+		},
+		// Dots are not valid in user names
+		{
+			in:   "hub.jazz.net/git/user.1/pkgname",
+			rerr: errors.New("hub.jazz.net/git/user.1/pkgname is not a valid path for a source on hub.jazz.net"),
+		},
+		{
+			in:   "hub.jazz.net/git/user1/pkg.name",
+			root: "hub.jazz.net/git/user1/pkg.name",
+			mb:   maybeGitSource{url: mkurl("https://hub.jazz.net/git/user1/pkg.name")},
+		},
+		// User names cannot have uppercase letters
+		{
+			in:   "hub.jazz.net/git/USER/pkgname",
+			rerr: errors.New("hub.jazz.net/git/USER/pkgname is not a valid path for a source on hub.jazz.net"),
+		},
+	},
+	"bitbucket": []pathDeductionFixture{
+		{
+			in:   "bitbucket.org/sdboyer/reporoot",
+			root: "bitbucket.org/sdboyer/reporoot",
+			mb: maybeSources{
+				maybeHgSource{url: mkurl("https://bitbucket.org/sdboyer/reporoot")},
+				maybeHgSource{url: mkurl("ssh://hg@bitbucket.org/sdboyer/reporoot")},
+				maybeHgSource{url: mkurl("http://bitbucket.org/sdboyer/reporoot")},
+				maybeGitSource{url: mkurl("https://bitbucket.org/sdboyer/reporoot")},
+				maybeGitSource{url: mkurl("ssh://git@bitbucket.org/sdboyer/reporoot")},
+				maybeGitSource{url: mkurl("git://bitbucket.org/sdboyer/reporoot")},
+				maybeGitSource{url: mkurl("http://bitbucket.org/sdboyer/reporoot")},
+			},
+		},
+		{
+			in:   "bitbucket.org/sdboyer/reporoot/foo/bar",
+			root: "bitbucket.org/sdboyer/reporoot",
+			mb: maybeSources{
+				maybeHgSource{url: mkurl("https://bitbucket.org/sdboyer/reporoot")},
+				maybeHgSource{url: mkurl("ssh://hg@bitbucket.org/sdboyer/reporoot")},
+				maybeHgSource{url: mkurl("http://bitbucket.org/sdboyer/reporoot")},
+				maybeGitSource{url: mkurl("https://bitbucket.org/sdboyer/reporoot")},
+				maybeGitSource{url: mkurl("ssh://git@bitbucket.org/sdboyer/reporoot")},
+				maybeGitSource{url: mkurl("git://bitbucket.org/sdboyer/reporoot")},
+				maybeGitSource{url: mkurl("http://bitbucket.org/sdboyer/reporoot")},
+			},
+		},
+		{
+			in:   "https://bitbucket.org/sdboyer/reporoot/foo/bar",
+			root: "bitbucket.org/sdboyer/reporoot",
+			mb: maybeSources{
+				maybeHgSource{url: mkurl("https://bitbucket.org/sdboyer/reporoot")},
+				maybeGitSource{url: mkurl("https://bitbucket.org/sdboyer/reporoot")},
+			},
+		},
+		// Less standard behaviors possible due to the hg/git ambiguity
+		{
+			in:   "bitbucket.org/sdboyer/reporoot.git",
+			root: "bitbucket.org/sdboyer/reporoot.git",
+			mb: maybeSources{
+				maybeGitSource{url: mkurl("https://bitbucket.org/sdboyer/reporoot.git")},
+				maybeGitSource{url: mkurl("ssh://git@bitbucket.org/sdboyer/reporoot.git")},
+				maybeGitSource{url: mkurl("git://bitbucket.org/sdboyer/reporoot.git")},
+				maybeGitSource{url: mkurl("http://bitbucket.org/sdboyer/reporoot.git")},
+			},
+		},
+		{
+			in:   "git@bitbucket.org:sdboyer/reporoot.git",
+			root: "bitbucket.org/sdboyer/reporoot.git",
+			mb:   maybeGitSource{url: mkurl("ssh://git@bitbucket.org/sdboyer/reporoot.git")},
+		},
+		{
+			in:   "bitbucket.org/sdboyer/reporoot.hg",
+			root: "bitbucket.org/sdboyer/reporoot.hg",
+			mb: maybeSources{
+				maybeHgSource{url: mkurl("https://bitbucket.org/sdboyer/reporoot.hg")},
+				maybeHgSource{url: mkurl("ssh://hg@bitbucket.org/sdboyer/reporoot.hg")},
+				maybeHgSource{url: mkurl("http://bitbucket.org/sdboyer/reporoot.hg")},
+			},
+		},
+		{
+			in:   "hg@bitbucket.org:sdboyer/reporoot",
+			root: "bitbucket.org/sdboyer/reporoot",
+			mb:   maybeHgSource{url: mkurl("ssh://hg@bitbucket.org/sdboyer/reporoot")},
+		},
+		{
+			in:     "git://bitbucket.org/sdboyer/reporoot.hg",
+			root:   "bitbucket.org/sdboyer/reporoot.hg",
+			srcerr: errors.New("git is not a valid scheme for accessing an hg repository"),
+		},
+	},
+	"launchpad": []pathDeductionFixture{
+		// tests for launchpad, mostly bazaar
+		// TODO(sdboyer) need more tests to deal w/launchpad's oddities
+		{
+			in:   "launchpad.net/govcstestbzrrepo",
+			root: "launchpad.net/govcstestbzrrepo",
+			mb: maybeSources{
+				maybeBzrSource{url: mkurl("https://launchpad.net/govcstestbzrrepo")},
+				maybeBzrSource{url: mkurl("bzr+ssh://launchpad.net/govcstestbzrrepo")},
+				maybeBzrSource{url: mkurl("bzr://launchpad.net/govcstestbzrrepo")},
+				maybeBzrSource{url: mkurl("http://launchpad.net/govcstestbzrrepo")},
+			},
+		},
+		{
+			in:   "launchpad.net/govcstestbzrrepo/foo/bar",
+			root: "launchpad.net/govcstestbzrrepo",
+			mb: maybeSources{
+				maybeBzrSource{url: mkurl("https://launchpad.net/govcstestbzrrepo")},
+				maybeBzrSource{url: mkurl("bzr+ssh://launchpad.net/govcstestbzrrepo")},
+				maybeBzrSource{url: mkurl("bzr://launchpad.net/govcstestbzrrepo")},
+				maybeBzrSource{url: mkurl("http://launchpad.net/govcstestbzrrepo")},
+			},
+		},
+		{
+			in:   "launchpad.net/repo root",
+			rerr: errors.New("launchpad.net/repo root is not a valid path for a source on launchpad.net"),
+		},
+	},
+	"git.launchpad": []pathDeductionFixture{
+		{
+			in:   "git.launchpad.net/reporoot",
+			root: "git.launchpad.net/reporoot",
+			mb: maybeSources{
+				maybeGitSource{url: mkurl("https://git.launchpad.net/reporoot")},
+				maybeGitSource{url: mkurl("ssh://git.launchpad.net/reporoot")},
+				maybeGitSource{url: mkurl("git://git.launchpad.net/reporoot")},
+				maybeGitSource{url: mkurl("http://git.launchpad.net/reporoot")},
+			},
+		},
+		{
+			in:   "git.launchpad.net/reporoot/foo/bar",
+			root: "git.launchpad.net/reporoot",
+			mb: maybeSources{
+				maybeGitSource{url: mkurl("https://git.launchpad.net/reporoot")},
+				maybeGitSource{url: mkurl("ssh://git.launchpad.net/reporoot")},
+				maybeGitSource{url: mkurl("git://git.launchpad.net/reporoot")},
+				maybeGitSource{url: mkurl("http://git.launchpad.net/reporoot")},
+			},
+		},
+		{
+			in:   "git.launchpad.net/repo root",
+			rerr: errors.New("git.launchpad.net/repo root is not a valid path for a source on launchpad.net"),
+		},
+	},
+	"apache": []pathDeductionFixture{
+		{
+			in:   "git.apache.org/package-name.git",
+			root: "git.apache.org/package-name.git",
+			mb: maybeSources{
+				maybeGitSource{url: mkurl("https://git.apache.org/package-name.git")},
+				maybeGitSource{url: mkurl("ssh://git.apache.org/package-name.git")},
+				maybeGitSource{url: mkurl("git://git.apache.org/package-name.git")},
+				maybeGitSource{url: mkurl("http://git.apache.org/package-name.git")},
+			},
+		},
+		{
+			in:   "git.apache.org/package-name.git/foo/bar",
+			root: "git.apache.org/package-name.git",
+			mb: maybeSources{
+				maybeGitSource{url: mkurl("https://git.apache.org/package-name.git")},
+				maybeGitSource{url: mkurl("ssh://git.apache.org/package-name.git")},
+				maybeGitSource{url: mkurl("git://git.apache.org/package-name.git")},
+				maybeGitSource{url: mkurl("http://git.apache.org/package-name.git")},
+			},
+		},
+	},
+	"vcsext": []pathDeductionFixture{
+		// VCS extension-based syntax
+		{
+			in:   "foobar.com/baz.git",
+			root: "foobar.com/baz.git",
+			mb: maybeSources{
+				maybeGitSource{url: mkurl("https://foobar.com/baz.git")},
+				maybeGitSource{url: mkurl("ssh://foobar.com/baz.git")},
+				maybeGitSource{url: mkurl("git://foobar.com/baz.git")},
+				maybeGitSource{url: mkurl("http://foobar.com/baz.git")},
+			},
+		},
+		{
+			in:   "foobar.com/baz.git/extra/path",
+			root: "foobar.com/baz.git",
+			mb: maybeSources{
+				maybeGitSource{url: mkurl("https://foobar.com/baz.git")},
+				maybeGitSource{url: mkurl("ssh://foobar.com/baz.git")},
+				maybeGitSource{url: mkurl("git://foobar.com/baz.git")},
+				maybeGitSource{url: mkurl("http://foobar.com/baz.git")},
+			},
+		},
+		{
+			in:   "foobar.com/baz.bzr",
+			root: "foobar.com/baz.bzr",
+			mb: maybeSources{
+				maybeBzrSource{url: mkurl("https://foobar.com/baz.bzr")},
+				maybeBzrSource{url: mkurl("bzr+ssh://foobar.com/baz.bzr")},
+				maybeBzrSource{url: mkurl("bzr://foobar.com/baz.bzr")},
+				maybeBzrSource{url: mkurl("http://foobar.com/baz.bzr")},
+			},
+		},
+		{
+			in:   "foo-bar.com/baz.hg",
+			root: "foo-bar.com/baz.hg",
+			mb: maybeSources{
+				maybeHgSource{url: mkurl("https://foo-bar.com/baz.hg")},
+				maybeHgSource{url: mkurl("ssh://foo-bar.com/baz.hg")},
+				maybeHgSource{url: mkurl("http://foo-bar.com/baz.hg")},
+			},
+		},
+		{
+			in:   "git@foobar.com:baz.git",
+			root: "foobar.com/baz.git",
+			mb:   maybeGitSource{url: mkurl("ssh://git@foobar.com/baz.git")},
+		},
+		{
+			in:   "bzr+ssh://foobar.com/baz.bzr",
+			root: "foobar.com/baz.bzr",
+			mb:   maybeBzrSource{url: mkurl("bzr+ssh://foobar.com/baz.bzr")},
+		},
+		{
+			in:   "ssh://foobar.com/baz.bzr",
+			root: "foobar.com/baz.bzr",
+			mb:   maybeBzrSource{url: mkurl("ssh://foobar.com/baz.bzr")},
+		},
+		{
+			in:   "https://foobar.com/baz.hg",
+			root: "foobar.com/baz.hg",
+			mb:   maybeHgSource{url: mkurl("https://foobar.com/baz.hg")},
+		},
+		{
+			in:     "git://foobar.com/baz.hg",
+			root:   "foobar.com/baz.hg",
+			srcerr: errors.New("git is not a valid scheme for accessing hg repositories (path foobar.com/baz.hg)"),
+		},
+		// who knows why anyone would do this, but having a second vcs ext
+		// shouldn't throw us off - only the first one counts
+		{
+			in:   "foobar.com/baz.git/quark/quizzle.bzr/quorum",
+			root: "foobar.com/baz.git",
+			mb: maybeSources{
+				maybeGitSource{url: mkurl("https://foobar.com/baz.git")},
+				maybeGitSource{url: mkurl("ssh://foobar.com/baz.git")},
+				maybeGitSource{url: mkurl("git://foobar.com/baz.git")},
+				maybeGitSource{url: mkurl("http://foobar.com/baz.git")},
+			},
+		},
+	},
+	"vanity": []pathDeductionFixture{
+		// Vanity imports
+		{
+			in:   "golang.org/x/exp",
+			root: "golang.org/x/exp",
+			mb:   maybeGitSource{url: mkurl("https://go.googlesource.com/exp")},
+		},
+		{
+			in:   "golang.org/x/exp/inotify",
+			root: "golang.org/x/exp",
+			mb:   maybeGitSource{url: mkurl("https://go.googlesource.com/exp")},
+		},
+		{
+			in:   "rsc.io/pdf",
+			root: "rsc.io/pdf",
+			mb:   maybeGitSource{url: mkurl("https://github.com/rsc/pdf")},
+		},
+	},
+}
+
+func TestDeduceFromPath(t *testing.T) {
+	for typ, fixtures := range pathDeductionFixtures {
+		var deducer pathDeducer
+		switch typ {
+		case "github":
+			deducer = githubDeducer{regexp: ghRegex}
+		case "gopkg.in":
+			deducer = gopkginDeducer{regexp: gpinNewRegex}
+		case "jazz":
+			deducer = jazzDeducer{regexp: jazzRegex}
+		case "bitbucket":
+			deducer = bitbucketDeducer{regexp: bbRegex}
+		case "launchpad":
+			deducer = launchpadDeducer{regexp: lpRegex}
+		case "git.launchpad":
+			deducer = launchpadGitDeducer{regexp: glpRegex}
+		case "apache":
+			deducer = apacheDeducer{regexp: apacheRegex}
+		case "vcsext":
+			deducer = vcsExtensionDeducer{regexp: vcsExtensionRegex}
+		default:
+			// Should just be the vanity imports, which we do elsewhere
+			continue
+		}
+
+		var printmb func(mb maybeSource) string
+		printmb = func(mb maybeSource) string {
+			switch tmb := mb.(type) {
+			case maybeSources:
+				var buf bytes.Buffer
+				fmt.Fprintf(&buf, "%v maybeSources:", len(tmb))
+				for _, elem := range tmb {
+					fmt.Fprintf(&buf, "\n\t\t%s", printmb(elem))
+				}
+				return buf.String()
+			case maybeGitSource:
+				return fmt.Sprintf("%T: %s", tmb, ufmt(tmb.url))
+			case maybeBzrSource:
+				return fmt.Sprintf("%T: %s", tmb, ufmt(tmb.url))
+			case maybeHgSource:
+				return fmt.Sprintf("%T: %s", tmb, ufmt(tmb.url))
+			default:
+				t.Errorf("Unknown maybeSource type: %T", mb)
+				t.FailNow()
+			}
+			return ""
+		}
+
+		for _, fix := range fixtures {
+			u, in, uerr := normalizeURI(fix.in)
+			if uerr != nil {
+				if fix.rerr == nil {
+					t.Errorf("(in: %s) bad input URI %s", fix.in, uerr)
+				}
+				continue
+			}
+
+			root, rerr := deducer.deduceRoot(in)
+			if fix.rerr != nil {
+				if rerr == nil {
+					t.Errorf("(in: %s, %T) Expected error on deducing root, got none:\n\t(WNT) %s", in, deducer, fix.rerr)
+				} else if fix.rerr.Error() != rerr.Error() {
+					t.Errorf("(in: %s, %T) Got unexpected error on deducing root:\n\t(GOT) %s\n\t(WNT) %s", in, deducer, rerr, fix.rerr)
+				}
+			} else if rerr != nil {
+				t.Errorf("(in: %s, %T) Got unexpected error on deducing root:\n\t(GOT) %s", in, deducer, rerr)
+			} else if root != fix.root {
+				t.Errorf("(in: %s, %T) Deducer did not return expected root:\n\t(GOT) %s\n\t(WNT) %s", in, deducer, root, fix.root)
+			}
+
+			mb, mberr := deducer.deduceSource(in, u)
+			if fix.srcerr != nil {
+				if mberr == nil {
+					t.Errorf("(in: %s, %T) Expected error on deducing source, got none:\n\t(WNT) %s", in, deducer, fix.srcerr)
+				} else if fix.srcerr.Error() != mberr.Error() {
+					t.Errorf("(in: %s, %T) Got unexpected error on deducing source:\n\t(GOT) %s\n\t(WNT) %s", in, deducer, mberr, fix.srcerr)
+				}
+			} else if mberr != nil {
+				// don't complain the fix already expected an rerr
+				if fix.rerr == nil {
+					t.Errorf("(in: %s, %T) Got unexpected error on deducing source:\n\t(GOT) %s", in, deducer, mberr)
+				}
+			} else if !reflect.DeepEqual(mb, fix.mb) {
+				if mb == nil {
+					t.Errorf("(in: %s, %T) Deducer returned source maybes, but none expected:\n\t(GOT) (none)\n\t(WNT) %s", in, deducer, printmb(fix.mb))
+				} else if fix.mb == nil {
+					t.Errorf("(in: %s, %T) Deducer returned source maybes, but none expected:\n\t(GOT) %s\n\t(WNT) (none)", in, deducer, printmb(mb))
+				} else {
+					t.Errorf("(in: %s, %T) Deducer did not return expected source:\n\t(GOT) %s\n\t(WNT) %s", in, deducer, printmb(mb), printmb(fix.mb))
+				}
+			}
+		}
+	}
+}
+
+func TestVanityDeduction(t *testing.T) {
+	if testing.Short() {
+		t.Skip("Skipping slow test in short mode")
+	}
+
+	sm, clean := mkNaiveSM(t)
+	defer clean()
+
+	vanities := pathDeductionFixtures["vanity"]
+	wg := &sync.WaitGroup{}
+	wg.Add(len(vanities))
+
+	for _, fix := range vanities {
+		go func(fix pathDeductionFixture) {
+			defer wg.Done()
+			pr, err := sm.DeduceProjectRoot(fix.in)
+			if err != nil {
+				t.Errorf("(in: %s) Unexpected err on deducing project root: %s", fix.in, err)
+				return
+			} else if string(pr) != fix.root {
+				t.Errorf("(in: %s) Deducer did not return expected root:\n\t(GOT) %s\n\t(WNT) %s", fix.in, pr, fix.root)
+			}
+
+			_, srcf, err := sm.deducePathAndProcess(fix.in)
+			if err != nil {
+				t.Errorf("(in: %s) Unexpected err on deducing source: %s", fix.in, err)
+				return
+			}
+
+			_, ident, err := srcf()
+			if err != nil {
+				t.Errorf("(in: %s) Unexpected err on executing source future: %s", fix.in, err)
+				return
+			}
+
+			ustr := fix.mb.(maybeGitSource).url.String()
+			if ident != ustr {
+				t.Errorf("(in: %s) Deduced repo ident does not match fixture:\n\t(GOT) %s\n\t(WNT) %s", fix.in, ident, ustr)
+			}
+		}(fix)
+	}
+
+	wg.Wait()
+}
+
+// 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/errors.go b/vendor/github.com/sdboyer/gps/errors.go
deleted file mode 100644
index 26c8413..0000000
--- a/vendor/github.com/sdboyer/gps/errors.go
+++ /dev/null
@@ -1,405 +0,0 @@
-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
index 1a5a31a..2bbbe2c 100644
--- a/vendor/github.com/sdboyer/gps/example.go
+++ b/vendor/github.com/sdboyer/gps/example.go
@@ -9,7 +9,8 @@
 	"path/filepath"
 	"strings"
 
-	gps "github.com/sdboyer/gps"
+	"github.com/Masterminds/semver"
+	"github.com/sdboyer/gps"
 )
 
 // This is probably the simplest possible implementation of gps. It does the
@@ -18,8 +19,8 @@
 //  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!
+//  This will compile and work...and then blow away any vendor directory present
+//  in the cwd. Be careful!
 func main() {
 	// Operate on the current directory
 	root, _ := os.Getwd()
@@ -47,12 +48,21 @@
 		// 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)
+		gps.WriteDepTree(filepath.Join(root, "vendor"), solution, sourcemgr, true)
 	}
 }
 
 type NaiveAnalyzer struct{}
 
-func (a NaiveAnalyzer) GetInfo(path string, n gps.ProjectRoot) (gps.Manifest, gps.Lock, error) {
+// DeriveManifestAndLock gets called when the solver needs manifest/lock data
+// for a particular project (the gps.ProjectRoot parameter) at a particular
+// version. That version will be checked out in a directory rooted at path.
+func (a NaiveAnalyzer) DeriveManifestAndLock(path string, n gps.ProjectRoot) (gps.Manifest, gps.Lock, error) {
 	return nil, nil, nil
 }
+
+// Reports the name and version of the analyzer. This is mostly irrelevant.
+func (a NaiveAnalyzer) Info() (name string, version *semver.Version) {
+	v, _ := semver.NewVersion("v0.0.1")
+	return "example-analyzer", v
+}
diff --git a/vendor/github.com/sdboyer/gps/flags.go b/vendor/github.com/sdboyer/gps/flags.go
index a7172c1..d9a3a1d 100644
--- a/vendor/github.com/sdboyer/gps/flags.go
+++ b/vendor/github.com/sdboyer/gps/flags.go
@@ -1,7 +1,7 @@
 package gps
 
-// projectExistence values represent the extent to which a project "exists."
-type projectExistence uint8
+// sourceExistence values represent the extent to which a project "exists."
+type sourceExistence uint8
 
 const (
 	// ExistsInVendorRoot indicates that a project exists in a vendor directory
@@ -19,7 +19,7 @@
 	//
 	// In short, the information encoded in this flag should not be construed as
 	// exhaustive.
-	existsInVendorRoot projectExistence = 1 << iota
+	existsInVendorRoot sourceExistence = 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
diff --git a/vendor/github.com/sdboyer/gps/hash.go b/vendor/github.com/sdboyer/gps/hash.go
index 9e27bcd..893c34e 100644
--- a/vendor/github.com/sdboyer/gps/hash.go
+++ b/vendor/github.com/sdboyer/gps/hash.go
@@ -6,8 +6,8 @@
 	"sort"
 )
 
-// HashInputs computes a hash digest of all data in a SolveOpts that are as
-// function inputs to Solve().
+// HashInputs computes a hash digest of all data in SolveParams and the
+// RootManifest that act 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
@@ -20,17 +20,16 @@
 	// Do these checks up front before any other work is needed, as they're the
 	// only things that can cause errors
 	// Pass in magic root values, and the bridge will analyze the right thing
-	ptree, err := s.b.listPackages(ProjectIdentifier{ProjectRoot: s.params.ImportRoot}, nil)
+	ptree, err := s.b.ListPackages(ProjectIdentifier{ProjectRoot: 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)
+	c, tc := s.rm.DependencyConstraints(), s.rm.TestDependencyConstraints()
+	// Apply overrides to the constraints from the root. Otherwise, the hash
+	// would be computed on the basis of a constraint from root that doesn't
+	// actually affect solving.
+	p := s.ovr.overrideAll(pcSliceToMap(c, tc).asSortedSlice())
 
 	// We have everything we need; now, compute the hash.
 	h := sha256.New()
@@ -84,21 +83,19 @@
 		}
 	}
 
-	// TODO(sdboyer) overrides
-	// TODO(sdboyer) aliases
+	for _, pc := range s.ovr.asSortedSlice() {
+		h.Write([]byte(pc.Ident.ProjectRoot))
+		if pc.Ident.NetworkName != "" {
+			h.Write([]byte(pc.Ident.NetworkName))
+		}
+		if pc.Constraint != nil {
+			h.Write([]byte(pc.Constraint.String()))
+		}
+	}
+
+	an, av := s.b.AnalyzerInfo()
+	h.Write([]byte(an))
+	h.Write([]byte(av.String()))
+
 	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
index dc27ddf..171f377 100644
--- a/vendor/github.com/sdboyer/gps/hash_test.go
+++ b/vendor/github.com/sdboyer/gps/hash_test.go
@@ -12,8 +12,7 @@
 	params := SolveParameters{
 		RootDir:    string(fix.ds[0].n),
 		ImportRoot: fix.ds[0].n,
-		Manifest:   fix.ds[0],
-		Ignore:     []string{"foo", "bar"},
+		Manifest:   fix.rootmanifest(),
 	}
 
 	s, err := Prepare(params, newdepspecSM(fix.ds, nil))
@@ -24,7 +23,24 @@
 	}
 
 	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"} {
+
+	elems := []string{
+		"a",
+		"a",
+		"1.0.0",
+		"b",
+		"b",
+		"1.0.0",
+		stdlibPkgs,
+		appenginePkgs,
+		"root",
+		"root",
+		"a",
+		"b",
+		"depspec-sm-builtin",
+		"1.0.0",
+	}
+	for _, v := range elems {
 		h.Write([]byte(v))
 	}
 	correct := h.Sum(nil)
@@ -33,3 +49,335 @@
 		t.Errorf("Hashes are not equal")
 	}
 }
+
+func TestHashInputsIgnores(t *testing.T) {
+	fix := basicFixtures["shared dependency with overlapping constraints"]
+
+	rm := fix.rootmanifest().(simpleRootManifest)
+	rm.ig = map[string]bool{
+		"foo": true,
+		"bar": true,
+	}
+	params := SolveParameters{
+		RootDir:    string(fix.ds[0].n),
+		ImportRoot: fix.ds[0].n,
+		Manifest:   rm,
+	}
+
+	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()
+
+	elems := []string{
+		"a",
+		"a",
+		"1.0.0",
+		"b",
+		"b",
+		"1.0.0",
+		stdlibPkgs,
+		appenginePkgs,
+		"root",
+		"",
+		"root",
+		"a",
+		"b",
+		"bar",
+		"foo",
+		"depspec-sm-builtin",
+		"1.0.0",
+	}
+	for _, v := range elems {
+		h.Write([]byte(v))
+	}
+	correct := h.Sum(nil)
+
+	if !bytes.Equal(dig, correct) {
+		t.Errorf("Hashes are not equal")
+	}
+}
+
+func TestHashInputsOverrides(t *testing.T) {
+	fix := basicFixtures["shared dependency with overlapping constraints"]
+
+	rm := fix.rootmanifest().(simpleRootManifest)
+	// First case - override something not in the root, just with network name
+	rm.ovr = map[ProjectRoot]ProjectProperties{
+		"c": ProjectProperties{
+			NetworkName: "car",
+		},
+	}
+	params := SolveParameters{
+		RootDir:    string(fix.ds[0].n),
+		ImportRoot: fix.ds[0].n,
+		Manifest:   rm,
+	}
+
+	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()
+
+	elems := []string{
+		"a",
+		"a",
+		"1.0.0",
+		"b",
+		"b",
+		"1.0.0",
+		stdlibPkgs,
+		appenginePkgs,
+		"root",
+		"",
+		"root",
+		"a",
+		"b",
+		"c",
+		"car",
+		"depspec-sm-builtin",
+		"1.0.0",
+	}
+	for _, v := range elems {
+		h.Write([]byte(v))
+	}
+	correct := h.Sum(nil)
+
+	if !bytes.Equal(dig, correct) {
+		t.Errorf("Hashes are not equal")
+	}
+
+	// Override not in root, just with constraint
+	rm.ovr["d"] = ProjectProperties{
+		Constraint: NewBranch("foobranch"),
+	}
+	dig, err = s.HashInputs()
+	if err != nil {
+		t.Fatalf("HashInputs returned unexpected err: %s", err)
+	}
+
+	h = sha256.New()
+
+	elems = []string{
+		"a",
+		"a",
+		"1.0.0",
+		"b",
+		"b",
+		"1.0.0",
+		stdlibPkgs,
+		appenginePkgs,
+		"root",
+		"",
+		"root",
+		"a",
+		"b",
+		"c",
+		"car",
+		"d",
+		"foobranch",
+		"depspec-sm-builtin",
+		"1.0.0",
+	}
+	for _, v := range elems {
+		h.Write([]byte(v))
+	}
+	correct = h.Sum(nil)
+
+	if !bytes.Equal(dig, correct) {
+		t.Errorf("Hashes are not equal")
+	}
+
+	// Override not in root, both constraint and network name
+	rm.ovr["e"] = ProjectProperties{
+		NetworkName: "groucho",
+		Constraint:  NewBranch("plexiglass"),
+	}
+	dig, err = s.HashInputs()
+	if err != nil {
+		t.Fatalf("HashInputs returned unexpected err: %s", err)
+	}
+
+	h = sha256.New()
+
+	elems = []string{
+		"a",
+		"a",
+		"1.0.0",
+		"b",
+		"b",
+		"1.0.0",
+		stdlibPkgs,
+		appenginePkgs,
+		"root",
+		"",
+		"root",
+		"a",
+		"b",
+		"c",
+		"car",
+		"d",
+		"foobranch",
+		"e",
+		"groucho",
+		"plexiglass",
+		"depspec-sm-builtin",
+		"1.0.0",
+	}
+	for _, v := range elems {
+		h.Write([]byte(v))
+	}
+	correct = h.Sum(nil)
+
+	if !bytes.Equal(dig, correct) {
+		t.Errorf("Hashes are not equal")
+	}
+
+	// Override in root, just constraint
+	rm.ovr["a"] = ProjectProperties{
+		Constraint: NewVersion("fluglehorn"),
+	}
+	dig, err = s.HashInputs()
+	if err != nil {
+		t.Fatalf("HashInputs returned unexpected err: %s", err)
+	}
+
+	h = sha256.New()
+
+	elems = []string{
+		"a",
+		"a",
+		"fluglehorn",
+		"b",
+		"b",
+		"1.0.0",
+		stdlibPkgs,
+		appenginePkgs,
+		"root",
+		"",
+		"root",
+		"a",
+		"b",
+		"a",
+		"fluglehorn",
+		"c",
+		"car",
+		"d",
+		"foobranch",
+		"e",
+		"groucho",
+		"plexiglass",
+		"depspec-sm-builtin",
+		"1.0.0",
+	}
+	for _, v := range elems {
+		h.Write([]byte(v))
+	}
+	correct = h.Sum(nil)
+
+	if !bytes.Equal(dig, correct) {
+		t.Errorf("Hashes are not equal")
+	}
+
+	// Override in root, only network name
+	rm.ovr["a"] = ProjectProperties{
+		NetworkName: "nota",
+	}
+	dig, err = s.HashInputs()
+	if err != nil {
+		t.Fatalf("HashInputs returned unexpected err: %s", err)
+	}
+
+	h = sha256.New()
+
+	elems = []string{
+		"a",
+		"nota",
+		"1.0.0",
+		"b",
+		"b",
+		"1.0.0",
+		stdlibPkgs,
+		appenginePkgs,
+		"root",
+		"",
+		"root",
+		"a",
+		"b",
+		"a",
+		"nota",
+		"c",
+		"car",
+		"d",
+		"foobranch",
+		"e",
+		"groucho",
+		"plexiglass",
+		"depspec-sm-builtin",
+		"1.0.0",
+	}
+	for _, v := range elems {
+		h.Write([]byte(v))
+	}
+	correct = h.Sum(nil)
+
+	if !bytes.Equal(dig, correct) {
+		t.Errorf("Hashes are not equal")
+	}
+
+	// Override in root, network name and constraint
+	rm.ovr["a"] = ProjectProperties{
+		NetworkName: "nota",
+		Constraint:  NewVersion("fluglehorn"),
+	}
+	dig, err = s.HashInputs()
+	if err != nil {
+		t.Fatalf("HashInputs returned unexpected err: %s", err)
+	}
+
+	h = sha256.New()
+
+	elems = []string{
+		"a",
+		"nota",
+		"fluglehorn",
+		"b",
+		"b",
+		"1.0.0",
+		stdlibPkgs,
+		appenginePkgs,
+		"root",
+		"",
+		"root",
+		"a",
+		"b",
+		"a",
+		"nota",
+		"fluglehorn",
+		"c",
+		"car",
+		"d",
+		"foobranch",
+		"e",
+		"groucho",
+		"plexiglass",
+		"depspec-sm-builtin",
+		"1.0.0",
+	}
+	for _, v := range elems {
+		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/header.png b/vendor/github.com/sdboyer/gps/header.png
new file mode 100644
index 0000000..d39bed6
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/header.png
Binary files differ
diff --git a/vendor/github.com/sdboyer/gps/manager_test.go b/vendor/github.com/sdboyer/gps/manager_test.go
index ebc8091..439d8b4 100644
--- a/vendor/github.com/sdboyer/gps/manager_test.go
+++ b/vendor/github.com/sdboyer/gps/manager_test.go
@@ -5,8 +5,10 @@
 	"io/ioutil"
 	"os"
 	"path"
+	"path/filepath"
 	"runtime"
 	"sort"
+	"sync"
 	"testing"
 
 	"github.com/Masterminds/semver"
@@ -19,10 +21,14 @@
 // this as open/Any constraints on everything in the import graph.
 type naiveAnalyzer struct{}
 
-func (naiveAnalyzer) GetInfo(string, ProjectRoot) (Manifest, Lock, error) {
+func (naiveAnalyzer) DeriveManifestAndLock(string, ProjectRoot) (Manifest, Lock, error) {
 	return nil, nil, nil
 }
 
+func (a naiveAnalyzer) Info() (name string, version *semver.Version) {
+	return "naive-analyzer", sv("v0.0.1")
+}
+
 func sv(s string) *semver.Version {
 	sv, err := semver.NewVersion(s)
 	if err != nil {
@@ -32,6 +38,28 @@
 	return sv
 }
 
+func mkNaiveSM(t *testing.T) (*SourceMgr, func()) {
+	cpath, err := ioutil.TempDir("", "smcache")
+	if err != nil {
+		t.Errorf("Failed to create temp dir: %s", err)
+		t.FailNow()
+	}
+
+	sm, err := NewSourceManager(naiveAnalyzer{}, cpath, false)
+	if err != nil {
+		t.Errorf("Unexpected error on SourceManager creation: %s", err)
+		t.FailNow()
+	}
+
+	return sm, func() {
+		sm.Release()
+		err := removeAll(cpath)
+		if err != nil {
+			t.Errorf("removeAll failed: %s", err)
+		}
+	}
+}
+
 func init() {
 	_, filename, _, _ := runtime.Caller(1)
 	bd = path.Dir(filename)
@@ -79,23 +107,25 @@
 	cpath, err := ioutil.TempDir("", "smcache")
 	if err != nil {
 		t.Errorf("Failed to create temp dir: %s", err)
+		t.FailNow()
 	}
-	sm, err := NewSourceManager(naiveAnalyzer{}, cpath, false)
 
+	sm, err := NewSourceManager(naiveAnalyzer{}, cpath, false)
 	if err != nil {
 		t.Errorf("Unexpected error on SourceManager creation: %s", err)
 		t.FailNow()
 	}
+
 	defer func() {
+		sm.Release()
 		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)
+	id := mkPI("github.com/Masterminds/VCSTestRepo")
+	v, err := sm.ListVersions(id)
 	if err != nil {
 		t.Errorf("Unexpected error during initial project setup/fetching %s", err)
 	}
@@ -122,15 +152,15 @@
 	}
 
 	// 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.
+	// works (or at least doesn't not work) 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),
+		vlists: make(map[ProjectIdentifier][]Version),
 		s:      &solver{},
 	}
 
-	v, err = smc.listVersions(ProjectIdentifier{ProjectRoot: pn})
+	v, err = smc.ListVersions(id)
 	if err != nil {
 		t.Errorf("Unexpected error during initial project setup/fetching %s", err)
 	}
@@ -152,149 +182,96 @@
 		}
 	}
 
+	// use ListPackages to ensure the repo is actually on disk
+	// TODO(sdboyer) ugh, maybe we do need an explicit prefetch method
+	smc.ListPackages(id, NewVersion("1.0.0"))
+
 	// Ensure that the appropriate cache dirs and files exist
-	_, err = os.Stat(path.Join(cpath, "src", "github.com", "Masterminds", "VCSTestRepo", ".git"))
+	_, err = os.Stat(filepath.Join(cpath, "sources", "https---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"))
+	_, err = os.Stat(filepath.Join(cpath, "metadata", "github.com", "Masterminds", "VCSTestRepo", "cache.json"))
 	if err != nil {
-		// TODO(sdboyer) temporarily disabled until we turn caching back on
+		// TODO(sdboyer) disabled until we get caching working
 		//t.Error("Metadata cache json file does not exist in expected location")
 	}
 
-	// Ensure project existence values are what we expect
+	// Ensure source existence values are what we expect
 	var exists bool
-	exists, err = sm.RepoExists(pn)
+	exists, err = sm.SourceExists(id)
 	if err != nil {
-		t.Errorf("Error on checking RepoExists: %s", err)
+		t.Errorf("Error on checking SourceExists: %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")
+		t.Error("Source should exist after non-erroring call to ListVersions")
 	}
 }
 
-func TestRepoVersionFetching(t *testing.T) {
-	// This test is quite slow, skip it on -short
+func TestGetSources(t *testing.T) {
+	// This test is a tad slow, skip it on -short
 	if testing.Short() {
-		t.Skip("Skipping repo version fetching test in short mode")
+		t.Skip("Skipping source setup test in short mode")
 	}
 
-	cpath, err := ioutil.TempDir("", "smcache")
-	if err != nil {
-		t.Errorf("Failed to create temp dir: %s", err)
+	sm, clean := mkNaiveSM(t)
+
+	pil := []ProjectIdentifier{
+		mkPI("github.com/Masterminds/VCSTestRepo"),
+		mkPI("bitbucket.org/mattfarina/testhgrepo"),
+		mkPI("launchpad.net/govcstestbzrrepo"),
 	}
 
-	sm, err := NewSourceManager(naiveAnalyzer{}, cpath, false)
-	if err != nil {
-		t.Errorf("Unexpected error on SourceManager creation: %s", err)
-		t.FailNow()
+	wg := &sync.WaitGroup{}
+	wg.Add(3)
+	for _, pi := range pil {
+		go func(lpi ProjectIdentifier) {
+			nn := lpi.netName()
+			src, err := sm.getSourceFor(lpi)
+			if err != nil {
+				t.Errorf("(src %q) unexpected error setting up source: %s", nn, err)
+				return
+			}
+
+			// Re-get the same, make sure they are the same
+			src2, err := sm.getSourceFor(lpi)
+			if err != nil {
+				t.Errorf("(src %q) unexpected error re-getting source: %s", nn, err)
+			} else if src != src2 {
+				t.Errorf("(src %q) first and second sources are not eq", nn)
+			}
+
+			// All of them _should_ select https, so this should work
+			lpi.NetworkName = "https://" + lpi.NetworkName
+			src3, err := sm.getSourceFor(lpi)
+			if err != nil {
+				t.Errorf("(src %q) unexpected error getting explicit https source: %s", nn, err)
+			} else if src != src3 {
+				t.Errorf("(src %q) explicit https source should reuse autodetected https source", nn)
+			}
+
+			// Now put in http, and they should differ
+			lpi.NetworkName = "http://" + string(lpi.ProjectRoot)
+			src4, err := sm.getSourceFor(lpi)
+			if err != nil {
+				t.Errorf("(src %q) unexpected error getting explicit http source: %s", nn, err)
+			} else if src == src4 {
+				t.Errorf("(src %q) explicit http source should create a new src", nn)
+			}
+
+			wg.Done()
+		}(pi)
 	}
 
-	upstreams := []ProjectRoot{
-		"github.com/Masterminds/VCSTestRepo",
-		"bitbucket.org/mattfarina/testhgrepo",
-		"launchpad.net/govcstestbzrrepo",
-	}
+	wg.Wait()
 
-	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
+	// nine entries (of which three are dupes): for each vcs, raw import path,
+	// the https url, and the http url
+	if len(sm.srcs) != 9 {
+		t.Errorf("Should have nine discrete entries in the srcs map, got %v", len(sm.srcs))
 	}
-
-	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
+	clean()
 }
 
 // Regression test for #32
@@ -304,34 +281,19 @@
 		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()
+	sm, clean := mkNaiveSM(t)
+	defer clean()
 
 	// setup done, now do the test
 
-	pn := ProjectRoot("github.com/Masterminds/VCSTestRepo")
+	id := mkPI("github.com/Masterminds/VCSTestRepo")
 
-	_, _, err = sm.GetProjectInfo(pn, NewVersion("1.0.0"))
+	_, _, err := sm.GetManifestAndLock(id, NewVersion("1.0.0"))
 	if err != nil {
 		t.Errorf("Unexpected error from GetInfoAt %s", err)
 	}
 
-	v, err := sm.ListVersions(pn)
+	v, err := sm.ListVersions(id)
 	if err != nil {
 		t.Errorf("Unexpected error from ListVersions %s", err)
 	}
@@ -340,3 +302,154 @@
 		t.Errorf("Expected three results from ListVersions, got %v", len(v))
 	}
 }
+
+func TestDeduceProjectRoot(t *testing.T) {
+	sm, clean := mkNaiveSM(t)
+	defer clean()
+
+	in := "github.com/sdboyer/gps"
+	pr, err := sm.DeduceProjectRoot(in)
+	if err != nil {
+		t.Errorf("Problem while detecting root of %q %s", in, err)
+	}
+	if string(pr) != in {
+		t.Errorf("Wrong project root was deduced;\n\t(GOT) %s\n\t(WNT) %s", pr, in)
+	}
+	if sm.rootxt.Len() != 1 {
+		t.Errorf("Root path trie should have one element after one deduction, has %v", sm.rootxt.Len())
+	}
+
+	pr, err = sm.DeduceProjectRoot(in)
+	if err != nil {
+		t.Errorf("Problem while detecting root of %q %s", in, err)
+	} else if string(pr) != in {
+		t.Errorf("Wrong project root was deduced;\n\t(GOT) %s\n\t(WNT) %s", pr, in)
+	}
+	if sm.rootxt.Len() != 1 {
+		t.Errorf("Root path trie should still have one element after performing the same deduction twice; has %v", sm.rootxt.Len())
+	}
+
+	// Now do a subpath
+	sub := path.Join(in, "foo")
+	pr, err = sm.DeduceProjectRoot(sub)
+	if err != nil {
+		t.Errorf("Problem while detecting root of %q %s", sub, err)
+	} else if string(pr) != in {
+		t.Errorf("Wrong project root was deduced;\n\t(GOT) %s\n\t(WNT) %s", pr, in)
+	}
+	if sm.rootxt.Len() != 2 {
+		t.Errorf("Root path trie should have two elements, one for root and one for subpath; has %v", sm.rootxt.Len())
+	}
+
+	// Now do a fully different root, but still on github
+	in2 := "github.com/bagel/lox"
+	sub2 := path.Join(in2, "cheese")
+	pr, err = sm.DeduceProjectRoot(sub2)
+	if err != nil {
+		t.Errorf("Problem while detecting root of %q %s", sub2, err)
+	} else if string(pr) != in2 {
+		t.Errorf("Wrong project root was deduced;\n\t(GOT) %s\n\t(WNT) %s", pr, in)
+	}
+	if sm.rootxt.Len() != 4 {
+		t.Errorf("Root path trie should have four elements, one for each unique root and subpath; has %v", sm.rootxt.Len())
+	}
+
+	// Ensure that our prefixes are bounded by path separators
+	in4 := "github.com/bagel/loxx"
+	pr, err = sm.DeduceProjectRoot(in4)
+	if err != nil {
+		t.Errorf("Problem while detecting root of %q %s", in4, err)
+	} else if string(pr) != in4 {
+		t.Errorf("Wrong project root was deduced;\n\t(GOT) %s\n\t(WNT) %s", pr, in)
+	}
+	if sm.rootxt.Len() != 5 {
+		t.Errorf("Root path trie should have five elements, one for each unique root and subpath; has %v", sm.rootxt.Len())
+	}
+
+	// Ensure that vcs extension-based matching comes through
+	in5 := "ffffrrrraaaaaapppppdoesnotresolve.com/baz.git"
+	pr, err = sm.DeduceProjectRoot(in5)
+	if err != nil {
+		t.Errorf("Problem while detecting root of %q %s", in5, err)
+	} else if string(pr) != in5 {
+		t.Errorf("Wrong project root was deduced;\n\t(GOT) %s\n\t(WNT) %s", pr, in)
+	}
+	if sm.rootxt.Len() != 6 {
+		t.Errorf("Root path trie should have six elements, one for each unique root and subpath; has %v", sm.rootxt.Len())
+	}
+}
+
+// Test that the future returned from SourceMgr.deducePathAndProcess() is safe
+// to call concurrently.
+//
+// Obviously, this is just a heuristic; passage does not guarantee correctness
+// (though failure does guarantee incorrectness)
+func TestMultiDeduceThreadsafe(t *testing.T) {
+	sm, clean := mkNaiveSM(t)
+	defer clean()
+
+	in := "github.com/sdboyer/gps"
+	rootf, srcf, err := sm.deducePathAndProcess(in)
+	if err != nil {
+		t.Errorf("Known-good path %q had unexpected basic deduction error: %s", in, err)
+		t.FailNow()
+	}
+
+	cnum := 50
+	wg := &sync.WaitGroup{}
+
+	// Set up channel for everything else to block on
+	c := make(chan struct{}, 1)
+	f := func(rnum int) {
+		defer func() {
+			wg.Done()
+			if e := recover(); e != nil {
+				t.Errorf("goroutine number %v panicked with err: %s", rnum, e)
+			}
+		}()
+		<-c
+		_, err := rootf()
+		if err != nil {
+			t.Errorf("err was non-nil on root detection in goroutine number %v: %s", rnum, err)
+		}
+	}
+
+	for k := range make([]struct{}, cnum) {
+		wg.Add(1)
+		go f(k)
+		runtime.Gosched()
+	}
+	close(c)
+	wg.Wait()
+	if sm.rootxt.Len() != 1 {
+		t.Errorf("Root path trie should have just one element; has %v", sm.rootxt.Len())
+	}
+
+	// repeat for srcf
+	wg2 := &sync.WaitGroup{}
+	c = make(chan struct{}, 1)
+	f = func(rnum int) {
+		defer func() {
+			wg2.Done()
+			if e := recover(); e != nil {
+				t.Errorf("goroutine number %v panicked with err: %s", rnum, e)
+			}
+		}()
+		<-c
+		_, _, err := srcf()
+		if err != nil {
+			t.Errorf("err was non-nil on root detection in goroutine number %v: %s", rnum, err)
+		}
+	}
+
+	for k := range make([]struct{}, cnum) {
+		wg2.Add(1)
+		go f(k)
+		runtime.Gosched()
+	}
+	close(c)
+	wg2.Wait()
+	if len(sm.srcs) != 2 {
+		t.Errorf("Sources map should have just two elements, but has %v", len(sm.srcs))
+	}
+}
diff --git a/vendor/github.com/sdboyer/gps/manifest.go b/vendor/github.com/sdboyer/gps/manifest.go
index 83fd9d7..86d06cc 100644
--- a/vendor/github.com/sdboyer/gps/manifest.go
+++ b/vendor/github.com/sdboyer/gps/manifest.go
@@ -16,11 +16,36 @@
 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.
+
+	// Returns a list of constraints applicable to test imports.
+	//
+	// These are applied only when tests are incorporated. Typically, that
+	// will only be for root manifests.
 	TestDependencyConstraints() []ProjectConstraint
 }
 
+// RootManifest extends Manifest to add special controls over solving that are
+// only afforded to the root project.
+type RootManifest interface {
+	Manifest
+
+	// Overrides returns a list of ProjectConstraints that will unconditionally
+	// supercede any ProjectConstraint declarations made in either the root
+	// manifest, or in any dependency's manifest.
+	//
+	// Overrides are a special control afforded only to root manifests. Tool
+	// users should be encouraged to use them only as a last resort; they do not
+	// "play well with others" (that is their express goal), and overreliance on
+	// them can harm the ecosystem as a whole.
+	Overrides() ProjectConstraints
+
+	// IngorePackages returns a set of import paths to ignore. These import
+	// paths can be within the root project, or part of other projects. Ignoring
+	// a package means that both it and its (unique) imports will be disregarded
+	// by all relevant solver operations.
+	IgnorePackages() map[string]bool
+}
+
 // 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
@@ -42,6 +67,30 @@
 	return m.TestDeps
 }
 
+// simpleRootManifest exists so that we have a safe value to swap into solver
+// params when a nil Manifest is provided.
+//
+// Also, for tests.
+type simpleRootManifest struct {
+	c   []ProjectConstraint
+	tc  []ProjectConstraint
+	ovr ProjectConstraints
+	ig  map[string]bool
+}
+
+func (m simpleRootManifest) DependencyConstraints() []ProjectConstraint {
+	return m.c
+}
+func (m simpleRootManifest) TestDependencyConstraints() []ProjectConstraint {
+	return m.tc
+}
+func (m simpleRootManifest) Overrides() ProjectConstraints {
+	return m.ovr
+}
+func (m simpleRootManifest) IgnorePackages() map[string]bool {
+	return m.ig
+}
+
 // prepManifest ensures a manifest is prepared and safe for use by the solver.
 // This entails two things:
 //
diff --git a/vendor/github.com/sdboyer/gps/marker-header.png b/vendor/github.com/sdboyer/gps/marker-header.png
deleted file mode 100644
index 66965c5..0000000
--- a/vendor/github.com/sdboyer/gps/marker-header.png
+++ /dev/null
Binary files differ
diff --git a/vendor/github.com/sdboyer/gps/maybe_source.go b/vendor/github.com/sdboyer/gps/maybe_source.go
new file mode 100644
index 0000000..34fd5d5
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/maybe_source.go
@@ -0,0 +1,153 @@
+package gps
+
+import (
+	"bytes"
+	"fmt"
+	"net/url"
+	"path/filepath"
+
+	"github.com/Masterminds/vcs"
+)
+
+type maybeSource interface {
+	try(cachedir string, an ProjectAnalyzer) (source, string, error)
+}
+
+type maybeSources []maybeSource
+
+func (mbs maybeSources) try(cachedir string, an ProjectAnalyzer) (source, string, error) {
+	var e sourceFailures
+	for _, mb := range mbs {
+		src, ident, err := mb.try(cachedir, an)
+		if err == nil {
+			return src, ident, nil
+		}
+		e = append(e, sourceSetupFailure{
+			ident: ident,
+			err:   err,
+		})
+	}
+	return nil, "", e
+}
+
+type sourceSetupFailure struct {
+	ident string
+	err   error
+}
+
+func (e sourceSetupFailure) Error() string {
+	return fmt.Sprintf("failed to set up %q, error %s", e.ident, e.err.Error())
+}
+
+type sourceFailures []sourceSetupFailure
+
+func (sf sourceFailures) Error() string {
+	var buf bytes.Buffer
+	fmt.Fprintf(&buf, "No valid source could be created:\n")
+	for _, e := range sf {
+		fmt.Fprintf(&buf, "\t%s", e.Error())
+	}
+
+	return buf.String()
+}
+
+type maybeGitSource struct {
+	url *url.URL
+}
+
+func (m maybeGitSource) try(cachedir string, an ProjectAnalyzer) (source, string, error) {
+	ustr := m.url.String()
+	path := filepath.Join(cachedir, "sources", sanitizer.Replace(ustr))
+	r, err := vcs.NewGitRepo(ustr, path)
+	if err != nil {
+		return nil, "", err
+	}
+
+	src := &gitSource{
+		baseVCSSource: baseVCSSource{
+			an: an,
+			dc: newMetaCache(),
+			crepo: &repo{
+				r:     r,
+				rpath: path,
+			},
+		},
+	}
+
+	src.baseVCSSource.lvfunc = src.listVersions
+
+	_, err = src.listVersions()
+	if err != nil {
+		return nil, "", err
+	}
+
+	return src, ustr, nil
+}
+
+type maybeBzrSource struct {
+	url *url.URL
+}
+
+func (m maybeBzrSource) try(cachedir string, an ProjectAnalyzer) (source, string, error) {
+	ustr := m.url.String()
+	path := filepath.Join(cachedir, "sources", sanitizer.Replace(ustr))
+	r, err := vcs.NewBzrRepo(ustr, path)
+	if err != nil {
+		return nil, "", err
+	}
+	if !r.Ping() {
+		return nil, "", fmt.Errorf("Remote repository at %s does not exist, or is inaccessible", ustr)
+	}
+
+	src := &bzrSource{
+		baseVCSSource: baseVCSSource{
+			an: an,
+			dc: newMetaCache(),
+			ex: existence{
+				s: existsUpstream,
+				f: existsUpstream,
+			},
+			crepo: &repo{
+				r:     r,
+				rpath: path,
+			},
+		},
+	}
+	src.baseVCSSource.lvfunc = src.listVersions
+
+	return src, ustr, nil
+}
+
+type maybeHgSource struct {
+	url *url.URL
+}
+
+func (m maybeHgSource) try(cachedir string, an ProjectAnalyzer) (source, string, error) {
+	ustr := m.url.String()
+	path := filepath.Join(cachedir, "sources", sanitizer.Replace(ustr))
+	r, err := vcs.NewHgRepo(ustr, path)
+	if err != nil {
+		return nil, "", err
+	}
+	if !r.Ping() {
+		return nil, "", fmt.Errorf("Remote repository at %s does not exist, or is inaccessible", ustr)
+	}
+
+	src := &hgSource{
+		baseVCSSource: baseVCSSource{
+			an: an,
+			dc: newMetaCache(),
+			ex: existence{
+				s: existsUpstream,
+				f: existsUpstream,
+			},
+			crepo: &repo{
+				r:     r,
+				rpath: path,
+			},
+		},
+	}
+	src.baseVCSSource.lvfunc = src.listVersions
+
+	return src, ustr, nil
+}
diff --git a/vendor/github.com/sdboyer/gps/project_manager.go b/vendor/github.com/sdboyer/gps/project_manager.go
deleted file mode 100644
index e174fde..0000000
--- a/vendor/github.com/sdboyer/gps/project_manager.go
+++ /dev/null
@@ -1,584 +0,0 @@
-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
deleted file mode 100644
index c808d9a..0000000
--- a/vendor/github.com/sdboyer/gps/remote.go
+++ /dev/null
@@ -1,306 +0,0 @@
-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
deleted file mode 100644
index 17de00f..0000000
--- a/vendor/github.com/sdboyer/gps/remote_test.go
+++ /dev/null
@@ -1,478 +0,0 @@
-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/result.go b/vendor/github.com/sdboyer/gps/result.go
index e601de9..00dac45 100644
--- a/vendor/github.com/sdboyer/gps/result.go
+++ b/vendor/github.com/sdboyer/gps/result.go
@@ -25,13 +25,13 @@
 	hd []byte
 }
 
-// CreateVendorTree takes a basedir and a Lock, and exports all the projects
+// WriteDepTree 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 {
+func WriteDepTree(basedir string, l Lock, sm SourceManager, sv bool) error {
 	err := os.MkdirAll(basedir, 0777)
 	if err != nil {
 		return err
@@ -46,7 +46,7 @@
 			return err
 		}
 
-		err = sm.ExportProject(p.Ident().ProjectRoot, p.Version(), to)
+		err = sm.ExportProject(p.Ident(), p.Version(), to)
 		if err != nil {
 			removeAll(basedir)
 			return fmt.Errorf("Error while exporting %s: %s", p.Ident().ProjectRoot, err)
diff --git a/vendor/github.com/sdboyer/gps/result_test.go b/vendor/github.com/sdboyer/gps/result_test.go
index 1aed83b..2ae07ec 100644
--- a/vendor/github.com/sdboyer/gps/result_test.go
+++ b/vendor/github.com/sdboyer/gps/result_test.go
@@ -48,12 +48,10 @@
 	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)
-	}
+	sm, clean := mkNaiveSM(t)
+	defer clean()
 
-	err = CreateVendorTree(path.Join(tmp, "export"), r, sm, true)
+	err := WriteDepTree(path.Join(tmp, "export"), r, sm, true)
 	if err != nil {
 		t.Errorf("Unexpected error while creating vendor tree: %s", err)
 	}
@@ -77,7 +75,7 @@
 
 	// Prefetch the projects before timer starts
 	for _, lp := range r.p {
-		_, _, err := sm.GetProjectInfo(lp.Ident().ProjectRoot, lp.Version())
+		_, _, err := sm.GetManifestAndLock(lp.Ident(), lp.Version())
 		if err != nil {
 			b.Errorf("failed getting project info during prefetch: %s", err)
 			clean = false
@@ -93,7 +91,7 @@
 			// ease manual inspection
 			os.RemoveAll(exp)
 			b.StartTimer()
-			err = CreateVendorTree(exp, r, sm, true)
+			err = WriteDepTree(exp, r, sm, true)
 			b.StopTimer()
 			if err != nil {
 				b.Errorf("unexpected error after %v iterations: %s", i, err)
diff --git a/vendor/github.com/sdboyer/gps/satisfy.go b/vendor/github.com/sdboyer/gps/satisfy.go
index 8c99f47..ef9e688 100644
--- a/vendor/github.com/sdboyer/gps/satisfy.go
+++ b/vendor/github.com/sdboyer/gps/satisfy.go
@@ -1,9 +1,12 @@
 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 {
+// check performs constraint checks on the provided atom. The set of checks
+// differ slightly depending on whether the atom is pkgonly, or if it's the
+// entire project being added for the first time.
+//
+// The goal is to determine whether selecting the atom would result in a state
+// where all the solver requirements are still satisfied.
+func (s *solver) check(a atomWithPackages, pkgonly bool) error {
 	pa := a.a
 	if nilpa == pa {
 		// This shouldn't be able to happen, but if it does, it unequivocally
@@ -11,44 +14,52 @@
 		panic("canary - checking version of empty ProjectAtom")
 	}
 
-	if err := s.checkAtomAllowable(pa); err != nil {
-		s.logSolve(err)
-		return err
+	// If we're pkgonly, then base atom was already determined to be allowable,
+	// so we can skip the checkAtomAllowable step.
+	if !pkgonly {
+		if err := s.checkAtomAllowable(pa); err != nil {
+			s.traceInfo(err)
+			return err
+		}
 	}
 
 	if err := s.checkRequiredPackagesExist(a); err != nil {
-		s.logSolve(err)
+		s.traceInfo(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?
+		// TODO(sdboyer) can we traceInfo this?
 		return err
 	}
 
+	// TODO(sdboyer) this deps list contains only packages not already selected
+	// from the target atom (assuming one is selected at all). It's fine for
+	// now, but won't be good enough when we get around to doing static
+	// analysis.
 	for _, dep := range deps {
 		if err := s.checkIdentMatches(a, dep); err != nil {
-			s.logSolve(err)
+			s.traceInfo(err)
 			return err
 		}
 		if err := s.checkDepsConstraintsAllowable(a, dep); err != nil {
-			s.logSolve(err)
+			s.traceInfo(err)
 			return err
 		}
 		if err := s.checkDepsDisallowsSelected(a, dep); err != nil {
-			s.logSolve(err)
+			s.traceInfo(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)
+		//s.traceInfo(err)
 		//return err
 		//}
 		if err := s.checkPackageImportsFromDepExist(a, dep); err != nil {
-			s.logSolve(err)
+			s.traceInfo(err)
 			return err
 		}
 
@@ -58,53 +69,6 @@
 	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 {
@@ -135,7 +99,7 @@
 // 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)
+	ptree, err := s.b.ListPackages(a.a.id, a.a.v)
 	if err != nil {
 		// TODO(sdboyer) handle this more gracefully
 		return err
@@ -175,7 +139,7 @@
 // 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
+	dep := cdep.workingConstraint
 	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.
@@ -208,7 +172,7 @@
 // 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
+	dep := cdep.workingConstraint
 	selected, exists := s.sel.selected(dep.Ident)
 	if exists && !s.b.matches(dep.Ident, dep.Constraint, selected.a.v) {
 		s.fail(dep.Ident)
@@ -229,7 +193,7 @@
 // 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
+	dep := cdep.workingConstraint
 	if cur, exists := s.names[dep.Ident.ProjectRoot]; exists {
 		if cur != dep.Ident.netName() {
 			deps := s.sel.getDependenciesOn(a.a.id)
@@ -255,13 +219,13 @@
 // 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)
+	sel, is := s.sel.selected(cdep.workingConstraint.Ident)
 	if !is {
 		// dep is not already selected; nothing to do
 		return nil
 	}
 
-	ptree, err := s.b.listPackages(sel.a.id, sel.a.v)
+	ptree, err := s.b.ListPackages(sel.a.id, sel.a.v)
 	if err != nil {
 		// TODO(sdboyer) handle this more gracefully
 		return err
@@ -279,14 +243,15 @@
 	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
+			} else {
+				e.prob[pkg] = nil
 			}
 		}
 	}
 
-	if len(e.pl) > 0 {
+	if len(e.prob) > 0 {
 		return e
 	}
 	return nil
@@ -301,7 +266,7 @@
 		return nil
 	}
 
-	present, _ := s.b.revisionPresentIn(cdep.Ident, r)
+	present, _ := s.b.RevisionPresentIn(cdep.Ident, r)
 	if present {
 		return nil
 	}
diff --git a/vendor/github.com/sdboyer/gps/selection.go b/vendor/github.com/sdboyer/gps/selection.go
index 6d84643..9362fb0 100644
--- a/vendor/github.com/sdboyer/gps/selection.go
+++ b/vendor/github.com/sdboyer/gps/selection.go
@@ -22,10 +22,10 @@
 // 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) {
+func (s *selection) pushSelection(a atomWithPackages, pkgonly bool) {
 	s.projects = append(s.projects, selected{
 		a:     a,
-		first: first,
+		first: !pkgonly,
 	})
 }
 
diff --git a/vendor/github.com/sdboyer/gps/solve_basic_test.go b/vendor/github.com/sdboyer/gps/solve_basic_test.go
index 055ecc8..6b6a092 100644
--- a/vendor/github.com/sdboyer/gps/solve_basic_test.go
+++ b/vendor/github.com/sdboyer/gps/solve_basic_test.go
@@ -81,6 +81,16 @@
 // 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 {
+	// if info is "root", special case it to use the root "version"
+	if info == "root" {
+		return atom{
+			id: ProjectIdentifier{
+				ProjectRoot: ProjectRoot("root"),
+			},
+			v: rootRev,
+		}
+	}
+
 	id, ver, rev := nvrSplit(info)
 
 	var v Version
@@ -113,7 +123,7 @@
 	}
 }
 
-// mkPDep splits the input string on a space, and uses the first two elements
+// mkPCstrnt 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
@@ -124,7 +134,7 @@
 //  r: create a revision.
 //
 // If no leading character is used, a semver constraint is assumed.
-func mkPDep(info string) ProjectConstraint {
+func mkPCstrnt(info string) ProjectConstraint {
 	id, ver, rev := nvrSplit(info)
 
 	var c Constraint
@@ -164,6 +174,21 @@
 	}
 }
 
+// mkCDep composes a completeDep struct from the inputs.
+//
+// The only real work here is passing the initial string to mkPDep. All the
+// other args are taken as package names.
+func mkCDep(pdep string, pl ...string) completeDep {
+	pc := mkPCstrnt(pdep)
+	return completeDep{
+		workingConstraint: workingConstraint{
+			Ident:      pc.Ident,
+			Constraint: pc.Constraint,
+		},
+		pl: pl,
+	}
+}
+
 // A depspec is a fixture representing all the information a SourceManager would
 // ordinarily glean directly from interrogating a repository.
 type depspec struct {
@@ -204,12 +229,53 @@
 			sl = &ds.deps
 		}
 
-		*sl = append(*sl, mkPDep(dep))
+		*sl = append(*sl, mkPCstrnt(dep))
 	}
 
 	return ds
 }
 
+func mkDep(atom, pdep string, pl ...string) dependency {
+	return dependency{
+		depender: mkAtom(atom),
+		dep:      mkCDep(pdep, pl...),
+	}
+}
+
+func mkADep(atom, pdep string, c Constraint, pl ...string) dependency {
+	return dependency{
+		depender: mkAtom(atom),
+		dep: completeDep{
+			workingConstraint: workingConstraint{
+				Ident: ProjectIdentifier{
+					ProjectRoot: ProjectRoot(pdep),
+					NetworkName: pdep,
+				},
+				Constraint: c,
+			},
+			pl: pl,
+		},
+	}
+}
+
+// mkPI creates a ProjectIdentifier with the ProjectRoot as the provided
+// string, and with the NetworkName normalized to be the same.
+func mkPI(root string) ProjectIdentifier {
+	return ProjectIdentifier{
+		ProjectRoot: ProjectRoot(root),
+		NetworkName: root,
+	}
+}
+
+// mkSVC creates a new semver constraint, panicking if an error is returned.
+func mkSVC(body string) Constraint {
+	c, err := NewSemverConstraint(body)
+	if err != nil {
+		panic(fmt.Sprintf("Error while trying to create semver constraint from %s: %s", body, err.Error()))
+	}
+	return c
+}
+
 // mklock makes a fixLock, suitable to act as a lock file
 func mklock(pairs ...string) fixLock {
 	l := make(fixLock, 0)
@@ -287,10 +353,11 @@
 
 type specfix interface {
 	name() string
+	rootmanifest() RootManifest
 	specs() []depspec
 	maxTries() int
-	expectErrs() []string
 	solution() map[string]Version
+	failure() error
 }
 
 // A basicFixture is a declarative test fixture that can cover a wide variety of
@@ -320,8 +387,10 @@
 	downgrade bool
 	// lock file simulator, if one's to be used at all
 	l fixLock
-	// projects expected to have errors, if any
-	errp []string
+	// solve failure expected, if any
+	fail error
+	// overrides, if any
+	ovr ProjectConstraints
 	// request up/downgrade to all projects
 	changeall bool
 }
@@ -338,14 +407,22 @@
 	return f.maxAttempts
 }
 
-func (f basicFixture) expectErrs() []string {
-	return f.errp
-}
-
 func (f basicFixture) solution() map[string]Version {
 	return f.r
 }
 
+func (f basicFixture) rootmanifest() RootManifest {
+	return simpleRootManifest{
+		c:   f.ds[0].deps,
+		tc:  f.ds[0].devdeps,
+		ovr: f.ovr,
+	}
+}
+
+func (f basicFixture) failure() error {
+	return f.fail
+}
+
 // A table of basicFixtures, used in the basic solving test set.
 var basicFixtures = map[string]basicFixture{
 	// basic fixtures
@@ -448,8 +525,21 @@
 			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"},
+		fail: &noVersionError{
+			pn: mkPI("foo"),
+			fails: []failedVersion{
+				{
+					v: NewVersion("1.0.0"),
+					f: &sourceMismatchFailure{
+						shared:   ProjectRoot("bar"),
+						current:  "bar",
+						mismatch: "baz",
+						prob:     mkAtom("foo 1.0.0"),
+						sel:      []dependency{mkDep("root", "foo 1.0.0", "foo")},
+					},
+				},
+			},
+		},
 	},
 	// fixtures with locks
 	"with compatible locked dependency": {
@@ -679,7 +769,27 @@
 			mkDepspec("foo 2.0.0"),
 			mkDepspec("foo 2.1.3"),
 		},
-		errp: []string{"foo", "root"},
+		fail: &noVersionError{
+			pn: mkPI("foo"),
+			fails: []failedVersion{
+				{
+					v: NewVersion("2.1.3"),
+					f: &versionNotAllowedFailure{
+						goal:       mkAtom("foo 2.1.3"),
+						failparent: []dependency{mkDep("root", "foo ^1.0.0", "foo")},
+						c:          mkSVC("^1.0.0"),
+					},
+				},
+				{
+					v: NewVersion("2.0.0"),
+					f: &versionNotAllowedFailure{
+						goal:       mkAtom("foo 2.0.0"),
+						failparent: []dependency{mkDep("root", "foo ^1.0.0", "foo")},
+						c:          mkSVC("^1.0.0"),
+					},
+				},
+			},
+		},
 	},
 	"no version that matches combined constraint": {
 		ds: []depspec{
@@ -689,7 +799,27 @@
 			mkDepspec("shared 2.5.0"),
 			mkDepspec("shared 3.5.0"),
 		},
-		errp: []string{"shared", "foo", "bar"},
+		fail: &noVersionError{
+			pn: mkPI("shared"),
+			fails: []failedVersion{
+				{
+					v: NewVersion("3.5.0"),
+					f: &versionNotAllowedFailure{
+						goal:       mkAtom("shared 3.5.0"),
+						failparent: []dependency{mkDep("foo 1.0.0", "shared >=2.0.0, <3.0.0", "shared")},
+						c:          mkSVC(">=2.9.0, <3.0.0"),
+					},
+				},
+				{
+					v: NewVersion("2.5.0"),
+					f: &versionNotAllowedFailure{
+						goal:       mkAtom("shared 2.5.0"),
+						failparent: []dependency{mkDep("bar 1.0.0", "shared >=2.9.0, <4.0.0", "shared")},
+						c:          mkSVC(">=2.9.0, <3.0.0"),
+					},
+				},
+			},
+		},
 	},
 	"disjoint constraints": {
 		ds: []depspec{
@@ -699,8 +829,20 @@
 			mkDepspec("shared 2.0.0"),
 			mkDepspec("shared 4.0.0"),
 		},
-		//errp: []string{"shared", "foo", "bar"}, // dart's has this...
-		errp: []string{"foo", "bar"},
+		fail: &noVersionError{
+			pn: mkPI("foo"),
+			fails: []failedVersion{
+				{
+					v: NewVersion("1.0.0"),
+					f: &disjointConstraintFailure{
+						goal:      mkDep("foo 1.0.0", "shared <=2.0.0", "shared"),
+						failsib:   []dependency{mkDep("bar 1.0.0", "shared >3.0.0", "shared")},
+						nofailsib: nil,
+						c:         mkSVC(">3.0.0"),
+					},
+				},
+			},
+		},
 	},
 	"no valid solution": {
 		ds: []depspec{
@@ -710,8 +852,26 @@
 			mkDepspec("b 1.0.0", "a 2.0.0"),
 			mkDepspec("b 2.0.0", "a 1.0.0"),
 		},
-		errp:        []string{"b", "a"},
-		maxAttempts: 2,
+		fail: &noVersionError{
+			pn: mkPI("b"),
+			fails: []failedVersion{
+				{
+					v: NewVersion("2.0.0"),
+					f: &versionNotAllowedFailure{
+						goal:       mkAtom("b 2.0.0"),
+						failparent: []dependency{mkDep("a 1.0.0", "b 1.0.0", "b")},
+						c:          mkSVC("1.0.0"),
+					},
+				},
+				{
+					v: NewVersion("1.0.0"),
+					f: &constraintNotAllowedFailure{
+						goal: mkDep("b 1.0.0", "a 2.0.0", "a"),
+						v:    NewVersion("1.0.0"),
+					},
+				},
+			},
+		},
 	},
 	"no version that matches while backtracking": {
 		ds: []depspec{
@@ -719,7 +879,19 @@
 			mkDepspec("a 1.0.0"),
 			mkDepspec("b 1.0.0"),
 		},
-		errp: []string{"b", "root"},
+		fail: &noVersionError{
+			pn: mkPI("b"),
+			fails: []failedVersion{
+				{
+					v: NewVersion("1.0.0"),
+					f: &versionNotAllowedFailure{
+						goal:       mkAtom("b 1.0.0"),
+						failparent: []dependency{mkDep("root", "b >1.0.0", "b")},
+						c:          mkSVC(">1.0.0"),
+					},
+				},
+			},
+		},
 	},
 	// 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
@@ -829,8 +1001,19 @@
 			mkDepspec("bar 3.0.0"),
 			mkDepspec("none 1.0.0"),
 		},
-		errp:        []string{"none", "foo"},
-		maxAttempts: 1,
+		fail: &noVersionError{
+			pn: mkPI("none"),
+			fails: []failedVersion{
+				{
+					v: NewVersion("1.0.0"),
+					f: &versionNotAllowedFailure{
+						goal:       mkAtom("none 1.0.0"),
+						failparent: []dependency{mkDep("foo 1.0.0", "none 2.0.0", "none")},
+						c:          mkSVC("2.0.0"),
+					},
+				},
+			},
+		},
 	},
 	// 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
@@ -866,6 +1049,59 @@
 			"foo r123abc",
 		),
 	},
+	// Some basic override checks
+	"override root's own constraint": {
+		ds: []depspec{
+			mkDepspec("root 0.0.0", "a *", "b *"),
+			mkDepspec("a 1.0.0", "b 1.0.0"),
+			mkDepspec("a 2.0.0", "b 1.0.0"),
+			mkDepspec("b 1.0.0"),
+		},
+		ovr: ProjectConstraints{
+			ProjectRoot("a"): ProjectProperties{
+				Constraint: NewVersion("1.0.0"),
+			},
+		},
+		r: mksolution(
+			"a 1.0.0",
+			"b 1.0.0",
+		),
+	},
+	"override dep's constraint": {
+		ds: []depspec{
+			mkDepspec("root 0.0.0", "a *"),
+			mkDepspec("a 1.0.0", "b 1.0.0"),
+			mkDepspec("a 2.0.0", "b 1.0.0"),
+			mkDepspec("b 1.0.0"),
+			mkDepspec("b 2.0.0"),
+		},
+		ovr: ProjectConstraints{
+			ProjectRoot("b"): ProjectProperties{
+				Constraint: NewVersion("2.0.0"),
+			},
+		},
+		r: mksolution(
+			"a 2.0.0",
+			"b 2.0.0",
+		),
+	},
+	"overridden mismatched net addrs, alt in dep, back to default": {
+		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"),
+		},
+		ovr: ProjectConstraints{
+			ProjectRoot("bar"): ProjectProperties{
+				NetworkName: "bar",
+			},
+		},
+		r: mksolution(
+			"foo 1.0.0",
+			"bar 1.0.0",
+		),
+	},
+
 	// TODO(sdboyer) decide how to refactor the solver in order to re-enable these.
 	// Checking for revision existence is important...but kinda obnoxious.
 	//{
@@ -966,37 +1202,43 @@
 	}
 }
 
-func (sm *depspecSourceManager) GetProjectInfo(n ProjectRoot, v Version) (Manifest, Lock, error) {
+func (sm *depspecSourceManager) GetManifestAndLock(id ProjectIdentifier, v Version) (Manifest, Lock, error) {
 	for _, ds := range sm.specs {
-		if n == ds.n && v.Matches(ds.v) {
+		if id.ProjectRoot == 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)
+	return nil, nil, fmt.Errorf("Project %s at version %s could not be found", id.errString(), 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 {
+func (sm *depspecSourceManager) AnalyzerInfo() (string, *semver.Version) {
+	return "depspec-sm-builtin", sv("v1.0.0")
+}
+
+func (sm *depspecSourceManager) ExternalReach(id ProjectIdentifier, v Version) (map[string][]string, error) {
+	pid := pident{n: id.ProjectRoot, v: v}
+	if m, exists := sm.rm[pid]; exists {
 		return m, nil
 	}
-	return nil, fmt.Errorf("No reach data for %s at version %s", n, v)
+	return nil, fmt.Errorf("No reach data for %s at version %s", id.errString(), v)
 }
 
-func (sm *depspecSourceManager) ListExternal(n ProjectRoot, v Version) ([]string, error) {
+func (sm *depspecSourceManager) ListExternal(id ProjectIdentifier, 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
+	pid := pident{n: id.ProjectRoot, v: v}
+	if r, exists := sm.rm[pid]; exists {
+		return r[string(id.ProjectRoot)], nil
 	}
-	return nil, fmt.Errorf("No reach data for %s at version %s", n, v)
+	return nil, fmt.Errorf("No reach data for %s at version %s", id.errString(), v)
 }
 
-func (sm *depspecSourceManager) ListPackages(n ProjectRoot, v Version) (PackageTree, error) {
-	id := pident{n: n, v: v}
-	if r, exists := sm.rm[id]; exists {
+func (sm *depspecSourceManager) ListPackages(id ProjectIdentifier, v Version) (PackageTree, error) {
+	pid := pident{n: id.ProjectRoot, v: v}
+	n := id.ProjectRoot
+
+	if r, exists := sm.rm[pid]; exists {
 		ptree := PackageTree{
 			ImportRoot: string(n),
 			Packages: map[string]PackageOrErr{
@@ -1015,35 +1257,35 @@
 	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) {
+func (sm *depspecSourceManager) ListVersions(id ProjectIdentifier) (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 {
+		if _, isrev := ds.v.(Revision); !isrev && id.ProjectRoot == ds.n {
 			pi = append(pi, ds.v)
 		}
 	}
 
 	if len(pi) == 0 {
-		err = fmt.Errorf("Project %s could not be found", name)
+		err = fmt.Errorf("Project %s could not be found", id.errString())
 	}
 
 	return
 }
 
-func (sm *depspecSourceManager) RevisionPresentIn(name ProjectRoot, r Revision) (bool, error) {
+func (sm *depspecSourceManager) RevisionPresentIn(id ProjectIdentifier, r Revision) (bool, error) {
 	for _, ds := range sm.specs {
-		if name == ds.n && r == ds.v {
+		if id.ProjectRoot == ds.n && r == ds.v {
 			return true, nil
 		}
 	}
 
-	return false, fmt.Errorf("Project %s has no revision %s", name, r)
+	return false, fmt.Errorf("Project %s has no revision %s", id.errString(), r)
 }
 
-func (sm *depspecSourceManager) RepoExists(name ProjectRoot) (bool, error) {
+func (sm *depspecSourceManager) SourceExists(id ProjectIdentifier) (bool, error) {
 	for _, ds := range sm.specs {
-		if name == ds.n {
+		if id.ProjectRoot == ds.n {
 			return true, nil
 		}
 	}
@@ -1051,16 +1293,26 @@
 	return false, nil
 }
 
-func (sm *depspecSourceManager) VendorCodeExists(name ProjectRoot) (bool, error) {
+func (sm *depspecSourceManager) VendorCodeExists(id ProjectIdentifier) (bool, error) {
 	return false, nil
 }
 
 func (sm *depspecSourceManager) Release() {}
 
-func (sm *depspecSourceManager) ExportProject(n ProjectRoot, v Version, to string) error {
+func (sm *depspecSourceManager) ExportProject(id ProjectIdentifier, v Version, to string) error {
 	return fmt.Errorf("dummy sm doesn't support exporting")
 }
 
+func (sm *depspecSourceManager) DeduceProjectRoot(ip string) (ProjectRoot, error) {
+	for _, ds := range sm.allSpecs() {
+		n := string(ds.n)
+		if ip == n || strings.HasPrefix(ip, n+"/") {
+			return ProjectRoot(n), nil
+		}
+	}
+	return "", fmt.Errorf("Could not find %s, or any parent, in list of known fixtures", ip)
+}
+
 func (sm *depspecSourceManager) rootSpec() depspec {
 	return sm.specs[0]
 }
@@ -1084,7 +1336,7 @@
 	dsm := b.sm.(fixSM)
 	root := dsm.rootSpec()
 
-	ptree, err := dsm.ListPackages(root.n, nil)
+	ptree, err := dsm.ListPackages(mkPI(string(root.n)), nil)
 	if err != nil {
 		return nil, err
 	}
@@ -1102,23 +1354,8 @@
 	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)
+func (b *depspecBridge) ListPackages(id ProjectIdentifier, v Version) (PackageTree, error) {
+	return b.sm.(fixSM).ListPackages(id, v)
 }
 
 // enforce interfaces
diff --git a/vendor/github.com/sdboyer/gps/solve_bimodal_test.go b/vendor/github.com/sdboyer/gps/solve_bimodal_test.go
index 09333e0..f62619d 100644
--- a/vendor/github.com/sdboyer/gps/solve_bimodal_test.go
+++ b/vendor/github.com/sdboyer/gps/solve_bimodal_test.go
@@ -320,7 +320,25 @@
 				pkg("a"),
 			),
 		},
-		errp: []string{"a", "root", "a"},
+		fail: &noVersionError{
+			pn: mkPI("a"),
+			fails: []failedVersion{
+				{
+					v: NewVersion("1.0.0"),
+					f: &checkeeHasProblemPackagesFailure{
+						goal: mkAtom("a 1.0.0"),
+						failpkg: map[string]errDeppers{
+							"a/foo": errDeppers{
+								err: nil, // nil indicates package is missing
+								deppers: []atom{
+									mkAtom("root"),
+								},
+							},
+						},
+					},
+				},
+			},
+		},
 	},
 	// Transitive deps from one project (a) get incrementally included as other
 	// deps incorporate its various packages, and fail with proper error when we
@@ -345,7 +363,21 @@
 				pkg("d", "a/nonexistent"),
 			),
 		},
-		errp: []string{"d", "a", "d"},
+		fail: &noVersionError{
+			pn: mkPI("d"),
+			fails: []failedVersion{
+				{
+					v: NewVersion("1.0.0"),
+					f: &depHasProblemPackagesFailure{
+						goal: mkADep("d 1.0.0", "a", Any(), "a/nonexistent"),
+						v:    NewVersion("1.0.0"),
+						prob: map[string]error{
+							"a/nonexistent": nil,
+						},
+					},
+				},
+			},
+		},
 	},
 	// Check ignores on the root project
 	"ignore in double-subpkg": {
@@ -466,6 +498,66 @@
 			"b 2.0.0 barrev",
 		),
 	},
+	"override unconstrained root import": {
+		ds: []depspec{
+			dsp(mkDepspec("root 0.0.0"),
+				pkg("root", "a")),
+			dsp(mkDepspec("a 1.0.0"),
+				pkg("a")),
+			dsp(mkDepspec("a 2.0.0"),
+				pkg("a")),
+		},
+		ovr: ProjectConstraints{
+			ProjectRoot("a"): ProjectProperties{
+				Constraint: NewVersion("1.0.0"),
+			},
+		},
+		r: mksolution(
+			"a 1.0.0",
+		),
+	},
+	"overridden mismatched net addrs, alt in dep": {
+		ds: []depspec{
+			dsp(mkDepspec("root 0.0.0"),
+				pkg("root", "foo")),
+			dsp(mkDepspec("foo 1.0.0", "bar from baz 1.0.0"),
+				pkg("foo", "bar")),
+			dsp(mkDepspec("bar 1.0.0"),
+				pkg("bar")),
+			dsp(mkDepspec("baz 1.0.0"),
+				pkg("bar")),
+		},
+		ovr: ProjectConstraints{
+			ProjectRoot("bar"): ProjectProperties{
+				NetworkName: "baz",
+			},
+		},
+		r: mksolution(
+			"foo 1.0.0",
+			"bar from baz 1.0.0",
+		),
+	},
+	"overridden mismatched net addrs, alt in root": {
+		ds: []depspec{
+			dsp(mkDepspec("root 0.0.0", "bar from baz 1.0.0"),
+				pkg("root", "foo")),
+			dsp(mkDepspec("foo 1.0.0"),
+				pkg("foo", "bar")),
+			dsp(mkDepspec("bar 1.0.0"),
+				pkg("bar")),
+			dsp(mkDepspec("baz 1.0.0"),
+				pkg("bar")),
+		},
+		ovr: ProjectConstraints{
+			ProjectRoot("bar"): ProjectProperties{
+				NetworkName: "baz",
+			},
+		},
+		r: mksolution(
+			"foo 1.0.0",
+			"bar from baz 1.0.0",
+		),
+	},
 }
 
 // tpkg is a representation of a single package. It has its own import path, as
@@ -493,8 +585,10 @@
 	// 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
+	// solve failure expected, if any
+	fail error
+	// overrides, if any
+	ovr ProjectConstraints
 	// request up/downgrade to all projects
 	changeall bool
 	// pkgs to ignore
@@ -513,14 +607,28 @@
 	return f.maxAttempts
 }
 
-func (f bimodalFixture) expectErrs() []string {
-	return f.errp
-}
-
 func (f bimodalFixture) solution() map[string]Version {
 	return f.r
 }
 
+func (f bimodalFixture) rootmanifest() RootManifest {
+	m := simpleRootManifest{
+		c:   f.ds[0].deps,
+		tc:  f.ds[0].devdeps,
+		ovr: f.ovr,
+		ig:  make(map[string]bool),
+	}
+	for _, ig := range f.ignore {
+		m.ig[ig] = true
+	}
+
+	return m
+}
+
+func (f bimodalFixture) failure() error {
+	return f.fail
+}
+
 // 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.
@@ -541,12 +649,12 @@
 	return sm
 }
 
-func (sm *bmSourceManager) ListPackages(n ProjectRoot, v Version) (PackageTree, error) {
+func (sm *bmSourceManager) ListPackages(id ProjectIdentifier, 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)) {
+		if id.ProjectRoot == ds.n && (k == 0 || ds.v.Matches(v)) {
 			ptree := PackageTree{
-				ImportRoot: string(n),
+				ImportRoot: string(id.ProjectRoot),
 				Packages:   make(map[string]PackageOrErr),
 			}
 			for _, pkg := range ds.pkgs {
@@ -563,13 +671,13 @@
 		}
 	}
 
-	return PackageTree{}, fmt.Errorf("Project %s at version %s could not be found", n, v)
+	return PackageTree{}, fmt.Errorf("Project %s at version %s could not be found", id.errString(), v)
 }
 
-func (sm *bmSourceManager) GetProjectInfo(n ProjectRoot, v Version) (Manifest, Lock, error) {
+func (sm *bmSourceManager) GetManifestAndLock(id ProjectIdentifier, 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 {
+		if id.ProjectRoot == ds.n && v.Matches(ds.v) {
+			if l, exists := sm.lm[string(id.ProjectRoot)+" "+v.String()]; exists {
 				return ds, l, nil
 			}
 			return ds, dummyLock{}, nil
@@ -577,7 +685,7 @@
 	}
 
 	// TODO(sdboyer) proper solver-type errors
-	return nil, nil, fmt.Errorf("Project %s at version %s could not be found", n, v)
+	return nil, nil, fmt.Errorf("Project %s at version %s could not be found", id.errString(), v)
 }
 
 // computeBimodalExternalMap takes a set of depspecs and computes an
@@ -601,10 +709,6 @@
 		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),
diff --git a/vendor/github.com/sdboyer/gps/solve_failures.go b/vendor/github.com/sdboyer/gps/solve_failures.go
new file mode 100644
index 0000000..9c144e8
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/solve_failures.go
@@ -0,0 +1,492 @@
+package gps
+
+import (
+	"bytes"
+	"fmt"
+	"sort"
+	"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
+)
+
+func a2vs(a atom) string {
+	if a.v == rootRev || a.v == nil {
+		return "(root)"
+	}
+
+	return fmt.Sprintf("%s@%s", a.id.errString(), a.v)
+}
+
+type traceError interface {
+	traceString() string
+}
+
+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()
+}
+
+// disjointConstraintFailure occurs when attempting to introduce an atom that
+// itself has an acceptable version, but one of its dependency constraints is
+// disjoint with one or more dependency constraints already active for that
+// identifier.
+type disjointConstraintFailure struct {
+	// goal is the dependency with the problematic constraint, forcing us to
+	// reject the atom that introduces it.
+	goal dependency
+	// failsib is the list of active dependencies that are disjoint with the
+	// goal dependency. This will be at least one, but may not be all of the
+	// active dependencies.
+	failsib []dependency
+	// nofailsib is the list of active dependencies that are NOT disjoint with
+	// the goal dependency. The total of nofailsib and failsib will always be
+	// the total number of active dependencies on target identifier.
+	nofailsib []dependency
+	// c is the current constraint on the target identifier. It is intersection
+	// of all the active dependencies' constraints.
+	c Constraint
+}
+
+func (e *disjointConstraintFailure) Error() string {
+	if len(e.failsib) == 1 {
+		str := "Could not introduce %s, as it has a dependency on %s with constraint %s, which has no overlap with existing constraint %s from %s"
+		return fmt.Sprintf(str, a2vs(e.goal.depender), e.goal.dep.Ident.errString(), e.goal.dep.Constraint.String(), e.failsib[0].dep.Constraint.String(), a2vs(e.failsib[0].depender))
+	}
+
+	var buf bytes.Buffer
+
+	var sibs []dependency
+	if len(e.failsib) > 1 {
+		sibs = e.failsib
+
+		str := "Could not introduce %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, a2vs(e.goal.depender), e.goal.dep.Ident.errString(), e.goal.dep.Constraint.String())
+	} else {
+		sibs = e.nofailsib
+
+		str := "Could not introduce %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, a2vs(e.goal.depender), e.goal.dep.Ident.errString(), e.goal.dep.Constraint.String())
+	}
+
+	for _, c := range sibs {
+		fmt.Fprintf(&buf, "\t%s from %s\n", c.dep.Constraint.String(), a2vs(c.depender))
+	}
+
+	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 (no overlap)\n",
+			f.dep.Constraint.String(),
+			a2vs(f.depender),
+		)
+	}
+	for _, f := range e.nofailsib {
+		fmt.Fprintf(
+			&buf,
+			"%s from %s (some overlap)\n",
+			f.dep.Constraint.String(),
+			a2vs(f.depender),
+		)
+	}
+
+	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 {
+	// The dependency with the problematic constraint that could not be
+	// introduced.
+	goal dependency
+	// The (currently selected) version of the target project that was not
+	// admissible by the goal dependency.
+	v Version
+}
+
+func (e *constraintNotAllowedFailure) Error() string {
+	return fmt.Sprintf(
+		"Could not introduce %s, as it has a dependency on %s with constraint %s, which does not allow the currently selected version of %s",
+		a2vs(e.goal.depender),
+		e.goal.dep.Ident.errString(),
+		e.goal.dep.Constraint,
+		e.v,
+	)
+}
+
+func (e *constraintNotAllowedFailure) traceString() string {
+	return fmt.Sprintf(
+		"%s depends on %s with %s, but that's already selected at %s",
+		a2vs(e.goal.depender),
+		e.goal.dep.Ident.ProjectRoot,
+		e.goal.dep.Constraint,
+		e.v,
+	)
+}
+
+// versionNotAllowedFailure describes a failure where an atom is rejected
+// because its version is not allowed by current constraints.
+//
+// (This is one of the more straightforward types of failures)
+type versionNotAllowedFailure struct {
+	// goal is the atom that was rejected by current constraints.
+	goal atom
+	// failparent is the list of active dependencies that caused the atom to be
+	// rejected. Note that this only includes dependencies that actually
+	// rejected the atom, which will be at least one, but may not be all the
+	// active dependencies on the atom's identifier.
+	failparent []dependency
+	// c is the current constraint on the atom's identifier. This is the intersection
+	// of all active dependencies' constraints.
+	c Constraint
+}
+
+func (e *versionNotAllowedFailure) Error() string {
+	if len(e.failparent) == 1 {
+		return fmt.Sprintf(
+			"Could not introduce %s, as it is not allowed by constraint %s from project %s.",
+			a2vs(e.goal),
+			e.failparent[0].dep.Constraint.String(),
+			e.failparent[0].depender.id.errString(),
+		)
+	}
+
+	var buf bytes.Buffer
+
+	fmt.Fprintf(&buf, "Could not introduce %s, as it is not allowed by constraints from the following projects:\n", a2vs(e.goal))
+
+	for _, f := range e.failparent {
+		fmt.Fprintf(&buf, "\t%s from %s\n", f.dep.Constraint.String(), a2vs(f.depender))
+	}
+
+	return buf.String()
+}
+
+func (e *versionNotAllowedFailure) traceString() string {
+	var buf bytes.Buffer
+
+	fmt.Fprintf(&buf, "%s not allowed by constraint %s:\n", a2vs(e.goal), e.c.String())
+	for _, f := range e.failparent {
+		fmt.Fprintf(&buf, "  %s from %s\n", f.dep.Constraint.String(), a2vs(f.depender))
+	}
+
+	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 {
+	// The ProjectRoot over which there is disagreement about where it should be
+	// sourced from
+	shared ProjectRoot
+	// The current value for the network source
+	current string
+	// The mismatched value for the network source
+	mismatch string
+	// The currently selected dependencies which have agreed upon/established
+	// the given network source
+	sel []dependency
+	// The atom with the constraint that has the new, incompatible network source
+	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, as it depends on %s from %s, but %s is already marked as coming from %s by %s"
+	return fmt.Sprintf(str, a2vs(e.prob), 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
+}
+
+// checkeeHasProblemPackagesFailure indicates that the goal atom was rejected
+// because one or more of the packages required by its deppers had errors.
+//
+// "errors" includes package nonexistence, which is indicated by a nil err in
+// the corresponding errDeppers failpkg map value.
+//
+// checkeeHasProblemPackagesFailure complements depHasProblemPackagesFailure;
+// one or the other could appear to describe the same fundamental issue,
+// depending on the order in which dependencies were visited.
+type checkeeHasProblemPackagesFailure struct {
+	// goal is the atom that was rejected due to problematic packages.
+	goal atom
+	// failpkg is a map of package names to the error describing the problem
+	// with them, plus a list of the selected atoms that require that package.
+	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 due to multiple problematic subpackages:\n",
+			a2vs(e.goal),
+		)
+	}
+
+	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, as its subpackage %s %s.",
+				a2vs(e.goal),
+				pkg,
+				cause,
+			)
+		} else {
+			fmt.Fprintf(&buf, "\tSubpackage %s %s.", pkg, cause)
+		}
+
+		if len(errdep.deppers) == 1 {
+			fmt.Fprintf(
+				&buf, " (Package is required by %s.)",
+				a2vs(errdep.deppers[0]),
+			)
+		} else {
+			fmt.Fprintf(&buf, " Package is required by:")
+			for _, pa := range errdep.deppers {
+				fmt.Fprintf(&buf, "\n%s\t%s", indent, a2vs(pa))
+			}
+		}
+	}
+
+	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.", a2vs(errdep.deppers[0]))
+		} 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()
+}
+
+// depHasProblemPackagesFailure indicates that the goal dependency was rejected
+// because there were problems with one or more of the packages the dependency
+// requires in the atom currently selected for that dependency. (This failure
+// can only occur if the target dependency is already selected.)
+//
+// "errors" includes package nonexistence, which is indicated by a nil err as
+// the corresponding prob map value.
+//
+// depHasProblemPackagesFailure complements checkeeHasProblemPackagesFailure;
+// one or the other could appear to describe the same fundamental issue,
+// depending on the order in which dependencies were visited.
+type depHasProblemPackagesFailure struct {
+	// goal is the dependency that was rejected due to the atom currently
+	// selected for the dependency's target id having errors (including, and
+	// probably most commonly,
+	// nonexistence) in one or more packages named by the dependency.
+	goal dependency
+	// v is the version of the currently selected atom targeted by the goal
+	// dependency.
+	v Version
+	// prob is a map of problem packages to their specific error. It does not
+	// include missing packages.
+	prob map[string]error
+}
+
+func (e *depHasProblemPackagesFailure) Error() string {
+	fcause := func(pkg string) string {
+		if err := e.prob[pkg]; err != nil {
+			return fmt.Sprintf("does not contain usable Go code (%T).", err)
+		}
+		return "is missing."
+	}
+
+	if len(e.prob) == 1 {
+		var pkg string
+		for pkg = range e.prob {
+		}
+
+		return fmt.Sprintf(
+			"Could not introduce %s, as it requires package %s from %s, but in version %s that package %s",
+			a2vs(e.goal.depender),
+			pkg,
+			e.goal.dep.Ident.errString(),
+			e.v,
+			fcause(pkg),
+		)
+	}
+
+	var buf bytes.Buffer
+	fmt.Fprintf(
+		&buf, "Could not introduce %s, as it requires problematic packages from %s (current version %s):",
+		a2vs(e.goal.depender),
+		e.goal.dep.Ident.errString(),
+		e.v,
+	)
+
+	pkgs := make([]string, len(e.prob))
+	k := 0
+	for pkg := range e.prob {
+		pkgs[k] = pkg
+		k++
+	}
+	sort.Strings(pkgs)
+	for _, pkg := range pkgs {
+		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 {
+		if err := e.prob[pkg]; err != nil {
+			return fmt.Sprintf("has parsing err (%T).", err)
+		}
+		return "is missing"
+	}
+
+	fmt.Fprintf(
+		&buf, "%s depping on %s at %s has problem subpkg(s):",
+		a2vs(e.goal.depender),
+		e.goal.dep.Ident.errString(),
+		e.v,
+	)
+
+	pkgs := make([]string, len(e.prob))
+	k := 0
+	for pkg := range e.prob {
+		pkgs[k] = pkg
+		k++
+	}
+	sort.Strings(pkgs)
+	for _, pkg := range pkgs {
+		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, as it requires %s at revision %s, but that revision does not exist",
+		a2vs(e.goal.depender),
+		e.goal.dep.Ident.errString(),
+		e.r,
+	)
+}
+
+func (e *nonexistentRevisionFailure) traceString() string {
+	return fmt.Sprintf(
+		"%s wants missing rev %s of %s",
+		a2vs(e.goal.depender),
+		e.r,
+		e.goal.dep.Ident.errString(),
+	)
+}
diff --git a/vendor/github.com/sdboyer/gps/solve_test.go b/vendor/github.com/sdboyer/gps/solve_test.go
index 95db023..94ed8ba 100644
--- a/vendor/github.com/sdboyer/gps/solve_test.go
+++ b/vendor/github.com/sdboyer/gps/solve_test.go
@@ -2,7 +2,6 @@
 
 import (
 	"flag"
-	"fmt"
 	"io/ioutil"
 	"log"
 	"math/rand"
@@ -31,7 +30,7 @@
 			&bridge{
 				sm:     sm,
 				s:      s,
-				vlists: make(map[ProjectRoot][]Version),
+				vlists: make(map[ProjectIdentifier][]Version),
 			},
 		}
 	}
@@ -88,7 +87,7 @@
 	params := SolveParameters{
 		RootDir:    string(fix.ds[0].n),
 		ImportRoot: ProjectRoot(fix.ds[0].n),
-		Manifest:   fix.ds[0],
+		Manifest:   fix.rootmanifest(),
 		Lock:       dummyLock{},
 		Downgrade:  fix.downgrade,
 		ChangeAll:  fix.changeall,
@@ -138,9 +137,8 @@
 	params := SolveParameters{
 		RootDir:    string(fix.ds[0].n),
 		ImportRoot: ProjectRoot(fix.ds[0].n),
-		Manifest:   fix.ds[0],
+		Manifest:   fix.rootmanifest(),
 		Lock:       dummyLock{},
-		Ignore:     fix.ignore,
 		Downgrade:  fix.downgrade,
 		ChangeAll:  fix.changeall,
 	}
@@ -154,62 +152,20 @@
 	return fixtureSolveSimpleChecks(fix, res, err, t)
 }
 
-func fixtureSolveSimpleChecks(fix specfix, res Solution, err error, t *testing.T) (Solution, error) {
+func fixtureSolveSimpleChecks(fix specfix, soln Solution, err error, t *testing.T) (Solution, error) {
+	fixfail := fix.failure()
 	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
+		if fixfail == nil {
+			t.Errorf("(fixture: %q) Solve failed unexpectedly:\n%s", fix.name(), err)
+		} else if !reflect.DeepEqual(fixfail, err) {
+			// TODO(sdboyer) reflect.DeepEqual works for now, but once we start
+			// modeling more complex cases, this should probably become more robust
+			t.Errorf("(fixture: %q) Failure mismatch:\n\t(GOT): %s\n\t(WNT): %s", fix.name(), err, fixfail)
 		}
-
-		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 if fixfail != nil {
+		t.Errorf("(fixture: %q) Solver succeeded, but expecting failure:\n%s", fix.name(), fixfail)
 	} else {
-		r := res.(solution)
+		r := soln.(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())
 		}
@@ -251,7 +207,7 @@
 		}
 	}
 
-	return res, err
+	return soln, err
 }
 
 // This tests that, when a root lock is underspecified (has only a version) we
@@ -293,7 +249,7 @@
 	params := SolveParameters{
 		RootDir:    string(fix.ds[0].n),
 		ImportRoot: ProjectRoot(fix.ds[0].n),
-		Manifest:   fix.ds[0],
+		Manifest:   fix.rootmanifest(),
 		Lock:       l2,
 	}
 
@@ -302,44 +258,6 @@
 	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"]
@@ -378,8 +296,21 @@
 	} 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)
+
+	params.Manifest = simpleRootManifest{
+		ovr: ProjectConstraints{
+			ProjectRoot("foo"): ProjectProperties{},
+		},
+	}
+	_, err = Prepare(params, sm)
+	if err == nil {
+		t.Errorf("Should have errored on override with empty ProjectProperties")
+	} else if !strings.Contains(err.Error(), "foo, but without any non-zero properties") {
+		t.Error("Prepare should have given error override with empty ProjectProperties, but gave:", err)
+	}
+	params.Manifest = nil
+
 	_, err = Prepare(params, sm)
 	if err != nil {
 		t.Error("Basic conditions satisfied, prepare should have completed successfully, err as:", err)
@@ -391,7 +322,7 @@
 		return &bridge{
 			sm:     sm,
 			s:      s,
-			vlists: make(map[ProjectRoot][]Version),
+			vlists: make(map[ProjectIdentifier][]Version),
 		}
 	}
 
@@ -414,27 +345,3 @@
 	// 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
index 121bc81..d82a40c 100644
--- a/vendor/github.com/sdboyer/gps/solver.go
+++ b/vendor/github.com/sdboyer/gps/solver.go
@@ -11,6 +11,8 @@
 	"github.com/armon/go-radix"
 )
 
+var rootRev = Revision("")
+
 // SolveParameters hold all arguments to a solver run.
 //
 // Only RootDir and ImportRoot are absolutely required. A nil Manifest is
@@ -40,11 +42,12 @@
 	// 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.
+	// The root manifest. This contains all the dependency constraints
+	// associated with normal Manifests, as well as the particular controls
+	// afforded only to the root project.
 	//
 	// May be nil, but for most cases, that would be unwise.
-	Manifest Manifest
+	Manifest RootManifest
 
 	// The root lock. Optional. Generally, this lock is the output of a previous
 	// solve run.
@@ -53,11 +56,6 @@
 	// 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.
@@ -88,8 +86,8 @@
 	TraceLogger *log.Logger
 }
 
-// solver is a CDCL-style SAT solver with satisfiability conditions hardcoded to
-// the needs of the Go package management problem space.
+// solver is a CDCL-style constraint 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
@@ -149,8 +147,13 @@
 
 	// A map of the ProjectRoot (local names) that are currently selected, and
 	// the network name to which they currently correspond.
+	// TODO(sdboyer) i think this is cruft and can be removed
 	names map[ProjectRoot]string
 
+	// A ProjectConstraints map containing the validated (guaranteed non-empty)
+	// overrides declared by the root manifest.
+	ovr ProjectConstraints
+
 	// A map of the names listed in the root's lock.
 	rlm map[ProjectIdentifier]LockedProject
 
@@ -162,9 +165,19 @@
 }
 
 // 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.
+// performs a constraint solving analysis to develop a complete Solution, or
+// else fail with an informative error.
+//
+// If a Solution is found, an implementing tool may persist it - typically into
+// what a "lock file" - and/or use it to write out a directory tree of
+// dependencies, suitable to be a vendor directory, via CreateVendorTree.
 type Solver interface {
+	// HashInputs produces a hash digest representing the unique inputs to this
+	// solver. It is guaranteed that, if the hash digest is equal to the digest
+	// from a previous Solution.InputHash(), that that Solution is valid for
+	// this Solver's inputs.
+	//
+	// In such a case, it may not be necessary to run Solve() at all.
 	HashInputs() ([]byte, error)
 	Solve() (Solution, error)
 }
@@ -175,9 +188,6 @@
 // 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")
 	}
@@ -192,23 +202,43 @@
 	}
 
 	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
-		}
+		params.Manifest = simpleRootManifest{}
 	}
 
 	s := &solver{
 		params: params,
-		ig:     ig,
+		ig:     params.Manifest.IgnorePackages(),
+		ovr:    params.Manifest.Overrides(),
 		tl:     params.TraceLogger,
 	}
 
+	// Ensure the ignore and overrides maps are at least initialized
+	if s.ig == nil {
+		s.ig = make(map[string]bool)
+	}
+	if s.ovr == nil {
+		s.ovr = make(ProjectConstraints)
+	}
+
+	// Validate no empties in the overrides map
+	var eovr []string
+	for pr, pp := range s.ovr {
+		if pp.Constraint == nil && pp.NetworkName == "" {
+			eovr = append(eovr, string(pr))
+		}
+	}
+
+	if eovr != nil {
+		// Maybe it's a little nitpicky to do this (we COULD proceed; empty
+		// overrides have no effect), but this errs on the side of letting the
+		// tool/user know there's bad input. Purely as a principle, that seems
+		// preferable to silently allowing progress with icky input.
+		if len(eovr) > 1 {
+			return nil, badOptsFailure(fmt.Sprintf("Overrides lacked any non-zero properties for multiple project roots: %s", strings.Join(eovr, " ")))
+		}
+		return nil, badOptsFailure(fmt.Sprintf("An override was declared for %s, but without any non-zero properties", eovr[0]))
+	}
+
 	// 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.)
@@ -260,36 +290,33 @@
 	// 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
+	var soln solution
+	if err == nil {
+		soln = solution{
+			att: s.attempts,
+		}
+
+		// An err here is impossible; it could only be caused by a parsing error
+		// of the root tree, but that necessarily succeeded back up
+		// selectRoot(), so we can ignore this err
+		soln.hd, _ = s.HashInputs()
+
+		// Convert ProjectAtoms into LockedProjects
+		soln.p = make([]LockedProject, len(all))
+		k := 0
+		for pa, pl := range all {
+			soln.p[k] = pa2lp(pa, pl)
+			k++
+		}
 	}
 
-	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
+	s.traceFinish(soln, err)
+	return soln, err
 }
 
 // solve is the top-level loop for the SAT solving process.
@@ -313,10 +340,11 @@
 		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.
+				s.traceStartBacktrack(bmi, err, false)
+				//s.traceBacktrack(bmi, false)
 				if s.backtrack() {
 					// backtracking succeeded, move to the next unselected id
 					continue
@@ -328,15 +356,15 @@
 				panic("canary - queue is empty, but flow indicates success")
 			}
 
-			s.selectAtomWithPackages(atomWithPackages{
+			awp := atomWithPackages{
 				a: atom{
 					id: queue.id,
 					v:  queue.current(),
 				},
 				pl: bmi.pl,
-			})
+			}
+			s.selectAtom(awp, false)
 			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
@@ -357,21 +385,21 @@
 				pl: bmi.pl,
 			}
 
-			s.logStart(bmi) // TODO(sdboyer) different special start logger for this path
-			err := s.checkPackage(nawp)
+			s.traceCheckPkgs(bmi)
+			err := s.check(nawp, true)
 			if err != nil {
 				// Err means a failure somewhere down the line; try backtracking.
+				s.traceStartBacktrack(bmi, err, true)
 				if s.backtrack() {
 					// backtracking succeeded, move to the next unselected id
 					continue
 				}
 				return nil, err
 			}
-			s.selectPackages(nawp)
+			s.selectAtom(nawp, true)
 			// 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()
 		}
 	}
 
@@ -406,10 +434,10 @@
 		// 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(""),
+		v: rootRev,
 	}
 
-	ptree, err := s.b.listPackages(pa.id, nil)
+	ptree, err := s.b.ListPackages(pa.id, nil)
 	if err != nil {
 		return err
 	}
@@ -432,7 +460,8 @@
 
 	// 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()...)
+	c, tc := s.rm.DependencyConstraints(), s.rm.TestDependencyConstraints()
+	mdeps := s.ovr.overrideAll(pcSliceToMap(c, tc).asSortedSlice())
 
 	// Err is not possible at this point, as it could only come from
 	// listPackages(), which if we're here already succeeded for root
@@ -451,6 +480,7 @@
 		heap.Push(s.unsel, bimodalIdentifier{id: dep.Ident, pl: dep.pl, fromRoot: true})
 	}
 
+	s.traceSelectRoot(ptree, deps)
 	return nil
 }
 
@@ -463,12 +493,12 @@
 
 	// Work through the source manager to get project info and static analysis
 	// information.
-	m, _, err := s.b.getProjectInfo(a.a)
+	m, _, err := s.b.GetManifestAndLock(a.a.id, a.a.v)
 	if err != nil {
 		return nil, err
 	}
 
-	ptree, err := s.b.listPackages(a.a.id, a.a.v)
+	ptree, err := s.b.ListPackages(a.a.id, a.a.v)
 	if err != nil {
 		return nil, err
 	}
@@ -505,8 +535,7 @@
 		k++
 	}
 
-	deps := m.DependencyConstraints()
-	// TODO(sdboyer) add overrides here...if we impl the concept (which we should)
+	deps := s.ovr.overrideAll(m.DependencyConstraints())
 
 	return s.intersectConstraintsWithImports(deps, reach)
 }
@@ -515,7 +544,7 @@
 // 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) {
+func (s *solver) intersectConstraintsWithImports(deps []workingConstraint, 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()
@@ -543,8 +572,8 @@
 			// 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
+			// The latter would incorrectly be conflated 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.
@@ -552,13 +581,13 @@
 				// 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)
+				dep := idep.(workingConstraint)
 				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,
+						workingConstraint: dep,
 						pl:                []string{rp},
 					}
 				}
@@ -567,27 +596,27 @@
 		}
 
 		// No match. Let the SourceManager try to figure out the root
-		root, err := s.b.deduceRemoteRepo(rp)
+		root, err := s.b.DeduceProjectRoot(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{
+		// Make a new completeDep with an open constraint, respecting overrides
+		pd := s.ovr.override(ProjectConstraint{
 			Ident: ProjectIdentifier{
-				ProjectRoot: ProjectRoot(root.Base),
-				NetworkName: root.Base,
+				ProjectRoot: root,
+				NetworkName: string(root),
 			},
 			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)
+		xt.Insert(string(root), pd)
 		// And also put the complete dep into the dmap
-		dmap[ProjectRoot(root.Base)] = completeDep{
-			ProjectConstraint: pd,
+		dmap[root] = completeDep{
+			workingConstraint: pd,
 			pl:                []string{rp},
 		}
 	}
@@ -610,7 +639,7 @@
 		return newVersionQueue(id, nil, nil, s.b)
 	}
 
-	exists, err := s.b.repoExists(id)
+	exists, err := s.b.SourceExists(id)
 	if err != nil {
 		return nil, err
 	}
@@ -623,7 +652,7 @@
 			// 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)
+			return nil, fmt.Errorf("Project '%s' could not be located.", id)
 		}
 	}
 
@@ -650,7 +679,7 @@
 				continue
 			}
 
-			_, l, err := s.b.getProjectInfo(dep.depender)
+			_, l, err := s.b.GetManifestAndLock(dep.depender.id, dep.depender.v)
 			if err != nil || l == nil {
 				// err being non-nil really shouldn't be possible, but the lock
 				// being nil is quite likely
@@ -715,6 +744,7 @@
 	}
 
 	// Having assembled the queue, search it for a valid version.
+	s.traceCheckQueue(q, bmi, false, 1)
 	return q, s.findValidVersion(q, bmi.pl)
 }
 
@@ -735,13 +765,14 @@
 
 	for {
 		cur := q.current()
-		err := s.checkProject(atomWithPackages{
+		s.traceInfo("try %s@%s", q.id.errString(), cur)
+		err := s.check(atomWithPackages{
 			a: atom{
 				id: q.id,
 				v:  cur,
 			},
 			pl: pl,
-		})
+		}, false)
 		if err == nil {
 			// we have a good version, can return safely
 			return nil
@@ -785,7 +816,7 @@
 		// 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 {
+		if exist, _ := s.b.SourceExists(id); exist {
 			return nil, nil
 		}
 
@@ -833,13 +864,10 @@
 		}
 
 		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
 }
 
@@ -865,46 +893,44 @@
 
 			// Pop selections off until we get to a project.
 			var proj bool
+			var awp atomWithPackages
 			for !proj {
-				_, proj = s.unselectLast()
+				awp, proj = s.unselectLast()
+				s.traceBacktrack(awp.bmi(), !proj)
 			}
 		}
 
 		// 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()
+		// Walk back to the next project
+		awp, proj := s.unselectLast()
+		if !proj {
+			panic("canary - *should* be impossible to have a pkg-only selection here")
 		}
 
 		if !q.id.eq(awp.a.id) {
-			panic("canary - version queue stack and selected project stack are out of alignment")
+			panic("canary - version queue stack and selected project stack are misaligned")
 		}
 
 		// 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
+			s.traceCheckQueue(q, awp.bmi(), true, 0)
 			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,
-				})
+
+				// reusing the old awp is fine
+				awp.a.v = q.current()
+				s.selectAtom(awp, false)
 				break
 			}
 		}
 
-		s.logSolve("no more versions of %s, backtracking", q.id.errString())
+		s.traceBacktrack(awp.bmi(), false)
+		//s.traceInfo("no more versions of %s, backtracking", q.id.errString())
 
 		// No solution found; continue backtracking after popping the queue
 		// we just inspected off the list
@@ -975,8 +1001,8 @@
 	// 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)
+	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
@@ -1012,79 +1038,18 @@
 	}
 }
 
-// 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.
+// selectAtom pulls an atom into the selection stack, alongside some of
+// its contained packages. New resultant dependency requirements are added to
+// the unselected priority queue.
 //
-// It also takes an atomWithPackages because we need that same information in
-// order to enqueue the selection.
-func (s *solver) selectPackages(a atomWithPackages) {
+// Behavior is slightly diffferent if pkgonly is true.
+func (s *solver) selectAtom(a atomWithPackages, pkgonly bool) {
 	s.unsel.remove(bimodalIdentifier{
 		id: a.a.id,
 		pl: a.pl,
 	})
 
-	s.sel.pushSelection(a, false)
+	s.sel.pushSelection(a, pkgonly)
 
 	deps, err := s.getImportsAndConstraintsOf(a)
 	if err != nil {
@@ -1095,7 +1060,7 @@
 
 	// 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)
+	_, l, _ := s.b.GetManifestAndLock(a.a.id, a.a.v)
 	var lmap map[ProjectIdentifier]Version
 	if l != nil {
 		lmap = make(map[ProjectIdentifier]Version)
@@ -1132,6 +1097,8 @@
 			s.names[dep.Ident.ProjectRoot] = dep.Ident.netName()
 		}
 	}
+
+	s.traceSelect(a, pkgonly)
 }
 
 func (s *solver) unselectLast() (atomWithPackages, bool) {
@@ -1158,67 +1125,6 @@
 	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{
diff --git a/vendor/github.com/sdboyer/gps/source.go b/vendor/github.com/sdboyer/gps/source.go
new file mode 100644
index 0000000..feaba15
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/source.go
@@ -0,0 +1,328 @@
+package gps
+
+import "fmt"
+
+type source interface {
+	checkExistence(sourceExistence) bool
+	exportVersionTo(Version, string) error
+	getManifestAndLock(ProjectRoot, Version) (Manifest, Lock, error)
+	listPackages(ProjectRoot, Version) (PackageTree, error)
+	listVersions() ([]Version, error)
+	revisionPresentIn(Revision) (bool, error)
+}
+
+type sourceMetaCache struct {
+	//Version  string                   // TODO(sdboyer) use this
+	infos  map[Revision]projectInfo
+	ptrees map[Revision]PackageTree
+	vMap   map[UnpairedVersion]Revision
+	rMap   map[Revision][]UnpairedVersion
+	// TODO(sdboyer) mutexes. actually probably just one, b/c complexity
+}
+
+// projectInfo holds manifest and lock
+type projectInfo struct {
+	Manifest
+	Lock
+}
+
+type existence struct {
+	// The existence levels for which a search/check has been performed
+	s sourceExistence
+
+	// The existence levels verified to be present through searching
+	f sourceExistence
+}
+
+func newMetaCache() *sourceMetaCache {
+	return &sourceMetaCache{
+		infos:  make(map[Revision]projectInfo),
+		ptrees: make(map[Revision]PackageTree),
+		vMap:   make(map[UnpairedVersion]Revision),
+		rMap:   make(map[Revision][]UnpairedVersion),
+	}
+}
+
+type baseVCSSource struct {
+	// 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
+
+	// ProjectAnalyzer used to fulfill getManifestAndLock
+	an ProjectAnalyzer
+
+	// Whether the cache has the latest info on versions
+	cvsync bool
+
+	// The project metadata cache. This is (or is intended to be) persisted to
+	// disk, for reuse across solver runs.
+	dc *sourceMetaCache
+
+	// lvfunc allows the other vcs source types that embed this type to inject
+	// their listVersions func into the baseSource, for use as needed.
+	lvfunc func() (vlist []Version, err error)
+}
+
+func (bs *baseVCSSource) getManifestAndLock(r ProjectRoot, v Version) (Manifest, Lock, error) {
+	if err := bs.ensureCacheExistence(); err != nil {
+		return nil, nil, err
+	}
+
+	rev, err := bs.toRevOrErr(v)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	// Return the info from the cache, if we already have it
+	if pi, exists := bs.dc.infos[rev]; exists {
+		return pi.Manifest, pi.Lock, nil
+	}
+
+	bs.crepo.mut.Lock()
+	if !bs.crepo.synced {
+		err = bs.crepo.r.Update()
+		if err != nil {
+			return nil, nil, fmt.Errorf("could not fetch latest updates into repository")
+		}
+		bs.crepo.synced = true
+	}
+
+	// Always prefer a rev, if it's available
+	if pv, ok := v.(PairedVersion); ok {
+		err = bs.crepo.r.UpdateVersion(pv.Underlying().String())
+	} else {
+		err = bs.crepo.r.UpdateVersion(v.String())
+	}
+	bs.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", bs.crepo.r.LocalPath(), v.String(), err))
+	}
+
+	bs.crepo.mut.RLock()
+	m, l, err := bs.an.DeriveManifestAndLock(bs.crepo.r.LocalPath(), r)
+	// TODO(sdboyer) cache results
+	bs.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,
+		}
+
+		bs.dc.infos[rev] = pi
+
+		return pi.Manifest, pi.Lock, nil
+	}
+
+	return nil, nil, err
+}
+
+// toRevision turns a Version into a Revision, if doing so is possible based on
+// the information contained in the version itself, or in the cache maps.
+func (dc *sourceMetaCache) toRevision(v Version) Revision {
+	switch t := v.(type) {
+	case Revision:
+		return t
+	case PairedVersion:
+		return t.Underlying()
+	case UnpairedVersion:
+		// This will return the empty rev (empty string) if we don't have a
+		// record of it. It's up to the caller to decide, for example, if
+		// it's appropriate to update the cache.
+		return dc.vMap[t]
+	default:
+		panic(fmt.Sprintf("Unknown version type %T", v))
+	}
+}
+
+// toUnpaired turns a Version into an UnpairedVersion, if doing so is possible
+// based on the information contained in the version itself, or in the cache
+// maps.
+//
+// If the input is a revision and multiple UnpairedVersions are associated with
+// it, whatever happens to be the first is returned.
+func (dc *sourceMetaCache) toUnpaired(v Version) UnpairedVersion {
+	switch t := v.(type) {
+	case UnpairedVersion:
+		return t
+	case PairedVersion:
+		return t.Unpair()
+	case Revision:
+		if upv, has := dc.rMap[t]; has && len(upv) > 0 {
+			return upv[0]
+		}
+		return nil
+	default:
+		panic(fmt.Sprintf("unknown version type %T", v))
+	}
+}
+
+func (bs *baseVCSSource) 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 := bs.dc.infos[r]; has {
+		return true, nil
+	} else if _, has := bs.dc.rMap[r]; has {
+		return true, nil
+	}
+
+	err := bs.ensureCacheExistence()
+	if err != nil {
+		return false, err
+	}
+
+	bs.crepo.mut.RLock()
+	defer bs.crepo.mut.RUnlock()
+	return bs.crepo.r.IsReference(string(r)), nil
+}
+
+func (bs *baseVCSSource) 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 !bs.checkExistence(existsInCache) {
+		if bs.checkExistence(existsUpstream) {
+			bs.crepo.mut.Lock()
+			err := bs.crepo.r.Get()
+			bs.crepo.mut.Unlock()
+
+			if err != nil {
+				return fmt.Errorf("failed to create repository cache for %s", bs.crepo.r.Remote())
+			}
+			bs.crepo.synced = true
+			bs.ex.s |= existsInCache
+			bs.ex.f |= existsInCache
+		} else {
+			return fmt.Errorf("project %s does not exist upstream", bs.crepo.r.Remote())
+		}
+	}
+
+	return nil
+}
+
+// checkExistence provides a direct method for querying existence levels of the
+// source. 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. This makes it unsafe to call from a segment where
+// the cache repo mutex is already write-locked, as deadlock will occur.
+func (bs *baseVCSSource) checkExistence(ex sourceExistence) bool {
+	if bs.ex.s&ex != ex {
+		if ex&existsInVendorRoot != 0 && bs.ex.s&existsInVendorRoot == 0 {
+			panic("should now be implemented in bridge")
+		}
+		if ex&existsInCache != 0 && bs.ex.s&existsInCache == 0 {
+			bs.crepo.mut.RLock()
+			bs.ex.s |= existsInCache
+			if bs.crepo.r.CheckLocal() {
+				bs.ex.f |= existsInCache
+			}
+			bs.crepo.mut.RUnlock()
+		}
+		if ex&existsUpstream != 0 && bs.ex.s&existsUpstream == 0 {
+			bs.crepo.mut.RLock()
+			bs.ex.s |= existsUpstream
+			if bs.crepo.r.Ping() {
+				bs.ex.f |= existsUpstream
+			}
+			bs.crepo.mut.RUnlock()
+		}
+	}
+
+	return ex&bs.ex.f == ex
+}
+
+func (bs *baseVCSSource) listPackages(pr ProjectRoot, v Version) (ptree PackageTree, err error) {
+	if err = bs.ensureCacheExistence(); err != nil {
+		return
+	}
+
+	var r Revision
+	if r, err = bs.toRevOrErr(v); err != nil {
+		return
+	}
+
+	// Return the ptree from the cache, if we already have it
+	var exists bool
+	if ptree, exists = bs.dc.ptrees[r]; exists {
+		return
+	}
+
+	// Not in the cache; check out the version and do the analysis
+	bs.crepo.mut.Lock()
+	// Check out the desired version for analysis
+	if r != "" {
+		// Always prefer a rev, if it's available
+		err = bs.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 !bs.crepo.synced {
+			err = bs.crepo.r.Update()
+			if err != nil {
+				return PackageTree{}, fmt.Errorf("could not fetch latest updates into repository: %s", err)
+			}
+			bs.crepo.synced = true
+		}
+		err = bs.crepo.r.UpdateVersion(v.String())
+	}
+
+	ptree, err = listPackages(bs.crepo.r.LocalPath(), string(pr))
+	bs.crepo.mut.Unlock()
+
+	// TODO(sdboyer) cache errs?
+	if err != nil {
+		bs.dc.ptrees[r] = ptree
+	}
+
+	return
+}
+
+// toRevOrErr makes all efforts to convert a Version into a rev, including
+// updating the cache repo (if needed). It does not guarantee that the returned
+// Revision actually exists in the repository (as one of the cheaper methods may
+// have had bad data).
+func (bs *baseVCSSource) toRevOrErr(v Version) (r Revision, err error) {
+	r = bs.dc.toRevision(v)
+	if r == "" {
+		// Rev can be empty if:
+		//  - The cache is unsynced
+		//  - A version was passed that used to exist, but no longer does
+		//  - A garbage version was passed. (Functionally indistinguishable from
+		//  the previous)
+		if !bs.cvsync {
+			// call the lvfunc to sync the meta cache
+			_, err = bs.lvfunc()
+			if err != nil {
+				return
+			}
+		}
+
+		r = bs.dc.toRevision(v)
+		// If we still don't have a rev, then the version's no good
+		if r == "" {
+			err = fmt.Errorf("version %s does not exist in source %s", v, bs.crepo.r.Remote())
+		}
+	}
+
+	return
+}
+
+func (bs *baseVCSSource) exportVersionTo(v Version, to string) error {
+	return bs.crepo.exportVersionTo(v, to)
+}
diff --git a/vendor/github.com/sdboyer/gps/source_manager.go b/vendor/github.com/sdboyer/gps/source_manager.go
index 86627a1..11ec567 100644
--- a/vendor/github.com/sdboyer/gps/source_manager.go
+++ b/vendor/github.com/sdboyer/gps/source_manager.go
@@ -1,57 +1,76 @@
 package gps
 
 import (
-	"encoding/json"
 	"fmt"
-	"go/build"
 	"os"
-	"path"
+	"path/filepath"
+	"strings"
+	"sync"
+	"sync/atomic"
 
-	"github.com/Masterminds/vcs"
+	"github.com/Masterminds/semver"
 )
 
+// Used to compute a friendly filepath from a URL-shaped input
+//
+// TODO(sdboyer) this is awful. Right?
+var sanitizer = strings.NewReplacer(":", "-", "/", "-", "+", "-")
+
 // 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.
+// gps's built-in SourceManager, SourceMgr, 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
+	// SourceExists checks if a repository exists, either upstream or in the
 	// SourceManager's central repository cache.
-	RepoExists(ProjectRoot) (bool, error)
+	SourceExists(ProjectIdentifier) (bool, error)
 
 	// ListVersions retrieves a list of the available versions for a given
 	// repository name.
-	ListVersions(ProjectRoot) ([]Version, error)
+	ListVersions(ProjectIdentifier) ([]Version, error)
 
 	// RevisionPresentIn indicates whether the provided Version is present in
 	// the given repository.
-	RevisionPresentIn(ProjectRoot, Revision) (bool, error)
+	RevisionPresentIn(ProjectIdentifier, 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)
+	// ListPackages parses the tree of the Go packages at or below root of the
+	// provided ProjectIdentifier, at the provided version.
+	ListPackages(ProjectIdentifier, 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
+	// GetManifestAndLock returns manifest and lock information for the provided
+	// root import path.
+	//
+	// gps currently requires that projects be rooted at their repository root,
+	// necessitating that the ProjectIdentifier's ProjectRoot must also be a
 	// repository root.
-	GetProjectInfo(ProjectRoot, Version) (Manifest, Lock, error)
+	GetManifestAndLock(ProjectIdentifier, 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
+	ExportProject(ProjectIdentifier, Version, string) error
 
-	// Release lets go of any locks held by the SourceManager.
-	Release()
+	// AnalyzerInfo reports the name and version of the logic used to service
+	// GetManifestAndLock().
+	AnalyzerInfo() (name string, version *semver.Version)
+
+	// DeduceRootProject takes an import path and deduces the corresponding
+	// project/source root.
+	DeduceProjectRoot(ip string) (ProjectRoot, error)
 }
 
-// A ProjectAnalyzer is responsible for analyzing a path for Manifest and Lock
-// information. Tools relying on gps must implement one.
+// A ProjectAnalyzer is responsible for analyzing a given path for Manifest and
+// Lock information. Tools relying on gps must implement one.
 type ProjectAnalyzer interface {
-	GetInfo(string, ProjectRoot) (Manifest, Lock, error)
+	// Perform analysis of the filesystem tree rooted at path, with the
+	// root import path importRoot, to determine the project's constraints, as
+	// indicated by a Manifest and Lock.
+	DeriveManifestAndLock(path string, importRoot ProjectRoot) (Manifest, Lock, error)
+
+	// Report the name and version of this ProjectAnalyzer.
+	Info() (name string, version *semver.Version)
 }
 
 // SourceMgr is the default SourceManager for gps.
@@ -60,22 +79,15 @@
 // tools; control via dependency injection is intended to be sufficient.
 type SourceMgr struct {
 	cachedir string
-	pms      map[ProjectRoot]*pmState
+	srcs     map[string]source
+	srcmut   sync.RWMutex
 	an       ProjectAnalyzer
-	ctx      build.Context
-	//pme               map[ProjectRoot]error
+	dxt      deducerTrie
+	rootxt   prTrie
 }
 
 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
@@ -98,12 +110,12 @@
 		return nil, fmt.Errorf("a ProjectAnalyzer must be provided to the SourceManager")
 	}
 
-	err := os.MkdirAll(cachedir, 0777)
+	err := os.MkdirAll(filepath.Join(cachedir, "sources"), 0777)
 	if err != nil {
 		return nil, err
 	}
 
-	glpath := path.Join(cachedir, "sm.lock")
+	glpath := filepath.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)
@@ -114,47 +126,50 @@
 		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,
+		srcs:     make(map[string]source),
 		an:       an,
+		dxt:      pathDeducerTrie(),
+		rootxt:   newProjectRootTrie(),
 	}, nil
 }
 
 // Release lets go of any locks held by the SourceManager.
 func (sm *SourceMgr) Release() {
-	os.Remove(path.Join(sm.cachedir, "sm.lock"))
+	os.Remove(filepath.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.
+// AnalyzerInfo reports the name and version of the injected ProjectAnalyzer.
+func (sm *SourceMgr) AnalyzerInfo() (name string, version *semver.Version) {
+	return sm.an.Info()
+}
+
+// GetManifestAndLock returns manifest and lock information for the provided
+// import path. gps currently requires that projects be rooted at their
+// repository root, necessitating that the ProjectIdentifier's 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)
+// The work of producing the manifest and lock is delegated to the injected
+// ProjectAnalyzer's DeriveManifestAndLock() method.
+func (sm *SourceMgr) GetManifestAndLock(id ProjectIdentifier, v Version) (Manifest, Lock, error) {
+	src, err := sm.getSourceFor(id)
 	if err != nil {
 		return nil, nil, err
 	}
 
-	return pmc.pm.GetInfoAt(v)
+	return src.getManifestAndLock(id.ProjectRoot, 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)
+// ListPackages parses the tree of the Go packages at and below the ProjectRoot
+// of the given ProjectIdentifier, at the given version.
+func (sm *SourceMgr) ListPackages(id ProjectIdentifier, v Version) (PackageTree, error) {
+	src, err := sm.getSourceFor(id)
 	if err != nil {
 		return PackageTree{}, err
 	}
 
-	return pmc.pm.ListPackages(v)
+	return src.listPackages(id.ProjectRoot, v)
 }
 
 // ListVersions retrieves a list of the available versions for a given
@@ -165,133 +180,219 @@
 // 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)
+// This list is always retrieved from upstream on the first call. Subsequent
+// calls will return a cached version of the first call's results. if upstream
+// is not accessible (network outage, access issues, or the resource actually
+// went away), an error will be returned.
+func (sm *SourceMgr) ListVersions(id ProjectIdentifier) ([]Version, error) {
+	src, err := sm.getSourceFor(id)
 	if err != nil {
 		// TODO(sdboyer) More-er proper-er errors
 		return nil, err
 	}
 
-	return pmc.pm.ListVersions()
+	return src.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)
+func (sm *SourceMgr) RevisionPresentIn(id ProjectIdentifier, r Revision) (bool, error) {
+	src, err := sm.getSourceFor(id)
 	if err != nil {
 		// TODO(sdboyer) More-er proper-er errors
 		return false, err
 	}
 
-	return pmc.pm.RevisionPresentIn(r)
+	return src.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)
+// SourceExists checks if a repository exists, either upstream or in the cache,
+// for the provided ProjectIdentifier.
+func (sm *SourceMgr) SourceExists(id ProjectIdentifier) (bool, error) {
+	src, err := sm.getSourceFor(id)
 	if err != nil {
 		return false, err
 	}
 
-	return pms.pm.CheckExistence(existsInCache) || pms.pm.CheckExistence(existsUpstream), nil
+	return src.checkExistence(existsInCache) || src.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)
+// ExportProject writes out the tree of the provided ProjectIdentifier's
+// ProjectRoot, at the provided version, to the provided directory.
+func (sm *SourceMgr) ExportProject(id ProjectIdentifier, v Version, to string) error {
+	src, err := sm.getSourceFor(id)
 	if err != nil {
 		return err
 	}
 
-	return pms.pm.ExportVersionTo(v, to)
+	return src.exportVersionTo(v, to)
 }
 
-// getProjectManager gets the project manager for the given ProjectRoot.
+// DeduceRootProject takes an import path and deduces the corresponding
+// project/source root.
 //
-// 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
+// Note that some import paths may require network activity to correctly
+// determine the root of the path, such as, but not limited to, vanity import
+// paths. (A special exception is written for gopkg.in to minimize network
+// activity, as its behavior is well-structured)
+func (sm *SourceMgr) DeduceProjectRoot(ip string) (ProjectRoot, error) {
+	if prefix, root, has := sm.rootxt.LongestPrefix(ip); has {
+		// The non-matching tail of the import path could still be malformed.
+		// Validate just that part, if it exists
+		if prefix != ip {
+			if !pathvld.MatchString(strings.TrimPrefix(ip, prefix)) {
+				return "", fmt.Errorf("%q is not a valid import path", ip)
+			}
+			// There was one, and it validated fine - add it so we don't have to
+			// revalidate it later
+			sm.rootxt.Insert(ip, root)
 		}
+		return root, nil
 	}
 
-	// Ensure cache dir exists
-	metadir := path.Join(sm.cachedir, "metadata", string(n))
-	err = os.MkdirAll(metadir, 0777)
+	rootf, _, err := sm.deducePathAndProcess(ip)
 	if err != nil {
-		// TODO(sdboyer) be better
+		return "", err
+	}
+
+	r, err := rootf()
+	return ProjectRoot(r), err
+}
+
+func (sm *SourceMgr) getSourceFor(id ProjectIdentifier) (source, error) {
+	nn := id.netName()
+
+	sm.srcmut.RLock()
+	src, has := sm.srcs[nn]
+	sm.srcmut.RUnlock()
+	if has {
+		return src, nil
+	}
+
+	_, srcf, err := sm.deducePathAndProcess(nn)
+	if err != nil {
 		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)
-		}
+	// we don't care about the ident here, and the future produced by
+	// deducePathAndProcess will dedupe with what's in the sm.srcs map
+	src, _, err = srcf()
+	return src, 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),
-		}
+func (sm *SourceMgr) deducePathAndProcess(path string) (stringFuture, sourceFuture, error) {
+	df, err := sm.deduceFromPath(path)
+	if err != nil {
+		return nil, nil, err
 	}
 
-	pm := &projectManager{
-		n:   n,
-		ctx: sm.ctx,
-		an:  sm.an,
-		dc:  dc,
-		crepo: &repo{
-			rpath: repodir,
-			r:     r,
-		},
+	var rstart, sstart int32
+	rc, sc := make(chan struct{}, 1), make(chan struct{}, 1)
+
+	// Rewrap in a deferred future, so the caller can decide when to trigger it
+	rootf := func() (pr string, err error) {
+		// CAS because a bad interleaving here would panic on double-closing rc
+		if atomic.CompareAndSwapInt32(&rstart, 0, 1) {
+			go func() {
+				defer close(rc)
+				pr, err = df.root()
+				if err != nil {
+					// Don't cache errs. This doesn't really hurt the solver, and is
+					// beneficial for other use cases because it means we don't have to
+					// expose any kind of controls for clearing caches.
+					return
+				}
+
+				tpr := ProjectRoot(pr)
+				sm.rootxt.Insert(pr, tpr)
+				// It's not harmful if the netname was a URL rather than an
+				// import path
+				if pr != path {
+					// Insert the result into the rootxt twice - once at the
+					// root itself, so as to catch siblings/relatives, and again
+					// at the exact provided import path (assuming they were
+					// different), so that on subsequent calls, exact matches
+					// can skip the regex above.
+					sm.rootxt.Insert(path, tpr)
+				}
+			}()
+		}
+
+		<-rc
+		return pr, err
 	}
 
-	pms.pm = pm
-	sm.pms[n] = pms
-	return pms, nil
+	// Now, handle the source
+	fut := df.psf(sm.cachedir, sm.an)
+
+	// Rewrap in a deferred future, so the caller can decide when to trigger it
+	srcf := func() (src source, ident string, err error) {
+		// CAS because a bad interleaving here would panic on double-closing sc
+		if atomic.CompareAndSwapInt32(&sstart, 0, 1) {
+			go func() {
+				defer close(sc)
+				src, ident, err = fut()
+				if err != nil {
+					// Don't cache errs. This doesn't really hurt the solver, and is
+					// beneficial for other use cases because it means we don't have
+					// to expose any kind of controls for clearing caches.
+					return
+				}
+
+				sm.srcmut.Lock()
+				defer sm.srcmut.Unlock()
+
+				// Check to make sure a source hasn't shown up in the meantime, or that
+				// there wasn't already one at the ident.
+				var hasi, hasp bool
+				var srci, srcp source
+				if ident != "" {
+					srci, hasi = sm.srcs[ident]
+				}
+				srcp, hasp = sm.srcs[path]
+
+				// if neither the ident nor the input path have an entry for this src,
+				// we're in the simple case - write them both in and we're done
+				if !hasi && !hasp {
+					sm.srcs[path] = src
+					if ident != path && ident != "" {
+						sm.srcs[ident] = src
+					}
+					return
+				}
+
+				// Now, the xors.
+				//
+				// If already present for ident but not for path, copy ident's src
+				// to path. This covers cases like a gopkg.in path referring back
+				// onto a github repository, where something else already explicitly
+				// looked up that same gh repo.
+				if hasi && !hasp {
+					sm.srcs[path] = srci
+					src = srci
+				}
+				// If already present for path but not for ident, do NOT copy path's
+				// src to ident, but use the returned one instead. Really, this case
+				// shouldn't occur at all...? But the crucial thing is that the
+				// path-based one has already discovered what actual ident of source
+				// they want to use, and changing that arbitrarily would have
+				// undefined effects.
+				if hasp && !hasi && ident != "" {
+					sm.srcs[ident] = src
+				}
+
+				// If both are present, then assume we're good, and use the path one
+				if hasp && hasi {
+					// TODO(sdboyer) compare these (somehow? reflect? pointer?) and if they're not the
+					// same object, panic
+					src = srcp
+				}
+			}()
+		}
+
+		<-sc
+		return
+	}
+
+	return rootf, srcf, nil
 }
diff --git a/vendor/github.com/sdboyer/gps/source_test.go b/vendor/github.com/sdboyer/gps/source_test.go
new file mode 100644
index 0000000..907d9c3
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/source_test.go
@@ -0,0 +1,319 @@
+package gps
+
+import (
+	"io/ioutil"
+	"net/url"
+	"reflect"
+	"sort"
+	"testing"
+)
+
+func TestGitSourceInteractions(t *testing.T) {
+	// This test is slowish, skip it on -short
+	if testing.Short() {
+		t.Skip("Skipping git source version fetching test in short mode")
+	}
+
+	cpath, err := ioutil.TempDir("", "smcache")
+	if err != nil {
+		t.Errorf("Failed to create temp dir: %s", err)
+	}
+	rf := func() {
+		err := removeAll(cpath)
+		if err != nil {
+			t.Errorf("removeAll failed: %s", err)
+		}
+	}
+
+	n := "github.com/Masterminds/VCSTestRepo"
+	un := "https://" + n
+	u, err := url.Parse(un)
+	if err != nil {
+		t.Errorf("URL was bad, lolwut? errtext: %s", err)
+		rf()
+		t.FailNow()
+	}
+	mb := maybeGitSource{
+		url: u,
+	}
+
+	isrc, ident, err := mb.try(cpath, naiveAnalyzer{})
+	if err != nil {
+		t.Errorf("Unexpected error while setting up gitSource for test repo: %s", err)
+		rf()
+		t.FailNow()
+	}
+	src, ok := isrc.(*gitSource)
+	if !ok {
+		t.Errorf("Expected a gitSource, got a %T", isrc)
+		rf()
+		t.FailNow()
+	}
+	if ident != un {
+		t.Errorf("Expected %s as source ident, got %s", un, ident)
+	}
+
+	vlist, err := src.listVersions()
+	if err != nil {
+		t.Errorf("Unexpected error getting version pairs from git repo: %s", err)
+		rf()
+		t.FailNow()
+	}
+
+	if src.ex.s&existsUpstream != existsUpstream {
+		t.Errorf("gitSource.listVersions() should have set the upstream existence bit for search")
+	}
+	if src.ex.f&existsUpstream != existsUpstream {
+		t.Errorf("gitSource.listVersions() should have set the upstream existence bit for found")
+	}
+	if src.ex.s&existsInCache != 0 {
+		t.Errorf("gitSource.listVersions() should not have set the cache existence bit for search")
+	}
+	if src.ex.f&existsInCache != 0 {
+		t.Errorf("gitSource.listVersions() should not have set the cache existence bit for found")
+	}
+
+	// check that an expected rev is present
+	is, err := src.revisionPresentIn(Revision("30605f6ac35fcb075ad0bfa9296f90a7d891523e"))
+	if err != nil {
+		t.Errorf("Unexpected error while checking revision presence: %s", err)
+	} else if !is {
+		t.Errorf("Revision that should exist was not present")
+	}
+
+	if len(vlist) != 3 {
+		t.Errorf("git test repo should've produced three versions, got %v: vlist was %s", len(vlist), vlist)
+	} else {
+		sort.Sort(upgradeVersionSorter(vlist))
+		evl := []Version{
+			NewVersion("1.0.0").Is(Revision("30605f6ac35fcb075ad0bfa9296f90a7d891523e")),
+			NewBranch("master").Is(Revision("30605f6ac35fcb075ad0bfa9296f90a7d891523e")),
+			NewBranch("test").Is(Revision("30605f6ac35fcb075ad0bfa9296f90a7d891523e")),
+		}
+		if !reflect.DeepEqual(vlist, evl) {
+			t.Errorf("Version list was not what we expected:\n\t(GOT): %s\n\t(WNT): %s", vlist, evl)
+		}
+	}
+
+	// recheck that rev is present, this time interacting with cache differently
+	is, err = src.revisionPresentIn(Revision("30605f6ac35fcb075ad0bfa9296f90a7d891523e"))
+	if err != nil {
+		t.Errorf("Unexpected error while re-checking revision presence: %s", err)
+	} else if !is {
+		t.Errorf("Revision that should exist was not present on re-check")
+	}
+}
+
+func TestBzrSourceInteractions(t *testing.T) {
+	// This test is quite slow (ugh bzr), so skip it on -short
+	if testing.Short() {
+		t.Skip("Skipping bzr source version fetching test in short mode")
+	}
+
+	cpath, err := ioutil.TempDir("", "smcache")
+	if err != nil {
+		t.Errorf("Failed to create temp dir: %s", err)
+	}
+	rf := func() {
+		err := removeAll(cpath)
+		if err != nil {
+			t.Errorf("removeAll failed: %s", err)
+		}
+	}
+
+	n := "launchpad.net/govcstestbzrrepo"
+	un := "https://" + n
+	u, err := url.Parse(un)
+	if err != nil {
+		t.Errorf("URL was bad, lolwut? errtext: %s", err)
+		rf()
+		t.FailNow()
+	}
+	mb := maybeBzrSource{
+		url: u,
+	}
+
+	isrc, ident, err := mb.try(cpath, naiveAnalyzer{})
+	if err != nil {
+		t.Errorf("Unexpected error while setting up bzrSource for test repo: %s", err)
+		rf()
+		t.FailNow()
+	}
+	src, ok := isrc.(*bzrSource)
+	if !ok {
+		t.Errorf("Expected a bzrSource, got a %T", isrc)
+		rf()
+		t.FailNow()
+	}
+	if ident != un {
+		t.Errorf("Expected %s as source ident, got %s", un, ident)
+	}
+
+	// check that an expected rev is present
+	is, err := src.revisionPresentIn(Revision("matt@mattfarina.com-20150731135137-pbphasfppmygpl68"))
+	if err != nil {
+		t.Errorf("Unexpected error while checking revision presence: %s", err)
+	} else if !is {
+		t.Errorf("Revision that should exist was not present")
+	}
+
+	vlist, err := src.listVersions()
+	if err != nil {
+		t.Errorf("Unexpected error getting version pairs from bzr repo: %s", err)
+	}
+
+	if src.ex.s&existsUpstream|existsInCache != existsUpstream|existsInCache {
+		t.Errorf("bzrSource.listVersions() should have set the upstream and cache existence bits for search")
+	}
+	if src.ex.f&existsUpstream|existsInCache != existsUpstream|existsInCache {
+		t.Errorf("bzrSource.listVersions() should have set the upstream and cache existence bits for found")
+	}
+
+	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])
+		}
+	}
+
+	// Run again, this time to ensure cache outputs correctly
+	vlist, err = src.listVersions()
+	if err != nil {
+		t.Errorf("Unexpected error getting version pairs from bzr repo: %s", err)
+	}
+
+	if src.ex.s&existsUpstream|existsInCache != existsUpstream|existsInCache {
+		t.Errorf("bzrSource.listVersions() should have set the upstream and cache existence bits for search")
+	}
+	if src.ex.f&existsUpstream|existsInCache != existsUpstream|existsInCache {
+		t.Errorf("bzrSource.listVersions() should have set the upstream and cache existence bits for found")
+	}
+
+	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])
+		}
+	}
+
+	// recheck that rev is present, this time interacting with cache differently
+	is, err = src.revisionPresentIn(Revision("matt@mattfarina.com-20150731135137-pbphasfppmygpl68"))
+	if err != nil {
+		t.Errorf("Unexpected error while re-checking revision presence: %s", err)
+	} else if !is {
+		t.Errorf("Revision that should exist was not present on re-check")
+	}
+}
+
+func TestHgSourceInteractions(t *testing.T) {
+	// This test is slow, so skip it on -short
+	if testing.Short() {
+		t.Skip("Skipping hg source version fetching test in short mode")
+	}
+
+	cpath, err := ioutil.TempDir("", "smcache")
+	if err != nil {
+		t.Errorf("Failed to create temp dir: %s", err)
+	}
+	rf := func() {
+		err := removeAll(cpath)
+		if err != nil {
+			t.Errorf("removeAll failed: %s", err)
+		}
+	}
+
+	n := "bitbucket.org/mattfarina/testhgrepo"
+	un := "https://" + n
+	u, err := url.Parse(un)
+	if err != nil {
+		t.Errorf("URL was bad, lolwut? errtext: %s", err)
+		rf()
+		t.FailNow()
+	}
+	mb := maybeHgSource{
+		url: u,
+	}
+
+	isrc, ident, err := mb.try(cpath, naiveAnalyzer{})
+	if err != nil {
+		t.Errorf("Unexpected error while setting up hgSource for test repo: %s", err)
+		rf()
+		t.FailNow()
+	}
+	src, ok := isrc.(*hgSource)
+	if !ok {
+		t.Errorf("Expected a hgSource, got a %T", isrc)
+		rf()
+		t.FailNow()
+	}
+	if ident != un {
+		t.Errorf("Expected %s as source ident, got %s", un, ident)
+	}
+
+	// check that an expected rev is present
+	is, err := src.revisionPresentIn(Revision("d680e82228d206935ab2eaa88612587abe68db07"))
+	if err != nil {
+		t.Errorf("Unexpected error while checking revision presence: %s", err)
+	} else if !is {
+		t.Errorf("Revision that should exist was not present")
+	}
+
+	vlist, err := src.listVersions()
+	if err != nil {
+		t.Errorf("Unexpected error getting version pairs from hg repo: %s", err)
+	}
+	evl := []Version{
+		NewVersion("1.0.0").Is(Revision("d680e82228d206935ab2eaa88612587abe68db07")),
+		NewBranch("test").Is(Revision("6c44ee3fe5d87763616c19bf7dbcadb24ff5a5ce")),
+	}
+
+	if src.ex.s&existsUpstream|existsInCache != existsUpstream|existsInCache {
+		t.Errorf("hgSource.listVersions() should have set the upstream and cache existence bits for search")
+	}
+	if src.ex.f&existsUpstream|existsInCache != existsUpstream|existsInCache {
+		t.Errorf("hgSource.listVersions() should have set the upstream and cache existence bits for found")
+	}
+
+	if len(vlist) != 2 {
+		t.Errorf("hg test repo should've produced one version, got %v", len(vlist))
+	} else {
+		sort.Sort(upgradeVersionSorter(vlist))
+		if !reflect.DeepEqual(vlist, evl) {
+			t.Errorf("Version list was not what we expected:\n\t(GOT): %s\n\t(WNT): %s", vlist, evl)
+		}
+	}
+
+	// Run again, this time to ensure cache outputs correctly
+	vlist, err = src.listVersions()
+	if err != nil {
+		t.Errorf("Unexpected error getting version pairs from hg repo: %s", err)
+	}
+
+	if src.ex.s&existsUpstream|existsInCache != existsUpstream|existsInCache {
+		t.Errorf("hgSource.listVersions() should have set the upstream and cache existence bits for search")
+	}
+	if src.ex.f&existsUpstream|existsInCache != existsUpstream|existsInCache {
+		t.Errorf("hgSource.listVersions() should have set the upstream and cache existence bits for found")
+	}
+
+	if len(vlist) != 2 {
+		t.Errorf("hg test repo should've produced one version, got %v", len(vlist))
+	} else {
+		sort.Sort(upgradeVersionSorter(vlist))
+		if !reflect.DeepEqual(vlist, evl) {
+			t.Errorf("Version list was not what we expected:\n\t(GOT): %s\n\t(WNT): %s", vlist, evl)
+		}
+	}
+
+	// recheck that rev is present, this time interacting with cache differently
+	is, err = src.revisionPresentIn(Revision("d680e82228d206935ab2eaa88612587abe68db07"))
+	if err != nil {
+		t.Errorf("Unexpected error while re-checking revision presence: %s", err)
+	} else if !is {
+		t.Errorf("Revision that should exist was not present on re-check")
+	}
+}
diff --git a/vendor/github.com/sdboyer/gps/trace.go b/vendor/github.com/sdboyer/gps/trace.go
new file mode 100644
index 0000000..4c20279
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/trace.go
@@ -0,0 +1,183 @@
+package gps
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+const (
+	successChar   = "✓"
+	successCharSp = successChar + " "
+	failChar      = "✗"
+	failCharSp    = failChar + " "
+	backChar      = "←"
+)
+
+func (s *solver) traceCheckPkgs(bmi bimodalIdentifier) {
+	if !s.params.Trace {
+		return
+	}
+
+	prefix := strings.Repeat("| ", len(s.vqs)+1)
+	s.tl.Printf("%s\n", tracePrefix(fmt.Sprintf("? revisit %s to add %v pkgs", bmi.id.errString(), len(bmi.pl)), prefix, prefix))
+}
+
+func (s *solver) traceCheckQueue(q *versionQueue, bmi bimodalIdentifier, cont bool, offset int) {
+	if !s.params.Trace {
+		return
+	}
+
+	prefix := strings.Repeat("| ", len(s.vqs)+offset)
+	vlen := strconv.Itoa(len(q.pi))
+	if !q.allLoaded {
+		vlen = "at least " + vlen
+	}
+
+	// TODO(sdboyer) how...to list the packages in the limited space we have?
+	var verb string
+	if cont {
+		verb = "continue"
+		vlen = vlen + " more"
+	} else {
+		verb = "attempt"
+	}
+
+	s.tl.Printf("%s\n", tracePrefix(fmt.Sprintf("? %s %s with %v pkgs; %s versions to try", verb, bmi.id.errString(), len(bmi.pl), vlen), prefix, prefix))
+}
+
+// traceStartBacktrack is called with the bmi that first failed, thus initiating
+// backtracking
+func (s *solver) traceStartBacktrack(bmi bimodalIdentifier, err error, pkgonly bool) {
+	if !s.params.Trace {
+		return
+	}
+
+	var msg string
+	if pkgonly {
+		msg = fmt.Sprintf("%s could not add %v pkgs to %s; begin backtrack", backChar, len(bmi.pl), bmi.id.errString())
+	} else {
+		msg = fmt.Sprintf("%s no more versions of %s to try; begin backtrack", backChar, bmi.id.errString())
+	}
+
+	prefix := strings.Repeat("| ", len(s.sel.projects))
+	s.tl.Printf("%s\n", tracePrefix(msg, prefix, prefix))
+}
+
+// traceBacktrack is called when a package or project is poppped off during
+// backtracking
+func (s *solver) traceBacktrack(bmi bimodalIdentifier, pkgonly bool) {
+	if !s.params.Trace {
+		return
+	}
+
+	var msg string
+	if pkgonly {
+		msg = fmt.Sprintf("%s backtrack: popped %v pkgs from %s", backChar, len(bmi.pl), bmi.id.errString())
+	} else {
+		msg = fmt.Sprintf("%s backtrack: no more versions of %s to try", backChar, bmi.id.errString())
+	}
+
+	prefix := strings.Repeat("| ", len(s.sel.projects))
+	s.tl.Printf("%s\n", tracePrefix(msg, prefix, prefix))
+}
+
+// Called just once after solving has finished, whether success or not
+func (s *solver) traceFinish(sol solution, err error) {
+	if !s.params.Trace {
+		return
+	}
+
+	if err == nil {
+		var pkgcount int
+		for _, lp := range sol.Projects() {
+			pkgcount += len(lp.pkgs)
+		}
+		s.tl.Printf("%s found solution with %v packages from %v projects", successChar, pkgcount, len(sol.Projects()))
+	} else {
+		s.tl.Printf("%s solving failed", failChar)
+	}
+}
+
+// traceSelectRoot is called just once, when the root project is selected
+func (s *solver) traceSelectRoot(ptree PackageTree, cdeps []completeDep) {
+	if !s.params.Trace {
+		return
+	}
+
+	// This duplicates work a bit, but we're in trace mode and it's only once,
+	// so who cares
+	rm := ptree.ExternalReach(true, true, s.ig)
+
+	s.tl.Printf("Root project is %q", s.params.ImportRoot)
+
+	var expkgs int
+	for _, cdep := range cdeps {
+		expkgs += len(cdep.pl)
+	}
+
+	// TODO(sdboyer) include info on ignored pkgs/imports, etc.
+	s.tl.Printf(" %v transitively valid internal packages", len(rm))
+	s.tl.Printf(" %v external packages imported from %v projects", expkgs, len(cdeps))
+	s.tl.Printf(successCharSp + "select (root)")
+}
+
+// traceSelect is called when an atom is successfully selected
+func (s *solver) traceSelect(awp atomWithPackages, pkgonly bool) {
+	if !s.params.Trace {
+		return
+	}
+
+	var msg string
+	if pkgonly {
+		msg = fmt.Sprintf("%s include %v more pkgs from %s", successChar, len(awp.pl), a2vs(awp.a))
+	} else {
+		msg = fmt.Sprintf("%s select %s w/%v pkgs", successChar, a2vs(awp.a), len(awp.pl))
+	}
+
+	prefix := strings.Repeat("| ", len(s.sel.projects)-1)
+	s.tl.Printf("%s\n", tracePrefix(msg, prefix, prefix))
+}
+
+func (s *solver) traceInfo(args ...interface{}) {
+	if !s.params.Trace {
+		return
+	}
+
+	if len(args) == 0 {
+		panic("must pass at least one param to traceInfo")
+	}
+
+	preflen := len(s.sel.projects)
+	var msg string
+	switch data := args[0].(type) {
+	case string:
+		msg = tracePrefix(fmt.Sprintf(data, args[1:]...), "| ", "| ")
+	case traceError:
+		preflen += 1
+		// We got a special traceError, use its custom method
+		msg = tracePrefix(data.traceString(), "| ", failCharSp)
+	case error:
+		// Regular error; still use the x leader but default Error() string
+		msg = tracePrefix(data.Error(), "| ", failCharSp)
+	default:
+		// panic here because this can *only* mean a stupid internal bug
+		panic(fmt.Sprintf("canary - unknown type passed as first param to traceInfo %T", data))
+	}
+
+	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] = fsep + str
+		} else {
+			parts[k] = sep + str
+		}
+	}
+
+	return strings.Join(parts, "\n")
+}
diff --git a/vendor/github.com/sdboyer/gps/typed_radix.go b/vendor/github.com/sdboyer/gps/typed_radix.go
new file mode 100644
index 0000000..9f56a9b
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/typed_radix.go
@@ -0,0 +1,151 @@
+package gps
+
+import (
+	"strings"
+
+	"github.com/armon/go-radix"
+)
+
+// Typed implementations of radix trees. These are just simple wrappers that let
+// us avoid having to type assert anywhere else, cleaning up other code a bit.
+//
+// Some of the more annoying things to implement (like walks) aren't
+// implemented. They can be added if/when we actually need them.
+//
+// Oh generics, where art thou...
+
+type deducerTrie struct {
+	t *radix.Tree
+}
+
+func newDeducerTrie() deducerTrie {
+	return deducerTrie{
+		t: radix.New(),
+	}
+}
+
+// Delete is used to delete a key, returning the previous value and if it was deleted
+func (t deducerTrie) Delete(s string) (pathDeducer, bool) {
+	if v, had := t.t.Delete(s); had {
+		return v.(pathDeducer), had
+	}
+	return nil, false
+}
+
+// Get is used to lookup a specific key, returning the value and if it was found
+func (t deducerTrie) Get(s string) (pathDeducer, bool) {
+	if v, has := t.t.Get(s); has {
+		return v.(pathDeducer), has
+	}
+	return nil, false
+}
+
+// Insert is used to add a newentry or update an existing entry. Returns if updated.
+func (t deducerTrie) Insert(s string, v pathDeducer) (pathDeducer, bool) {
+	if v2, had := t.t.Insert(s, v); had {
+		return v2.(pathDeducer), had
+	}
+	return nil, false
+}
+
+// Len is used to return the number of elements in the tree
+func (t deducerTrie) Len() int {
+	return t.t.Len()
+}
+
+// LongestPrefix is like Get, but instead of an exact match, it will return the
+// longest prefix match.
+func (t deducerTrie) LongestPrefix(s string) (string, pathDeducer, bool) {
+	if p, v, has := t.t.LongestPrefix(s); has {
+		return p, v.(pathDeducer), has
+	}
+	return "", nil, false
+}
+
+// ToMap is used to walk the tree and convert it to a map.
+func (t deducerTrie) ToMap() map[string]pathDeducer {
+	m := make(map[string]pathDeducer)
+	t.t.Walk(func(s string, v interface{}) bool {
+		m[s] = v.(pathDeducer)
+		return false
+	})
+
+	return m
+}
+
+type prTrie struct {
+	t *radix.Tree
+}
+
+func newProjectRootTrie() prTrie {
+	return prTrie{
+		t: radix.New(),
+	}
+}
+
+// Delete is used to delete a key, returning the previous value and if it was deleted
+func (t prTrie) Delete(s string) (ProjectRoot, bool) {
+	if v, had := t.t.Delete(s); had {
+		return v.(ProjectRoot), had
+	}
+	return "", false
+}
+
+// Get is used to lookup a specific key, returning the value and if it was found
+func (t prTrie) Get(s string) (ProjectRoot, bool) {
+	if v, has := t.t.Get(s); has {
+		return v.(ProjectRoot), has
+	}
+	return "", false
+}
+
+// Insert is used to add a newentry or update an existing entry. Returns if updated.
+func (t prTrie) Insert(s string, v ProjectRoot) (ProjectRoot, bool) {
+	if v2, had := t.t.Insert(s, v); had {
+		return v2.(ProjectRoot), had
+	}
+	return "", false
+}
+
+// Len is used to return the number of elements in the tree
+func (t prTrie) Len() int {
+	return t.t.Len()
+}
+
+// LongestPrefix is like Get, but instead of an exact match, it will return the
+// longest prefix match.
+func (t prTrie) LongestPrefix(s string) (string, ProjectRoot, bool) {
+	if p, v, has := t.t.LongestPrefix(s); has && isPathPrefixOrEqual(p, s) {
+		return p, v.(ProjectRoot), has
+	}
+	return "", "", false
+}
+
+// ToMap is used to walk the tree and convert it to a map.
+func (t prTrie) ToMap() map[string]ProjectRoot {
+	m := make(map[string]ProjectRoot)
+	t.t.Walk(func(s string, v interface{}) bool {
+		m[s] = v.(ProjectRoot)
+		return false
+	})
+
+	return m
+}
+
+// isPathPrefixOrEqual is an additional helper check to ensure that the literal
+// string prefix returned from a radix tree prefix match is also a tree 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 with the former. 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 a "/".
+func isPathPrefixOrEqual(pre, path string) bool {
+	prflen := len(pre)
+	return prflen == len(path) || strings.Index(path[:prflen], "/") == 0
+}
diff --git a/vendor/github.com/sdboyer/gps/types.go b/vendor/github.com/sdboyer/gps/types.go
index f720fa2..b40807d 100644
--- a/vendor/github.com/sdboyer/gps/types.go
+++ b/vendor/github.com/sdboyer/gps/types.go
@@ -75,14 +75,6 @@
 	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
@@ -134,6 +126,16 @@
 	return i
 }
 
+// ProjectProperties comprise the properties that can attached to a ProjectRoot.
+//
+// In general, these are declared in the context of a map of ProjectRoot to its
+// ProjectProperties; they make little sense without their corresponding
+// ProjectRoot.
+type ProjectProperties struct {
+	NetworkName string
+	Constraint  Constraint
+}
+
 // Package represents a Go package. It contains a subset of the information
 // go/build.Package does.
 type Package struct {
@@ -144,8 +146,6 @@
 }
 
 // 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
@@ -172,6 +172,18 @@
 	pl []string
 }
 
+// bmi converts an atomWithPackages into a bimodalIdentifier.
+//
+// This is mostly intended for (read-only) trace use, so the package list slice
+// is not copied. It is the callers responsibility to not modify the pl slice,
+// lest that backpropagate and cause inconsistencies.
+func (awp atomWithPackages) bmi() bimodalIdentifier {
+	return bimodalIdentifier{
+		id: awp.a.id,
+		pl: awp.pl,
+	}
+}
+
 //type byImportPath []Package
 
 //func (s byImportPath) Len() int           { return len(s) }
@@ -183,8 +195,8 @@
 // are the same) name, a constraint, and the actual packages needed that are
 // under that root.
 type completeDep struct {
-	// The base ProjectDep
-	ProjectConstraint
+	// The base workingConstraint
+	workingConstraint
 	// The specific packages required from the ProjectDep
 	pl []string
 }
diff --git a/vendor/github.com/sdboyer/gps/vcs_source.go b/vendor/github.com/sdboyer/gps/vcs_source.go
new file mode 100644
index 0000000..277b1db
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/vcs_source.go
@@ -0,0 +1,439 @@
+package gps
+
+import (
+	"bytes"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"sync"
+
+	"github.com/Masterminds/vcs"
+	"github.com/termie/go-shutil"
+)
+
+type vcsSource interface {
+	syncLocal() error
+	ensureLocal() error
+	listLocalVersionPairs() ([]PairedVersion, sourceExistence, error)
+	listUpstreamVersionPairs() ([]PairedVersion, sourceExistence, error)
+	hasRevision(Revision) (bool, error)
+	checkout(Version) error
+	exportVersionTo(Version, string) error
+}
+
+// gitSource is a generic git repository implementation that should work with
+// all standard git remotes.
+type gitSource struct {
+	baseVCSSource
+}
+
+func (s *gitSource) exportVersionTo(v Version, to string) error {
+	s.crepo.mut.Lock()
+	defer s.crepo.mut.Unlock()
+
+	r := s.crepo.r
+	if !r.CheckLocal() {
+		err := r.Get()
+		if err != nil {
+			return fmt.Errorf("failed to clone repo from %s", r.Remote())
+		}
+	}
+	// Back up original index
+	idx, bak := filepath.Join(r.LocalPath(), ".git", "index"), filepath.Join(r.LocalPath(), ".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.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.RunFromDir("git", "checkout-index", "-a", "--prefix="+to)
+	return err
+}
+
+func (s *gitSource) listVersions() (vlist []Version, err error) {
+	if s.cvsync {
+		vlist = make([]Version, len(s.dc.vMap))
+		k := 0
+		for v, r := range s.dc.vMap {
+			vlist[k] = v.Is(r)
+			k++
+		}
+
+		return
+	}
+
+	r := s.crepo.r
+	var out []byte
+	c := exec.Command("git", "ls-remote", 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
+		s.crepo.mut.Lock()
+		err = r.Update()
+		s.crepo.mut.Unlock()
+		if err != nil {
+			// Definitely have a problem, now - bail out
+			return
+		}
+
+		// Upstream and cache must exist for this to have worked, so add that to
+		// searched and found
+		s.ex.s |= existsUpstream | existsInCache
+		s.ex.f |= existsUpstream | existsInCache
+		// Also, local is definitely now synced
+		s.crepo.synced = true
+
+		s.crepo.mut.RLock()
+		out, err = r.RunFromDir("git", "show-ref", "--dereference")
+		s.crepo.mut.RUnlock()
+		if err != nil {
+			// TODO(sdboyer) More-er proper-er error
+			return
+		}
+
+		all = bytes.Split(bytes.TrimSpace(out), []byte("\n"))
+		if len(all) == 0 {
+			return nil, fmt.Errorf("no versions available for %s (this is weird)", r.Remote())
+		}
+	}
+
+	// Local cache may not actually exist here, but upstream definitely does
+	s.ex.s |= existsUpstream
+	s.ex.f |= existsUpstream
+
+	smap := make(map[string]bool)
+	uniq := 0
+	vlist = make([]Version, len(all)-1) // less 1, because always ignore HEAD
+	for _, pair := range all {
+		var v PairedVersion
+		if string(pair[46:51]) == "heads" {
+			v = NewBranch(string(pair[52:])).Is(Revision(pair[:40])).(PairedVersion)
+			vlist[uniq] = v
+			uniq++
+		} 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 smap[vstr] {
+				// 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)
+			smap[vstr] = true
+			vlist[uniq] = v
+			uniq++
+		}
+	}
+
+	// Trim off excess from the slice
+	vlist = vlist[:uniq]
+
+	// Process the version data into the cache
+	//
+	// reset the rmap and vmap, as they'll be fully repopulated by this
+	// TODO(sdboyer) detect out-of-sync pairings as we do this?
+	s.dc.vMap = make(map[UnpairedVersion]Revision)
+	s.dc.rMap = make(map[Revision][]UnpairedVersion)
+
+	for _, v := range vlist {
+		pv := v.(PairedVersion)
+		u, r := pv.Unpair(), pv.Underlying()
+		s.dc.vMap[u] = r
+		s.dc.rMap[r] = append(s.dc.rMap[r], u)
+	}
+	// Mark the cache as being in sync with upstream's version list
+	s.cvsync = true
+	return
+}
+
+// bzrSource is a generic bzr repository implementation that should work with
+// all standard bazaar remotes.
+type bzrSource struct {
+	baseVCSSource
+}
+
+func (s *bzrSource) listVersions() (vlist []Version, err error) {
+	if s.cvsync {
+		vlist = make([]Version, len(s.dc.vMap))
+		k := 0
+		for v, r := range s.dc.vMap {
+			vlist[k] = v.Is(r)
+			k++
+		}
+
+		return
+	}
+
+	// Must first ensure cache checkout's existence
+	err = s.ensureCacheExistence()
+	if err != nil {
+		return
+	}
+	r := s.crepo.r
+
+	// Local repo won't have all the latest refs if ensureCacheExistence()
+	// didn't create it
+	if !s.crepo.synced {
+		s.crepo.mut.Lock()
+		err = r.Update()
+		s.crepo.mut.Unlock()
+		if err != nil {
+			return
+		}
+
+		s.crepo.synced = true
+	}
+
+	var out []byte
+
+	// Now, list all the tags
+	out, err = r.RunFromDir("bzr", "tags", "--show-ids", "-v")
+	if err != nil {
+		return
+	}
+
+	all := bytes.Split(bytes.TrimSpace(out), []byte("\n"))
+
+	// reset the rmap and vmap, as they'll be fully repopulated by this
+	// TODO(sdboyer) detect out-of-sync pairings as we do this?
+	s.dc.vMap = make(map[UnpairedVersion]Revision)
+	s.dc.rMap = make(map[Revision][]UnpairedVersion)
+
+	vlist = make([]Version, len(all))
+	k := 0
+	for _, line := range all {
+		idx := bytes.IndexByte(line, 32) // space
+		v := NewVersion(string(line[:idx]))
+		r := Revision(bytes.TrimSpace(line[idx:]))
+
+		s.dc.vMap[v] = r
+		s.dc.rMap[r] = append(s.dc.rMap[r], v)
+		vlist[k] = v.Is(r)
+		k++
+	}
+
+	// Cache is now in sync with upstream's version list
+	s.cvsync = true
+	return
+}
+
+// hgSource is a generic hg repository implementation that should work with
+// all standard mercurial servers.
+type hgSource struct {
+	baseVCSSource
+}
+
+func (s *hgSource) listVersions() (vlist []Version, err error) {
+	if s.cvsync {
+		vlist = make([]Version, len(s.dc.vMap))
+		k := 0
+		for v, r := range s.dc.vMap {
+			vlist[k] = v.Is(r)
+			k++
+		}
+
+		return
+	}
+
+	// Must first ensure cache checkout's existence
+	err = s.ensureCacheExistence()
+	if err != nil {
+		return
+	}
+	r := s.crepo.r
+
+	// Local repo won't have all the latest refs if ensureCacheExistence()
+	// didn't create it
+	if !s.crepo.synced {
+		s.crepo.mut.Lock()
+		err = r.Update()
+		s.crepo.mut.Unlock()
+		if err != nil {
+			return
+		}
+
+		s.crepo.synced = true
+	}
+
+	var out []byte
+
+	// Now, list all the tags
+	out, err = 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.RunFromDir("hg", "branches", "--debug", "--verbose")
+	if err != nil {
+		// better nothing than partial and misleading
+		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)
+	}
+
+	// reset the rmap and vmap, as they'll be fully repopulated by this
+	// TODO(sdboyer) detect out-of-sync pairings as we do this?
+	s.dc.vMap = make(map[UnpairedVersion]Revision)
+	s.dc.rMap = make(map[Revision][]UnpairedVersion)
+
+	for _, v := range vlist {
+		pv := v.(PairedVersion)
+		u, r := pv.Unpair(), pv.Underlying()
+		s.dc.vMap[u] = r
+		s.dc.rMap[r] = append(s.dc.rMap[r], u)
+	}
+
+	// Cache is now in sync with upstream's version list
+	s.cvsync = true
+	return
+}
+
+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 (r *repo) exportVersionTo(v Version, to string) error {
+	r.mut.Lock()
+	defer r.mut.Unlock()
+
+	// TODO(sdboyer) This is a dumb, slow approach, but we're punting on making
+	// these fast for now because git is the OVERWHELMING case (it's handled in
+	// its own method)
+	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/version.go b/vendor/github.com/sdboyer/gps/version.go
index 57d37ec..ad79bff 100644
--- a/vendor/github.com/sdboyer/gps/version.go
+++ b/vendor/github.com/sdboyer/gps/version.go
@@ -16,6 +16,7 @@
 // hiding behind the interface.
 type Version interface {
 	Constraint
+
 	// Indicates the type of version - Revision, Branch, Version, or Semver
 	Type() string
 }
@@ -24,8 +25,15 @@
 // underlying Revision.
 type PairedVersion interface {
 	Version
+
 	// Underlying returns the immutable Revision that identifies this Version.
 	Underlying() Revision
+
+	// Unpair returns the surface-level UnpairedVersion that half of the pair.
+	//
+	// It does NOT modify the original PairedVersion
+	Unpair() UnpairedVersion
+
 	// Ensures it is impossible to be both a PairedVersion and an
 	// UnpairedVersion
 	_pair(int)
@@ -380,6 +388,10 @@
 	return v.r
 }
 
+func (v versionPair) Unpair() UnpairedVersion {
+	return v.v
+}
+
 func (v versionPair) Matches(v2 Version) bool {
 	switch tv2 := v2.(type) {
 	case versionTypeUnion:
@@ -470,8 +482,6 @@
 			return 0
 		case branchVersion, plainVersion, semVersion:
 			return 1
-		default:
-			panic("unknown version type")
 		}
 	case branchVersion:
 		switch r.(type) {
@@ -481,8 +491,6 @@
 			return 0
 		case plainVersion, semVersion:
 			return 1
-		default:
-			panic("unknown version type")
 		}
 
 	case plainVersion:
@@ -493,8 +501,6 @@
 			return 0
 		case semVersion:
 			return 1
-		default:
-			panic("unknown version type")
 		}
 
 	case semVersion:
@@ -503,10 +509,7 @@
 			return -1
 		case semVersion:
 			return 0
-		default:
-			panic("unknown version type")
 		}
-	default:
-		panic("unknown version type")
 	}
+	panic("unknown version type")
 }
diff --git a/vendor/github.com/sdboyer/gps/version_queue.go b/vendor/github.com/sdboyer/gps/version_queue.go
index e74a1da..7c92253 100644
--- a/vendor/github.com/sdboyer/gps/version_queue.go
+++ b/vendor/github.com/sdboyer/gps/version_queue.go
@@ -40,7 +40,7 @@
 
 	if len(vq.pi) == 0 {
 		var err error
-		vq.pi, err = vq.b.listVersions(vq.id)
+		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
@@ -86,7 +86,7 @@
 		}
 
 		vq.allLoaded = true
-		vq.pi, err = vq.b.listVersions(vq.id)
+		vq.pi, err = vq.b.ListVersions(vq.id)
 		if err != nil {
 			return err
 		}