Switch over to gps
diff --git a/glide.lock b/glide.lock
index da12611..951824d 100644
--- a/glide.lock
+++ b/glide.lock
@@ -9,8 +9,8 @@
version: 0a2c9fc0eee2c4cbb9526877c4a54da047fdcadd
- name: github.com/Masterminds/vcs
version: 7af28b64c5ec41b1558f5514fd938379822c237c
-- name: github.com/sdboyer/vsolver
- version: 4a1c3dd00ed484b3e87b4668b357e531b36baaa8
+- name: github.com/sdboyer/gps
+ version: a868c10855893c21ed05d0f50d6f9acb12b6366d
- name: github.com/termie/go-shutil
version: bcacb06fecaeec8dc42af03c87c6949f4a05c74c
- name: gopkg.in/yaml.v2
diff --git a/glide.yaml b/glide.yaml
index 5efef43..7a966ad 100644
--- a/glide.yaml
+++ b/glide.yaml
@@ -17,5 +17,5 @@
version: ~1.14.0
- package: github.com/Masterminds/semver
branch: 2.x
-- package: github.com/sdboyer/vsolver
+- package: github.com/sdboyer/gps
branch: master
diff --git a/vendor/github.com/sdboyer/vsolver/.gitignore b/vendor/github.com/sdboyer/gps/.gitignore
similarity index 100%
rename from vendor/github.com/sdboyer/vsolver/.gitignore
rename to vendor/github.com/sdboyer/gps/.gitignore
diff --git a/vendor/github.com/sdboyer/gps/CODE_OF_CONDUCT.md b/vendor/github.com/sdboyer/gps/CODE_OF_CONDUCT.md
new file mode 100644
index 0000000..660ee84
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/CODE_OF_CONDUCT.md
@@ -0,0 +1,74 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of
+experience, nationality, personal appearance, race, religion, or sexual identity
+and orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+ advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+ address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+ professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, or to ban temporarily or permanently any
+contributor for other behaviors that they deem inappropriate, threatening,
+offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at sam (at) samboyer.org. All complaints
+will be reviewed and investigated and will result in a response that is deemed
+necessary and appropriate to the circumstances. The project team is obligated to
+maintain confidentiality with regard to the reporter of an incident. Further
+details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 1.4, available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/
diff --git a/vendor/github.com/sdboyer/gps/CONTRIBUTING.md b/vendor/github.com/sdboyer/gps/CONTRIBUTING.md
new file mode 100644
index 0000000..3ff03b3
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/CONTRIBUTING.md
@@ -0,0 +1,58 @@
+# Contributing to `gps`
+
+:+1::tada: First, we're thrilled you're thinking about contributing! :tada::+1:
+
+As a library trying to cover all the bases in Go package management, it's
+crucial that we incorporate a broad range of experiences and use cases. There is
+a strong, motivating design behind `gps`, but we are always open to discussion
+on ways we can improve the library, particularly if it allows `gps` to cover
+more of the Go package management possibility space.
+
+`gps` has no CLA, but we do have a [Code of Conduct](https://github.com/sdboyer/gps/blob/master/CODE_OF_CONDUCT.md). By
+participating, you are expected to uphold this code.
+
+## How can I contribute?
+
+It may be best to start by getting a handle on what `gps` actually is. Our
+wiki has a [general introduction](https://github.com/sdboyer/gps/wiki/Introduction-to-gps), a
+[guide for tool implementors](https://github.com/sdboyer/gps/wiki/gps-for-Implementors), and
+a [guide for contributors](https://github.com/sdboyer/gps/wiki/gps-for-contributors).
+There's also a [discursive essay](https://medium.com/@sdboyer/so-you-want-to-write-a-package-manager-4ae9c17d9527)
+that lays out the big-picture goals and considerations driving the `gps` design.
+
+There are a number of ways to contribute, all highly valuable and deeply
+appreciated:
+
+* **Helping "translate" existing issues:** as `gps` exits its larval stage, it still
+ has a number of issues that may be incomprehensible to everyone except
+ @sdboyer. Simply asking clarifying questions on these issues is helpful!
+* **Identifying missed use cases:** the loose `gps` rule of thumb is, "if you can do
+ it in Go, we support it in `gps`." Posting issues about cases we've missed
+ helps us reach that goal.
+* **Writing tests:** in the same vein, `gps` has a [large suite](https://github.com/sdboyer/gps/blob/master/CODE_OF_CONDUCT.md) of solving tests, but
+ they still only scratch the surface. Writing tests is not only helpful, but is
+ also a great way to get a feel for how `gps` works.
+* **Suggesting enhancements:** `gps` has plenty of missing chunks. Help fill them in!
+* **Reporting bugs**: `gps` being a library means this isn't always the easiest.
+ However, you could always compile the [example](https://github.com/sdboyer/gps/blob/master/example.go), run that against some of
+ your projects, and report problems you encounter.
+* **Building experimental tools with `gps`:** probably the best and fastest ways to
+ kick the tires!
+
+`gps` is still beta-ish software. There are plenty of bugs to squash! APIs are
+stabilizing, but are still subject to change.
+
+## Issues and Pull Requests
+
+Pull requests are the preferred way to submit changes to 'gps'. Unless the
+changes are quite small, pull requests should generally reference an
+already-opened issue. Make sure to explain clearly in the body of the PR what
+the reasoning behind the change is.
+
+The changes themselves should generally conform to the following guidelines:
+
+* Git commit messages should be [well-written](http://chris.beams.io/posts/git-commit/#seven-rules).
+* Code should be `gofmt`-ed.
+* New or changed logic should be accompanied by tests.
+* Maintainable, table-based tests are strongly preferred, even if it means
+ writing a new testing harness to execute them.
diff --git a/vendor/github.com/sdboyer/vsolver/LICENSE b/vendor/github.com/sdboyer/gps/LICENSE
similarity index 100%
rename from vendor/github.com/sdboyer/vsolver/LICENSE
rename to vendor/github.com/sdboyer/gps/LICENSE
diff --git a/vendor/github.com/sdboyer/gps/README.md b/vendor/github.com/sdboyer/gps/README.md
new file mode 100644
index 0000000..227bf6b
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/README.md
@@ -0,0 +1,95 @@
+# gps
+
+--
+
+[](https://circleci.com/gh/sdboyer/gps) [](https://goreportcard.com/report/github.com/sdboyer/gps) [](https://godoc.org/github.com/sdboyer/gps)
+
+`gps` is the Go Packaging Solver. It is an engine for tackling dependency
+management problems in Go. You can replicate the fetching bits of `go get`,
+modulo arguments, [in about 30 lines of
+code](https://github.com/sdboyer/gps/blob/master/example.go) with `gps`.
+
+`gps` is _not_ Yet Another Go Package Management Tool. Rather, it's a library
+that package management (and adjacent) tools can use to solve the
+[hard](https://en.wikipedia.org/wiki/Boolean_satisfiability_problem) parts of
+the problem in a consistent,
+[holistic](https://medium.com/@sdboyer/so-you-want-to-write-a-package-manager-4ae9c17d9527)
+way. `gps` is [on track](https://github.com/Masterminds/glide/pull/384) to become the engine behind [glide](https://glide.sh).
+
+The wiki has a [general introduction to the `gps`
+approach](https://github.com/sdboyer/gps/wiki/Introduction-to-gps), as well
+as guides for folks [implementing
+tools](https://github.com/sdboyer/gps/wiki/gps-for-Implementors) or [looking
+to contribute](https://github.com/sdboyer/gps/wiki/Introduction-to-gps).
+
+**`gps` is progressing rapidly, but still beta, with a liberal sprinkling of panics.**
+
+## Wait...a package management _library_?!
+
+Yup. Because it's what the Go ecosystem needs right now.
+
+There are [scads of
+tools](https://github.com/golang/go/wiki/PackageManagementTools) out there, each
+tackling some slice of the Go package management domain. Some handle more than
+others, some impose more restrictions than others, and most are mutually
+incompatible (or mutually indifferent, which amounts to the same). This
+fragments the Go FLOSS ecosystem, harming the community as a whole.
+
+As in all epic software arguments, some of the points of disagreement between
+tools/their authors are a bit silly. Many, though, are based on legitimate
+differences of opinion about what workflows, controls, and interfaces are
+best to give Go developers.
+
+Now, we're certainly no less opinionated than anyone else. But part of the
+challenge has been that, with a problem as
+[complex](https://medium.com/@sdboyer/so-you-want-to-write-a-package-manager-4ae9c17d9527)
+as package management, subtle design decisions made in pursuit of a particular
+workflow or interface can have far-reaching effects on architecture, leading to
+deep incompatibilities between tools and approaches.
+
+We believe that many of [these
+differences](https://docs.google.com/document/d/1xrV9D5u8AKu1ip-A1W9JqhUmmeOhoI6d6zjVwvdn5mc/edit?usp=sharing)
+are incidental - and, given the right general solution, reconcilable. `gps` is
+our attempt at such a solution.
+
+By separating out the underlying problem into a standalone library, we are
+hoping to provide a common foundation for different tools. Such a foundation
+could improve interoperability, reduce harm to the ecosystem, and make the
+communal process of figuring out what's right for Go more about collaboration,
+and less about fiefdoms.
+
+### Assumptions
+
+Ideally, `gps` could provide this shared foundation with no additional
+assumptions beyond pure Go source files. Sadly, package management is too
+complex to be assumption-less. So, `gps` tries to keep its assumptions to the
+minimum, supporting as many situations as possible while still maintaining a
+predictable, well-formed system.
+
+* Go 1.6, or 1.5 with `GO15VENDOREXPERIMENT = 1` set. `vendor/`
+ directories are a requirement.
+* You don't manually change what's under `vendor/`. That’s tooling’s
+ job.
+* A **project** concept, where projects comprise the set of Go packages in a
+ rooted directory tree. By happy (not) accident, `vendor/` directories also
+ just happen to cover a rooted tree.
+* A [**manifest**](https://godoc.org/github.com/sdboyer/gps#Manifest) and
+ [**lock**](https://godoc.org/github.com/sdboyer/gps#Lock) approach to
+ tracking version and constraint information. The solver takes manifest (and,
+ optionally, lock)-type data as inputs, and produces lock-type data as its
+ output. Tools decide how to actually store this data, but these should
+ generally be at the root of the project tree.
+
+Manifests? Locks? Eeew. Yes, we also think it'd be swell if we didn't need
+metadata files. We love the idea of Go packages as standalone, self-describing
+code. Unfortunately, the wheels come off that idea as soon as versioning and
+cross-project/repository dependencies happen. But universe alignment is hard;
+trying to intermix version information directly with the code would only make
+matters worse.
+
+## Contributing
+
+Yay, contributing! Please see
+[CONTRIBUTING.md](https://github.com/sdboyer/gps/blob/master/CONTRIBUTING.md).
+Note that `gps` also abides by a [Code of
+Conduct](https://github.com/sdboyer/gps/blob/master/CODE_OF_CONDUCT.md), and is MIT-licensed.
diff --git a/vendor/github.com/sdboyer/gps/_testdata/src/disallow/.m1p/a.go b/vendor/github.com/sdboyer/gps/_testdata/src/disallow/.m1p/a.go
new file mode 100644
index 0000000..e4e2ced
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/_testdata/src/disallow/.m1p/a.go
@@ -0,0 +1,12 @@
+package m1p
+
+import (
+ "sort"
+
+ "github.com/sdboyer/gps"
+)
+
+var (
+ _ = sort.Strings
+ S = gps.Solve
+)
diff --git a/vendor/github.com/sdboyer/vsolver/_testdata/src/m1p/b.go b/vendor/github.com/sdboyer/gps/_testdata/src/disallow/.m1p/b.go
similarity index 100%
copy from vendor/github.com/sdboyer/vsolver/_testdata/src/m1p/b.go
copy to vendor/github.com/sdboyer/gps/_testdata/src/disallow/.m1p/b.go
diff --git a/vendor/github.com/sdboyer/gps/_testdata/src/disallow/a.go b/vendor/github.com/sdboyer/gps/_testdata/src/disallow/a.go
new file mode 100644
index 0000000..59d2f72
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/_testdata/src/disallow/a.go
@@ -0,0 +1,14 @@
+package disallow
+
+import (
+ "sort"
+ "disallow/testdata"
+
+ "github.com/sdboyer/gps"
+)
+
+var (
+ _ = sort.Strings
+ _ = gps.Solve
+ _ = testdata.H
+)
diff --git a/vendor/github.com/sdboyer/gps/_testdata/src/disallow/testdata/another.go b/vendor/github.com/sdboyer/gps/_testdata/src/disallow/testdata/another.go
new file mode 100644
index 0000000..6defdae
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/_testdata/src/disallow/testdata/another.go
@@ -0,0 +1,7 @@
+package testdata
+
+import "hash"
+
+var (
+ H = hash.Hash
+)
diff --git a/vendor/github.com/sdboyer/gps/_testdata/src/doublenest/a.go b/vendor/github.com/sdboyer/gps/_testdata/src/doublenest/a.go
new file mode 100644
index 0000000..04cac6a
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/_testdata/src/doublenest/a.go
@@ -0,0 +1,12 @@
+package base
+
+import (
+ "go/parser"
+
+ "github.com/sdboyer/gps"
+)
+
+var (
+ _ = parser.ParseFile
+ _ = gps.Solve
+)
diff --git a/vendor/github.com/sdboyer/gps/_testdata/src/doublenest/namemismatch/m1p/a.go b/vendor/github.com/sdboyer/gps/_testdata/src/doublenest/namemismatch/m1p/a.go
new file mode 100644
index 0000000..ec1f9b9
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/_testdata/src/doublenest/namemismatch/m1p/a.go
@@ -0,0 +1,12 @@
+package m1p
+
+import (
+ "sort"
+
+ "github.com/sdboyer/gps"
+)
+
+var (
+ _ = sort.Strings
+ _ = gps.Solve
+)
diff --git a/vendor/github.com/sdboyer/vsolver/_testdata/src/m1p/b.go b/vendor/github.com/sdboyer/gps/_testdata/src/doublenest/namemismatch/m1p/b.go
similarity index 100%
copy from vendor/github.com/sdboyer/vsolver/_testdata/src/m1p/b.go
copy to vendor/github.com/sdboyer/gps/_testdata/src/doublenest/namemismatch/m1p/b.go
diff --git a/vendor/github.com/sdboyer/vsolver/_testdata/src/varied/namemismatch/nm.go b/vendor/github.com/sdboyer/gps/_testdata/src/doublenest/namemismatch/nm.go
similarity index 100%
copy from vendor/github.com/sdboyer/vsolver/_testdata/src/varied/namemismatch/nm.go
copy to vendor/github.com/sdboyer/gps/_testdata/src/doublenest/namemismatch/nm.go
diff --git a/vendor/github.com/sdboyer/vsolver/_testdata/src/empty/.gitkeep b/vendor/github.com/sdboyer/gps/_testdata/src/empty/.gitkeep
similarity index 100%
rename from vendor/github.com/sdboyer/vsolver/_testdata/src/empty/.gitkeep
rename to vendor/github.com/sdboyer/gps/_testdata/src/empty/.gitkeep
diff --git a/vendor/github.com/sdboyer/gps/_testdata/src/igmain/a.go b/vendor/github.com/sdboyer/gps/_testdata/src/igmain/a.go
new file mode 100644
index 0000000..300b730
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/_testdata/src/igmain/a.go
@@ -0,0 +1,12 @@
+package simple
+
+import (
+ "sort"
+
+ "github.com/sdboyer/gps"
+)
+
+var (
+ _ = sort.Strings
+ _ = gps.Solve
+)
diff --git a/vendor/github.com/sdboyer/vsolver/_testdata/src/igmain/igmain.go b/vendor/github.com/sdboyer/gps/_testdata/src/igmain/igmain.go
similarity index 100%
rename from vendor/github.com/sdboyer/vsolver/_testdata/src/igmain/igmain.go
rename to vendor/github.com/sdboyer/gps/_testdata/src/igmain/igmain.go
diff --git a/vendor/github.com/sdboyer/gps/_testdata/src/igmainlong/a.go b/vendor/github.com/sdboyer/gps/_testdata/src/igmainlong/a.go
new file mode 100644
index 0000000..300b730
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/_testdata/src/igmainlong/a.go
@@ -0,0 +1,12 @@
+package simple
+
+import (
+ "sort"
+
+ "github.com/sdboyer/gps"
+)
+
+var (
+ _ = sort.Strings
+ _ = gps.Solve
+)
diff --git a/vendor/github.com/sdboyer/gps/_testdata/src/igmainlong/igmain.go b/vendor/github.com/sdboyer/gps/_testdata/src/igmainlong/igmain.go
new file mode 100644
index 0000000..efee3f9
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/_testdata/src/igmainlong/igmain.go
@@ -0,0 +1,9 @@
+// Another comment, which the parser should ignore and still see builds tags
+
+// +build ignore
+
+package main
+
+import "unicode"
+
+var _ = unicode.In
diff --git a/vendor/github.com/sdboyer/gps/_testdata/src/igmaint/a.go b/vendor/github.com/sdboyer/gps/_testdata/src/igmaint/a.go
new file mode 100644
index 0000000..300b730
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/_testdata/src/igmaint/a.go
@@ -0,0 +1,12 @@
+package simple
+
+import (
+ "sort"
+
+ "github.com/sdboyer/gps"
+)
+
+var (
+ _ = sort.Strings
+ _ = gps.Solve
+)
diff --git a/vendor/github.com/sdboyer/vsolver/_testdata/src/igmaint/igmain.go b/vendor/github.com/sdboyer/gps/_testdata/src/igmaint/igmain.go
similarity index 100%
rename from vendor/github.com/sdboyer/vsolver/_testdata/src/igmaint/igmain.go
rename to vendor/github.com/sdboyer/gps/_testdata/src/igmaint/igmain.go
diff --git a/vendor/github.com/sdboyer/vsolver/_testdata/src/igmaint/t_test.go b/vendor/github.com/sdboyer/gps/_testdata/src/igmaint/t_test.go
similarity index 100%
rename from vendor/github.com/sdboyer/vsolver/_testdata/src/igmaint/t_test.go
rename to vendor/github.com/sdboyer/gps/_testdata/src/igmaint/t_test.go
diff --git a/vendor/github.com/sdboyer/gps/_testdata/src/m1p/a.go b/vendor/github.com/sdboyer/gps/_testdata/src/m1p/a.go
new file mode 100644
index 0000000..ec1f9b9
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/_testdata/src/m1p/a.go
@@ -0,0 +1,12 @@
+package m1p
+
+import (
+ "sort"
+
+ "github.com/sdboyer/gps"
+)
+
+var (
+ _ = sort.Strings
+ _ = gps.Solve
+)
diff --git a/vendor/github.com/sdboyer/vsolver/_testdata/src/m1p/b.go b/vendor/github.com/sdboyer/gps/_testdata/src/m1p/b.go
similarity index 100%
rename from vendor/github.com/sdboyer/vsolver/_testdata/src/m1p/b.go
rename to vendor/github.com/sdboyer/gps/_testdata/src/m1p/b.go
diff --git a/vendor/github.com/sdboyer/gps/_testdata/src/missing/a.go b/vendor/github.com/sdboyer/gps/_testdata/src/missing/a.go
new file mode 100644
index 0000000..8522bdd
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/_testdata/src/missing/a.go
@@ -0,0 +1,14 @@
+package simple
+
+import (
+ "sort"
+
+ "missing/missing"
+ "github.com/sdboyer/gps"
+)
+
+var (
+ _ = sort.Strings
+ _ = gps.Solve
+ _ = missing.Foo
+)
diff --git a/vendor/github.com/sdboyer/gps/_testdata/src/missing/m1p/a.go b/vendor/github.com/sdboyer/gps/_testdata/src/missing/m1p/a.go
new file mode 100644
index 0000000..ec1f9b9
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/_testdata/src/missing/m1p/a.go
@@ -0,0 +1,12 @@
+package m1p
+
+import (
+ "sort"
+
+ "github.com/sdboyer/gps"
+)
+
+var (
+ _ = sort.Strings
+ _ = gps.Solve
+)
diff --git a/vendor/github.com/sdboyer/vsolver/_testdata/src/m1p/b.go b/vendor/github.com/sdboyer/gps/_testdata/src/missing/m1p/b.go
similarity index 100%
copy from vendor/github.com/sdboyer/vsolver/_testdata/src/m1p/b.go
copy to vendor/github.com/sdboyer/gps/_testdata/src/missing/m1p/b.go
diff --git a/vendor/github.com/sdboyer/gps/_testdata/src/nest/a.go b/vendor/github.com/sdboyer/gps/_testdata/src/nest/a.go
new file mode 100644
index 0000000..300b730
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/_testdata/src/nest/a.go
@@ -0,0 +1,12 @@
+package simple
+
+import (
+ "sort"
+
+ "github.com/sdboyer/gps"
+)
+
+var (
+ _ = sort.Strings
+ _ = gps.Solve
+)
diff --git a/vendor/github.com/sdboyer/gps/_testdata/src/nest/m1p/a.go b/vendor/github.com/sdboyer/gps/_testdata/src/nest/m1p/a.go
new file mode 100644
index 0000000..ec1f9b9
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/_testdata/src/nest/m1p/a.go
@@ -0,0 +1,12 @@
+package m1p
+
+import (
+ "sort"
+
+ "github.com/sdboyer/gps"
+)
+
+var (
+ _ = sort.Strings
+ _ = gps.Solve
+)
diff --git a/vendor/github.com/sdboyer/vsolver/_testdata/src/nest/m1p/b.go b/vendor/github.com/sdboyer/gps/_testdata/src/nest/m1p/b.go
similarity index 100%
rename from vendor/github.com/sdboyer/vsolver/_testdata/src/nest/m1p/b.go
rename to vendor/github.com/sdboyer/gps/_testdata/src/nest/m1p/b.go
diff --git a/vendor/github.com/sdboyer/gps/_testdata/src/ren/m1p/a.go b/vendor/github.com/sdboyer/gps/_testdata/src/ren/m1p/a.go
new file mode 100644
index 0000000..ec1f9b9
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/_testdata/src/ren/m1p/a.go
@@ -0,0 +1,12 @@
+package m1p
+
+import (
+ "sort"
+
+ "github.com/sdboyer/gps"
+)
+
+var (
+ _ = sort.Strings
+ _ = gps.Solve
+)
diff --git a/vendor/github.com/sdboyer/vsolver/_testdata/src/ren/m1p/b.go b/vendor/github.com/sdboyer/gps/_testdata/src/ren/m1p/b.go
similarity index 100%
rename from vendor/github.com/sdboyer/vsolver/_testdata/src/ren/m1p/b.go
rename to vendor/github.com/sdboyer/gps/_testdata/src/ren/m1p/b.go
diff --git a/vendor/github.com/sdboyer/gps/_testdata/src/ren/simple/a.go b/vendor/github.com/sdboyer/gps/_testdata/src/ren/simple/a.go
new file mode 100644
index 0000000..300b730
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/_testdata/src/ren/simple/a.go
@@ -0,0 +1,12 @@
+package simple
+
+import (
+ "sort"
+
+ "github.com/sdboyer/gps"
+)
+
+var (
+ _ = sort.Strings
+ _ = gps.Solve
+)
diff --git a/vendor/github.com/sdboyer/gps/_testdata/src/simple/a.go b/vendor/github.com/sdboyer/gps/_testdata/src/simple/a.go
new file mode 100644
index 0000000..300b730
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/_testdata/src/simple/a.go
@@ -0,0 +1,12 @@
+package simple
+
+import (
+ "sort"
+
+ "github.com/sdboyer/gps"
+)
+
+var (
+ _ = sort.Strings
+ _ = gps.Solve
+)
diff --git a/vendor/github.com/sdboyer/gps/_testdata/src/simpleallt/a.go b/vendor/github.com/sdboyer/gps/_testdata/src/simpleallt/a.go
new file mode 100644
index 0000000..300b730
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/_testdata/src/simpleallt/a.go
@@ -0,0 +1,12 @@
+package simple
+
+import (
+ "sort"
+
+ "github.com/sdboyer/gps"
+)
+
+var (
+ _ = sort.Strings
+ _ = gps.Solve
+)
diff --git a/vendor/github.com/sdboyer/vsolver/_testdata/src/simpleallt/a_test.go b/vendor/github.com/sdboyer/gps/_testdata/src/simpleallt/a_test.go
similarity index 100%
rename from vendor/github.com/sdboyer/vsolver/_testdata/src/simpleallt/a_test.go
rename to vendor/github.com/sdboyer/gps/_testdata/src/simpleallt/a_test.go
diff --git a/vendor/github.com/sdboyer/vsolver/_testdata/src/simpleallt/t_test.go b/vendor/github.com/sdboyer/gps/_testdata/src/simpleallt/t_test.go
similarity index 100%
rename from vendor/github.com/sdboyer/vsolver/_testdata/src/simpleallt/t_test.go
rename to vendor/github.com/sdboyer/gps/_testdata/src/simpleallt/t_test.go
diff --git a/vendor/github.com/sdboyer/gps/_testdata/src/simplet/a.go b/vendor/github.com/sdboyer/gps/_testdata/src/simplet/a.go
new file mode 100644
index 0000000..300b730
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/_testdata/src/simplet/a.go
@@ -0,0 +1,12 @@
+package simple
+
+import (
+ "sort"
+
+ "github.com/sdboyer/gps"
+)
+
+var (
+ _ = sort.Strings
+ _ = gps.Solve
+)
diff --git a/vendor/github.com/sdboyer/vsolver/_testdata/src/simplet/t_test.go b/vendor/github.com/sdboyer/gps/_testdata/src/simplet/t_test.go
similarity index 100%
rename from vendor/github.com/sdboyer/vsolver/_testdata/src/simplet/t_test.go
rename to vendor/github.com/sdboyer/gps/_testdata/src/simplet/t_test.go
diff --git a/vendor/github.com/sdboyer/gps/_testdata/src/simplext/a.go b/vendor/github.com/sdboyer/gps/_testdata/src/simplext/a.go
new file mode 100644
index 0000000..300b730
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/_testdata/src/simplext/a.go
@@ -0,0 +1,12 @@
+package simple
+
+import (
+ "sort"
+
+ "github.com/sdboyer/gps"
+)
+
+var (
+ _ = sort.Strings
+ _ = gps.Solve
+)
diff --git a/vendor/github.com/sdboyer/vsolver/_testdata/src/simplext/a_test.go b/vendor/github.com/sdboyer/gps/_testdata/src/simplext/a_test.go
similarity index 100%
rename from vendor/github.com/sdboyer/vsolver/_testdata/src/simplext/a_test.go
rename to vendor/github.com/sdboyer/gps/_testdata/src/simplext/a_test.go
diff --git a/vendor/github.com/sdboyer/vsolver/_testdata/src/t/t_test.go b/vendor/github.com/sdboyer/gps/_testdata/src/t/t_test.go
similarity index 100%
rename from vendor/github.com/sdboyer/vsolver/_testdata/src/t/t_test.go
rename to vendor/github.com/sdboyer/gps/_testdata/src/t/t_test.go
diff --git a/vendor/github.com/sdboyer/gps/_testdata/src/twopkgs/a.go b/vendor/github.com/sdboyer/gps/_testdata/src/twopkgs/a.go
new file mode 100644
index 0000000..300b730
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/_testdata/src/twopkgs/a.go
@@ -0,0 +1,12 @@
+package simple
+
+import (
+ "sort"
+
+ "github.com/sdboyer/gps"
+)
+
+var (
+ _ = sort.Strings
+ _ = gps.Solve
+)
diff --git a/vendor/github.com/sdboyer/vsolver/_testdata/src/twopkgs/b.go b/vendor/github.com/sdboyer/gps/_testdata/src/twopkgs/b.go
similarity index 100%
rename from vendor/github.com/sdboyer/vsolver/_testdata/src/twopkgs/b.go
rename to vendor/github.com/sdboyer/gps/_testdata/src/twopkgs/b.go
diff --git a/vendor/github.com/sdboyer/vsolver/_testdata/src/varied/locals.go b/vendor/github.com/sdboyer/gps/_testdata/src/varied/locals.go
similarity index 80%
rename from vendor/github.com/sdboyer/vsolver/_testdata/src/varied/locals.go
rename to vendor/github.com/sdboyer/gps/_testdata/src/varied/locals.go
index 3f73943..5c7e6c7 100644
--- a/vendor/github.com/sdboyer/vsolver/_testdata/src/varied/locals.go
+++ b/vendor/github.com/sdboyer/gps/_testdata/src/varied/locals.go
@@ -1,13 +1,13 @@
package main
import (
- "varied/otherpath"
"varied/namemismatch"
+ "varied/otherpath"
"varied/simple"
)
var (
- _ = simple.S
- _ = nm.V
+ _ = simple.S
+ _ = nm.V
_ = otherpath.O
)
diff --git a/vendor/github.com/sdboyer/gps/_testdata/src/varied/m1p/a.go b/vendor/github.com/sdboyer/gps/_testdata/src/varied/m1p/a.go
new file mode 100644
index 0000000..65fd7ca
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/_testdata/src/varied/m1p/a.go
@@ -0,0 +1,12 @@
+package m1p
+
+import (
+ "sort"
+
+ "github.com/sdboyer/gps"
+)
+
+var (
+ M = sort.Strings
+ _ = gps.Solve
+)
diff --git a/vendor/github.com/sdboyer/vsolver/_testdata/src/varied/m1p/b.go b/vendor/github.com/sdboyer/gps/_testdata/src/varied/m1p/b.go
similarity index 100%
rename from vendor/github.com/sdboyer/vsolver/_testdata/src/varied/m1p/b.go
rename to vendor/github.com/sdboyer/gps/_testdata/src/varied/m1p/b.go
diff --git a/vendor/github.com/sdboyer/vsolver/_testdata/src/varied/main.go b/vendor/github.com/sdboyer/gps/_testdata/src/varied/main.go
similarity index 100%
rename from vendor/github.com/sdboyer/vsolver/_testdata/src/varied/main.go
rename to vendor/github.com/sdboyer/gps/_testdata/src/varied/main.go
diff --git a/vendor/github.com/sdboyer/vsolver/_testdata/src/varied/namemismatch/nm.go b/vendor/github.com/sdboyer/gps/_testdata/src/varied/namemismatch/nm.go
similarity index 100%
rename from vendor/github.com/sdboyer/vsolver/_testdata/src/varied/namemismatch/nm.go
rename to vendor/github.com/sdboyer/gps/_testdata/src/varied/namemismatch/nm.go
diff --git a/vendor/github.com/sdboyer/vsolver/_testdata/src/varied/otherpath/otherpath_test.go b/vendor/github.com/sdboyer/gps/_testdata/src/varied/otherpath/otherpath_test.go
similarity index 100%
rename from vendor/github.com/sdboyer/vsolver/_testdata/src/varied/otherpath/otherpath_test.go
rename to vendor/github.com/sdboyer/gps/_testdata/src/varied/otherpath/otherpath_test.go
diff --git a/vendor/github.com/sdboyer/vsolver/_testdata/src/varied/simple/another/another.go b/vendor/github.com/sdboyer/gps/_testdata/src/varied/simple/another/another.go
similarity index 100%
rename from vendor/github.com/sdboyer/vsolver/_testdata/src/varied/simple/another/another.go
rename to vendor/github.com/sdboyer/gps/_testdata/src/varied/simple/another/another.go
diff --git a/vendor/github.com/sdboyer/vsolver/_testdata/src/varied/simple/another/another_test.go b/vendor/github.com/sdboyer/gps/_testdata/src/varied/simple/another/another_test.go
similarity index 100%
rename from vendor/github.com/sdboyer/vsolver/_testdata/src/varied/simple/another/another_test.go
rename to vendor/github.com/sdboyer/gps/_testdata/src/varied/simple/another/another_test.go
diff --git a/vendor/github.com/sdboyer/vsolver/_testdata/src/varied/simple/another/locals.go b/vendor/github.com/sdboyer/gps/_testdata/src/varied/simple/another/locals.go
similarity index 100%
rename from vendor/github.com/sdboyer/vsolver/_testdata/src/varied/simple/another/locals.go
rename to vendor/github.com/sdboyer/gps/_testdata/src/varied/simple/another/locals.go
diff --git a/vendor/github.com/sdboyer/vsolver/_testdata/src/varied/simple/locals.go b/vendor/github.com/sdboyer/gps/_testdata/src/varied/simple/locals.go
similarity index 77%
rename from vendor/github.com/sdboyer/vsolver/_testdata/src/varied/simple/locals.go
rename to vendor/github.com/sdboyer/gps/_testdata/src/varied/simple/locals.go
index 7717e80..6ebb90f 100644
--- a/vendor/github.com/sdboyer/vsolver/_testdata/src/varied/simple/locals.go
+++ b/vendor/github.com/sdboyer/gps/_testdata/src/varied/simple/locals.go
@@ -3,5 +3,5 @@
import "varied/simple/another"
var (
- _ = another.H
+ _ = another.H
)
diff --git a/vendor/github.com/sdboyer/gps/_testdata/src/varied/simple/simple.go b/vendor/github.com/sdboyer/gps/_testdata/src/varied/simple/simple.go
new file mode 100644
index 0000000..c8fbb05
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/_testdata/src/varied/simple/simple.go
@@ -0,0 +1,12 @@
+package simple
+
+import (
+ "go/parser"
+
+ "github.com/sdboyer/gps"
+)
+
+var (
+ _ = parser.ParseFile
+ S = gps.Prepare
+)
diff --git a/vendor/github.com/sdboyer/vsolver/_testdata/src/xt/a_test.go b/vendor/github.com/sdboyer/gps/_testdata/src/xt/a_test.go
similarity index 100%
rename from vendor/github.com/sdboyer/vsolver/_testdata/src/xt/a_test.go
rename to vendor/github.com/sdboyer/gps/_testdata/src/xt/a_test.go
diff --git a/vendor/github.com/sdboyer/gps/analysis.go b/vendor/github.com/sdboyer/gps/analysis.go
new file mode 100644
index 0000000..0cb93ba
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/analysis.go
@@ -0,0 +1,950 @@
+package gps
+
+import (
+ "bytes"
+ "fmt"
+ "go/build"
+ "io"
+ "io/ioutil"
+ "os"
+ "path/filepath"
+ "sort"
+ "strings"
+ "text/scanner"
+)
+
+var osList []string
+var archList []string
+var stdlib = make(map[string]bool)
+
+const stdlibPkgs string = "archive archive/tar archive/zip bufio builtin bytes compress compress/bzip2 compress/flate compress/gzip compress/lzw compress/zlib container container/heap container/list container/ring context crypto crypto/aes crypto/cipher crypto/des crypto/dsa crypto/ecdsa crypto/elliptic crypto/hmac crypto/md5 crypto/rand crypto/rc4 crypto/rsa crypto/sha1 crypto/sha256 crypto/sha512 crypto/subtle crypto/tls crypto/x509 crypto/x509/pkix database database/sql database/sql/driver debug debug/dwarf debug/elf debug/gosym debug/macho debug/pe debug/plan9obj encoding encoding/ascii85 encoding/asn1 encoding/base32 encoding/base64 encoding/binary encoding/csv encoding/gob encoding/hex encoding/json encoding/pem encoding/xml errors expvar flag fmt go go/ast go/build go/constant go/doc go/format go/importer go/parser go/printer go/scanner go/token go/types hash hash/adler32 hash/crc32 hash/crc64 hash/fnv html html/template image image/color image/color/palette image/draw image/gif image/jpeg image/png index index/suffixarray io io/ioutil log log/syslog math math/big math/cmplx math/rand mime mime/multipart mime/quotedprintable net net/http net/http/cgi net/http/cookiejar net/http/fcgi net/http/httptest net/http/httputil net/http/pprof net/mail net/rpc net/rpc/jsonrpc net/smtp net/textproto net/url os os/exec os/signal os/user path path/filepath reflect regexp regexp/syntax runtime runtime/cgo runtime/debug runtime/msan runtime/pprof runtime/race runtime/trace sort strconv strings sync sync/atomic syscall testing testing/iotest testing/quick text text/scanner text/tabwriter text/template text/template/parse time unicode unicode/utf16 unicode/utf8 unsafe"
+
+// Before appengine moved to google.golang.org/appengine, it had a magic
+// stdlib-like import path. We have to ignore all of these.
+const appenginePkgs string = "appengine/aetest appengine/blobstore appengine/capability appengine/channel appengine/cloudsql appengine/cmd appengine/cmd/aebundler appengine/cmd/aedeploy appengine/cmd/aefix appengine/datastore appengine/delay appengine/demos appengine/demos/guestbook appengine/demos/guestbook/templates appengine/demos/helloworld appengine/file appengine/image appengine/internal appengine/internal/aetesting appengine/internal/app_identity appengine/internal/base appengine/internal/blobstore appengine/internal/capability appengine/internal/channel appengine/internal/datastore appengine/internal/image appengine/internal/log appengine/internal/mail appengine/internal/memcache appengine/internal/modules appengine/internal/remote_api appengine/internal/search appengine/internal/socket appengine/internal/system appengine/internal/taskqueue appengine/internal/urlfetch appengine/internal/user appengine/internal/xmpp appengine/log appengine/mail appengine/memcache appengine/module appengine/remote_api appengine/runtime appengine/search appengine/socket appengine/taskqueue appengine/urlfetch appengine/user appengine/xmpp"
+
+func init() {
+ // The supported systems are listed in
+ // https://github.com/golang/go/blob/master/src/go/build/syslist.go
+ // The lists are not exported so we need to duplicate them here.
+ osListString := "android darwin dragonfly freebsd linux nacl netbsd openbsd plan9 solaris windows"
+ osList = strings.Split(osListString, " ")
+
+ archListString := "386 amd64 amd64p32 arm armbe arm64 arm64be ppc64 ppc64le mips mipsle mips64 mips64le mips64p32 mips64p32le ppc s390 s390x sparc sparc64"
+ archList = strings.Split(archListString, " ")
+
+ for _, pkg := range strings.Split(stdlibPkgs, " ") {
+ stdlib[pkg] = true
+ }
+ for _, pkg := range strings.Split(appenginePkgs, " ") {
+ stdlib[pkg] = true
+ }
+
+ // Also ignore C
+ // TODO(sdboyer) actually figure out how to deal with cgo
+ stdlib["C"] = true
+}
+
+// listPackages lists info for all packages at or below the provided fileRoot.
+//
+// Directories without any valid Go files are excluded. Directories with
+// multiple packages are excluded.
+//
+// The importRoot parameter is prepended to the relative path when determining
+// the import path for each package. The obvious case is for something typical,
+// like:
+//
+// fileRoot = "/home/user/go/src/github.com/foo/bar"
+// importRoot = "github.com/foo/bar"
+//
+// where the fileRoot and importRoot align. However, if you provide:
+//
+// fileRoot = "/home/user/workspace/path/to/repo"
+// importRoot = "github.com/foo/bar"
+//
+// then the root package at path/to/repo will be ascribed import path
+// "github.com/foo/bar", and its subpackage "baz" will be
+// "github.com/foo/bar/baz".
+//
+// A PackageTree is returned, which contains the ImportRoot and map of import path
+// to PackageOrErr - each path under the root that exists will have either a
+// Package, or an error describing why the directory is not a valid package.
+func listPackages(fileRoot, importRoot string) (PackageTree, error) {
+ // Set up a build.ctx for parsing
+ ctx := build.Default
+ ctx.GOROOT = ""
+ ctx.GOPATH = ""
+ ctx.UseAllFiles = true
+
+ ptree := PackageTree{
+ ImportRoot: importRoot,
+ Packages: make(map[string]PackageOrErr),
+ }
+
+ // mkfilter returns two funcs that can be injected into a build.Context,
+ // letting us filter the results into an "in" and "out" set.
+ mkfilter := func(files map[string]struct{}) (in, out func(dir string) (fi []os.FileInfo, err error)) {
+ in = func(dir string) (fi []os.FileInfo, err error) {
+ all, err := ioutil.ReadDir(dir)
+ if err != nil {
+ return nil, err
+ }
+
+ for _, f := range all {
+ if _, exists := files[f.Name()]; exists {
+ fi = append(fi, f)
+ }
+ }
+ return fi, nil
+ }
+
+ out = func(dir string) (fi []os.FileInfo, err error) {
+ all, err := ioutil.ReadDir(dir)
+ if err != nil {
+ return nil, err
+ }
+
+ for _, f := range all {
+ if _, exists := files[f.Name()]; !exists {
+ fi = append(fi, f)
+ }
+ }
+ return fi, nil
+ }
+
+ return
+ }
+
+ // helper func to create a Package from a *build.Package
+ happy := func(importPath string, p *build.Package) Package {
+ // Happy path - simple parsing worked
+ pkg := Package{
+ ImportPath: importPath,
+ CommentPath: p.ImportComment,
+ Name: p.Name,
+ Imports: p.Imports,
+ TestImports: dedupeStrings(p.TestImports, p.XTestImports),
+ }
+
+ return pkg
+ }
+
+ err := filepath.Walk(fileRoot, func(path string, fi os.FileInfo, err error) error {
+ if err != nil && err != filepath.SkipDir {
+ return err
+ }
+ if !fi.IsDir() {
+ return nil
+ }
+
+ // Skip dirs that are known to hold non-local/dependency code.
+ //
+ // We don't skip _*, or testdata dirs because, while it may be poor
+ // form, importing them is not a compilation error.
+ switch fi.Name() {
+ case "vendor", "Godeps":
+ return filepath.SkipDir
+ }
+ // We do skip dot-dirs, though, because it's such a ubiquitous standard
+ // that they not be visited by normal commands, and because things get
+ // really weird if we don't.
+ //
+ // TODO(sdboyer) does this entail that we should chuck dot-led import
+ // paths later on?
+ if strings.HasPrefix(fi.Name(), ".") {
+ return filepath.SkipDir
+ }
+
+ // Compute the import path. Run the result through ToSlash(), so that windows
+ // paths are normalized to Unix separators, as import paths are expected
+ // to be.
+ ip := filepath.ToSlash(filepath.Join(importRoot, strings.TrimPrefix(path, fileRoot)))
+
+ // Find all the imports, across all os/arch combos
+ p, err := ctx.ImportDir(path, analysisImportMode())
+ var pkg Package
+ if err == nil {
+ pkg = happy(ip, p)
+ } else {
+ switch terr := err.(type) {
+ case *build.NoGoError:
+ ptree.Packages[ip] = PackageOrErr{
+ Err: err,
+ }
+ return nil
+ case *build.MultiplePackageError:
+ // Set this up preemptively, so we can easily just return out if
+ // something goes wrong. Otherwise, it'll get transparently
+ // overwritten later.
+ ptree.Packages[ip] = PackageOrErr{
+ Err: err,
+ }
+
+ // For now, we're punting entirely on dealing with os/arch
+ // combinations. That will be a more significant refactor.
+ //
+ // However, there is one case we want to allow here - one or
+ // more files with "+build ignore" with package `main`. (Ignore
+ // is just a convention, but for now it's good enough to just
+ // check that.) This is a fairly common way to give examples,
+ // and to make a more sophisticated build system than a Makefile
+ // allows, so we want to support that case. So, transparently
+ // lump the deps together.
+ mains := make(map[string]struct{})
+ for k, pkgname := range terr.Packages {
+ if pkgname == "main" {
+ tags, err2 := readFileBuildTags(filepath.Join(path, terr.Files[k]))
+ if err2 != nil {
+ return nil
+ }
+
+ var hasignore bool
+ for _, t := range tags {
+ if t == "ignore" {
+ hasignore = true
+ break
+ }
+ }
+ if !hasignore {
+ // No ignore tag found - bail out
+ return nil
+ }
+ mains[terr.Files[k]] = struct{}{}
+ }
+ }
+ // Make filtering funcs that will let us look only at the main
+ // files, and exclude the main files; inf and outf, respectively
+ inf, outf := mkfilter(mains)
+
+ // outf first; if there's another err there, we bail out with a
+ // return
+ ctx.ReadDir = outf
+ po, err2 := ctx.ImportDir(path, analysisImportMode())
+ if err2 != nil {
+ return nil
+ }
+ ctx.ReadDir = inf
+ pi, err2 := ctx.ImportDir(path, analysisImportMode())
+ if err2 != nil {
+ return nil
+ }
+ ctx.ReadDir = nil
+
+ // Use the other files as baseline, they're the main stuff
+ pkg = happy(ip, po)
+ mpkg := happy(ip, pi)
+ pkg.Imports = dedupeStrings(pkg.Imports, mpkg.Imports)
+ pkg.TestImports = dedupeStrings(pkg.TestImports, mpkg.TestImports)
+ default:
+ return err
+ }
+ }
+
+ // This area has some...fuzzy rules, but check all the imports for
+ // local/relative/dot-ness, and record an error for the package if we
+ // see any.
+ var lim []string
+ for _, imp := range append(pkg.Imports, pkg.TestImports...) {
+ switch {
+ // Do allow the single-dot, at least for now
+ case imp == "..":
+ lim = append(lim, imp)
+ // ignore stdlib done this way, b/c that's what the go tooling does
+ case strings.HasPrefix(imp, "./"):
+ if stdlib[imp[2:]] {
+ lim = append(lim, imp)
+ }
+ case strings.HasPrefix(imp, "../"):
+ if stdlib[imp[3:]] {
+ lim = append(lim, imp)
+ }
+ }
+ }
+
+ if len(lim) > 0 {
+ ptree.Packages[ip] = PackageOrErr{
+ Err: &LocalImportsError{
+ Dir: ip,
+ LocalImports: lim,
+ },
+ }
+ } else {
+ ptree.Packages[ip] = PackageOrErr{
+ P: pkg,
+ }
+ }
+
+ return nil
+ })
+
+ if err != nil {
+ return PackageTree{}, err
+ }
+
+ return ptree, nil
+}
+
+// LocalImportsError indicates that a package contains at least one relative
+// import that will prevent it from compiling.
+//
+// TODO(sdboyer) add a Files property once we're doing our own per-file parsing
+type LocalImportsError struct {
+ Dir string
+ LocalImports []string
+}
+
+func (e *LocalImportsError) Error() string {
+ return fmt.Sprintf("import path %s had problematic local imports", e.Dir)
+}
+
+type wm struct {
+ err error
+ ex map[string]bool
+ in map[string]bool
+}
+
+// wmToReach takes an externalReach()-style workmap and transitively walks all
+// internal imports until they reach an external path or terminate, then
+// translates the results into a slice of external imports for each internal
+// pkg.
+//
+// The basedir string, with a trailing slash ensured, will be stripped from the
+// keys of the returned map.
+func wmToReach(workmap map[string]wm, basedir string) map[string][]string {
+ // Uses depth-first exploration to compute reachability into external
+ // packages, dropping any internal packages on "poisoned paths" - a path
+ // containing a package with an error, or with a dep on an internal package
+ // that's missing.
+
+ const (
+ white uint8 = iota
+ grey
+ black
+ )
+
+ colors := make(map[string]uint8)
+ allreachsets := make(map[string]map[string]struct{})
+
+ // poison is a helper func to eliminate specific reachsets from allreachsets
+ poison := func(path []string) {
+ for _, ppkg := range path {
+ delete(allreachsets, ppkg)
+ }
+ }
+
+ var dfe func(string, []string) bool
+
+ // dfe is the depth-first-explorer that computes safe, error-free external
+ // reach map.
+ //
+ // pkg is the import path of the pkg currently being visited; path is the
+ // stack of parent packages we've visited to get to pkg. The return value
+ // indicates whether the level completed successfully (true) or if it was
+ // poisoned (false).
+ //
+ // TODO(sdboyer) some deft improvements could probably be made by passing the list of
+ // parent reachsets, rather than a list of parent package string names.
+ // might be able to eliminate the use of allreachsets map-of-maps entirely.
+ dfe = func(pkg string, path []string) bool {
+ // white is the zero value of uint8, which is what we want if the pkg
+ // isn't in the colors map, so this works fine
+ switch colors[pkg] {
+ case white:
+ // first visit to this pkg; mark it as in-process (grey)
+ colors[pkg] = grey
+
+ // make sure it's present and w/out errs
+ w, exists := workmap[pkg]
+ if !exists || w.err != nil {
+ // Does not exist or has an err; poison self and all parents
+ poison(path)
+
+ // we know we're done here, so mark it black
+ colors[pkg] = black
+ return false
+ }
+ // pkg exists with no errs. mark it as in-process (grey), and start
+ // a reachmap for it
+ //
+ // TODO(sdboyer) use sync.Pool here? can be lots of explicit map alloc/dealloc
+ rs := make(map[string]struct{})
+
+ // Push self onto the path slice. Passing this as a value has the
+ // effect of auto-popping the slice, while also giving us safe
+ // memory reuse.
+ path = append(path, pkg)
+
+ // Dump this package's external pkgs into its own reachset. Separate
+ // loop from the parent dump to avoid nested map loop lookups.
+ for ex := range w.ex {
+ rs[ex] = struct{}{}
+ }
+ allreachsets[pkg] = rs
+
+ // Push this pkg's external imports into all parent reachsets. Not
+ // all parents will necessarily have a reachset; none, some, or all
+ // could have been poisoned by a different path than what we're on
+ // right now. (Or we could be at depth 0)
+ for _, ppkg := range path {
+ if prs, exists := allreachsets[ppkg]; exists {
+ for ex := range w.ex {
+ prs[ex] = struct{}{}
+ }
+ }
+ }
+
+ // Now, recurse until done, or a false bubbles up, indicating the
+ // path is poisoned.
+ var clean bool
+ for in := range w.in {
+ // It's possible, albeit weird, for a package to import itself.
+ // If we try to visit self, though, then it erroneously poisons
+ // the path, as it would be interpreted as grey. In reality,
+ // this becomes a no-op, so just skip it.
+ if in == pkg {
+ continue
+ }
+
+ clean = dfe(in, path)
+ if !clean {
+ // Path is poisoned. Our reachmap was already deleted by the
+ // path we're returning from; mark ourselves black, then
+ // bubble up the poison. This is OK to do early, before
+ // exploring all internal imports, because the outer loop
+ // visits all internal packages anyway.
+ //
+ // In fact, stopping early is preferable - white subpackages
+ // won't have to iterate pointlessly through a parent path
+ // with no reachset.
+ colors[pkg] = black
+ return false
+ }
+ }
+
+ // Fully done with this pkg; no transitive problems.
+ colors[pkg] = black
+ return true
+
+ case grey:
+ // grey means an import cycle; guaranteed badness right here.
+ //
+ // FIXME handle import cycles by dropping everything involved. i
+ // think we need to compute SCC, then drop *all* of them?
+ colors[pkg] = black
+ poison(append(path, pkg)) // poison self and parents
+
+ case black:
+ // black means we're done with the package. If it has an entry in
+ // allreachsets, it completed successfully. If not, it was poisoned,
+ // and we need to bubble the poison back up.
+ rs, exists := allreachsets[pkg]
+ if !exists {
+ // just poison parents; self was necessarily already poisoned
+ poison(path)
+ return false
+ }
+
+ // It's good; pull over of the external imports from its reachset
+ // into all non-poisoned parent reachsets
+ for _, ppkg := range path {
+ if prs, exists := allreachsets[ppkg]; exists {
+ for ex := range rs {
+ prs[ex] = struct{}{}
+ }
+ }
+ }
+ return true
+
+ default:
+ panic(fmt.Sprintf("invalid color marker %v for %s", colors[pkg], pkg))
+ }
+
+ // shouldn't ever hit this
+ return false
+ }
+
+ // Run the depth-first exploration.
+ //
+ // Don't bother computing graph sources, this straightforward loop works
+ // comparably well, and fits nicely with an escape hatch in the dfe.
+ var path []string
+ for pkg := range workmap {
+ dfe(pkg, path)
+ }
+
+ if len(allreachsets) == 0 {
+ return nil
+ }
+
+ // Flatten allreachsets into the final reachlist
+ rt := strings.TrimSuffix(basedir, string(os.PathSeparator)) + string(os.PathSeparator)
+ rm := make(map[string][]string)
+ for pkg, rs := range allreachsets {
+ rlen := len(rs)
+ if rlen == 0 {
+ rm[strings.TrimPrefix(pkg, rt)] = nil
+ continue
+ }
+
+ edeps := make([]string, rlen)
+ k := 0
+ for opkg := range rs {
+ edeps[k] = opkg
+ k++
+ }
+
+ sort.Strings(edeps)
+ rm[strings.TrimPrefix(pkg, rt)] = edeps
+ }
+
+ return rm
+}
+
+func readBuildTags(p string) ([]string, error) {
+ _, err := os.Stat(p)
+ if err != nil {
+ return []string{}, err
+ }
+
+ d, err := os.Open(p)
+ if err != nil {
+ return []string{}, err
+ }
+
+ objects, err := d.Readdir(-1)
+ if err != nil {
+ return []string{}, err
+ }
+
+ var tags []string
+ for _, obj := range objects {
+
+ // only process Go files
+ if strings.HasSuffix(obj.Name(), ".go") {
+ fp := filepath.Join(p, obj.Name())
+
+ co, err := readGoContents(fp)
+ if err != nil {
+ return []string{}, err
+ }
+
+ // Only look at places where we had a code comment.
+ if len(co) > 0 {
+ t := findTags(co)
+ for _, tg := range t {
+ found := false
+ for _, tt := range tags {
+ if tt == tg {
+ found = true
+ }
+ }
+ if !found {
+ tags = append(tags, tg)
+ }
+ }
+ }
+ }
+ }
+
+ return tags, nil
+}
+
+func readFileBuildTags(fp string) ([]string, error) {
+ co, err := readGoContents(fp)
+ if err != nil {
+ return []string{}, err
+ }
+
+ var tags []string
+ // Only look at places where we had a code comment.
+ if len(co) > 0 {
+ t := findTags(co)
+ for _, tg := range t {
+ found := false
+ for _, tt := range tags {
+ if tt == tg {
+ found = true
+ }
+ }
+ if !found {
+ tags = append(tags, tg)
+ }
+ }
+ }
+
+ return tags, nil
+}
+
+// Read contents of a Go file up to the package declaration. This can be used
+// to find the the build tags.
+func readGoContents(fp string) ([]byte, error) {
+ f, err := os.Open(fp)
+ defer f.Close()
+ if err != nil {
+ return []byte{}, err
+ }
+
+ var s scanner.Scanner
+ s.Init(f)
+ var tok rune
+ var pos scanner.Position
+ for tok != scanner.EOF {
+ tok = s.Scan()
+
+ // Getting the token text will skip comments by default.
+ tt := s.TokenText()
+ // build tags will not be after the package declaration.
+ if tt == "package" {
+ pos = s.Position
+ break
+ }
+ }
+
+ var buf bytes.Buffer
+ f.Seek(0, 0)
+ _, err = io.CopyN(&buf, f, int64(pos.Offset))
+ if err != nil {
+ return []byte{}, err
+ }
+
+ return buf.Bytes(), nil
+}
+
+// From a byte slice of a Go file find the tags.
+func findTags(co []byte) []string {
+ p := co
+ var tgs []string
+ for len(p) > 0 {
+ line := p
+ if i := bytes.IndexByte(line, '\n'); i >= 0 {
+ line, p = line[:i], p[i+1:]
+ } else {
+ p = p[len(p):]
+ }
+ line = bytes.TrimSpace(line)
+ // Only look at comment lines that are well formed in the Go style
+ if bytes.HasPrefix(line, []byte("//")) {
+ line = bytes.TrimSpace(line[len([]byte("//")):])
+ if len(line) > 0 && line[0] == '+' {
+ f := strings.Fields(string(line))
+
+ // We've found a +build tag line.
+ if f[0] == "+build" {
+ for _, tg := range f[1:] {
+ tgs = append(tgs, tg)
+ }
+ }
+ }
+ }
+ }
+
+ return tgs
+}
+
+// Get an OS value that's not the one passed in.
+func getOsValue(n string) string {
+ for _, o := range osList {
+ if o != n {
+ return o
+ }
+ }
+
+ return n
+}
+
+func isSupportedOs(n string) bool {
+ for _, o := range osList {
+ if o == n {
+ return true
+ }
+ }
+
+ return false
+}
+
+// Get an Arch value that's not the one passed in.
+func getArchValue(n string) string {
+ for _, o := range archList {
+ if o != n {
+ return o
+ }
+ }
+
+ return n
+}
+
+func isSupportedArch(n string) bool {
+ for _, o := range archList {
+ if o == n {
+ return true
+ }
+ }
+
+ return false
+}
+
+func ensureTrailingSlash(s string) string {
+ return strings.TrimSuffix(s, string(os.PathSeparator)) + string(os.PathSeparator)
+}
+
+// helper func to merge, dedupe, and sort strings
+func dedupeStrings(s1, s2 []string) (r []string) {
+ dedupe := make(map[string]bool)
+
+ if len(s1) > 0 && len(s2) > 0 {
+ for _, i := range s1 {
+ dedupe[i] = true
+ }
+ for _, i := range s2 {
+ dedupe[i] = true
+ }
+
+ for i := range dedupe {
+ r = append(r, i)
+ }
+ // And then re-sort them
+ sort.Strings(r)
+ } else if len(s1) > 0 {
+ r = s1
+ } else if len(s2) > 0 {
+ r = s2
+ }
+
+ return
+}
+
+// A PackageTree represents the results of recursively parsing a tree of
+// packages, starting at the ImportRoot. The results of parsing the files in the
+// directory identified by each import path - a Package or an error - are stored
+// in the Packages map, keyed by that import path.
+type PackageTree struct {
+ ImportRoot string
+ Packages map[string]PackageOrErr
+}
+
+// PackageOrErr stores the results of attempting to parse a single directory for
+// Go source code.
+type PackageOrErr struct {
+ P Package
+ Err error
+}
+
+// ExternalReach looks through a PackageTree and computes the list of external
+// packages (not logical children of PackageTree.ImportRoot) that are
+// transitively imported by the internal packages in the tree.
+//
+// main indicates whether (true) or not (false) to include main packages in the
+// analysis. main packages are generally excluded when analyzing anything other
+// than the root project, as they inherently can't be imported.
+//
+// tests indicates whether (true) or not (false) to include imports from test
+// files in packages when computing the reach map.
+//
+// ignore is a map of import paths that, if encountered, should be excluded from
+// analysis. This exclusion applies to both internal and external packages. If
+// an external import path is ignored, it is simply omitted from the results.
+//
+// If an internal path is ignored, then it is excluded from all transitive
+// dependency chains and does not appear as a key in the final map. That is, if
+// you ignore A/foo, then the external package list for all internal packages
+// that import A/foo will not include external packages that are only reachable
+// through A/foo.
+//
+// Visually, this means that, given a PackageTree with root A and packages at A,
+// A/foo, and A/bar, and the following import chain:
+//
+// A -> A/foo -> A/bar -> B/baz
+//
+// If you ignore A/foo, then the returned map would be:
+//
+// map[string][]string{
+// "A": []string{},
+// "A/bar": []string{"B/baz"},
+// }
+//
+// It is safe to pass a nil map if there are no packages to ignore.
+func (t PackageTree) ExternalReach(main, tests bool, ignore map[string]bool) map[string][]string {
+ if ignore == nil {
+ ignore = make(map[string]bool)
+ }
+
+ // world's simplest adjacency list
+ workmap := make(map[string]wm)
+
+ var imps []string
+ for ip, perr := range t.Packages {
+ if perr.Err != nil {
+ workmap[ip] = wm{
+ err: perr.Err,
+ }
+ continue
+ }
+ p := perr.P
+
+ // Skip main packages, unless param says otherwise
+ if p.Name == "main" && !main {
+ continue
+ }
+ // Skip ignored packages
+ if ignore[ip] {
+ continue
+ }
+
+ imps = imps[:0]
+ imps = p.Imports
+ if tests {
+ imps = dedupeStrings(imps, p.TestImports)
+ }
+
+ w := wm{
+ ex: make(map[string]bool),
+ in: make(map[string]bool),
+ }
+
+ for _, imp := range imps {
+ // Skip ignored imports
+ if ignore[imp] {
+ continue
+ }
+
+ if !checkPrefixSlash(filepath.Clean(imp), t.ImportRoot) {
+ w.ex[imp] = true
+ } else {
+ if w2, seen := workmap[imp]; seen {
+ for i := range w2.ex {
+ w.ex[i] = true
+ }
+ for i := range w2.in {
+ w.in[i] = true
+ }
+ } else {
+ w.in[imp] = true
+ }
+ }
+ }
+
+ workmap[ip] = w
+ }
+
+ //return wmToReach(workmap, t.ImportRoot)
+ return wmToReach(workmap, "") // TODO(sdboyer) this passes tests, but doesn't seem right
+}
+
+// ListExternalImports computes a sorted, deduplicated list of all the external
+// packages that are reachable through imports from all valid packages in the
+// PackageTree.
+//
+// main and tests determine whether main packages and test imports should be
+// included in the calculation. "External" is defined as anything not prefixed,
+// after path cleaning, by the PackageTree.ImportRoot. This includes stdlib.
+//
+// If an internal path is ignored, all of the external packages that it uniquely
+// imports are omitted. Note, however, that no internal transitivity checks are
+// made here - every non-ignored package in the tree is considered independently
+// (with one set of exceptions, noted below). That means, given a PackageTree
+// with root A and packages at A, A/foo, and A/bar, and the following import
+// chain:
+//
+// A -> A/foo -> A/bar -> B/baz
+//
+// If you ignore A or A/foo, A/bar will still be visited, and B/baz will be
+// returned, because this method visits ALL packages in the tree, not only those reachable
+// from the root (or any other) packages. If your use case requires interrogating
+// external imports with respect to only specific package entry points, you need
+// ExternalReach() instead.
+//
+// It is safe to pass a nil map if there are no packages to ignore.
+//
+// If an internal package has an error (that is, PackageOrErr is Err), it is excluded from
+// consideration. Internal packages that transitively import the error package
+// are also excluded. So, if:
+//
+// -> B/foo
+// /
+// A
+// \
+// -> A/bar -> B/baz
+//
+// And A/bar has some error in it, then both A and A/bar will be eliminated from
+// consideration; neither B/foo nor B/baz will be in the results. If A/bar, with
+// its errors, is ignored, however, then A will remain, and B/foo will be in the
+// results.
+//
+// Finally, note that if a directory is named "testdata", or has a leading dot
+// or underscore, it will not be directly analyzed as a source. This is in
+// keeping with Go tooling conventions that such directories should be ignored.
+// So, if:
+//
+// A -> B/foo
+// A/.bar -> B/baz
+// A/_qux -> B/baz
+// A/testdata -> B/baz
+//
+// Then B/foo will be returned, but B/baz will not, because all three of the
+// packages that import it are in directories with disallowed names.
+//
+// HOWEVER, in keeping with the Go compiler, if one of those packages in a
+// disallowed directory is imported by a package in an allowed directory, then
+// it *will* be used. That is, while tools like go list will ignore a directory
+// named .foo, you can still import from .foo. Thus, it must be included. So,
+// if:
+//
+// -> B/foo
+// /
+// A
+// \
+// -> A/.bar -> B/baz
+//
+// A is legal, and it imports A/.bar, so the results will include B/baz.
+func (t PackageTree) ListExternalImports(main, tests bool, ignore map[string]bool) []string {
+ // First, we need a reachmap
+ rm := t.ExternalReach(main, tests, ignore)
+
+ exm := make(map[string]struct{})
+ for pkg, reach := range rm {
+ // Eliminate import paths with any elements having leading dots, leading
+ // underscores, or testdata. If these are internally reachable (which is
+ // a no-no, but possible), any external imports will have already been
+ // pulled up through ExternalReach. The key here is that we don't want
+ // to treat such packages as themselves being sources.
+ //
+ // TODO(sdboyer) strings.Split will always heap alloc, which isn't great to do
+ // in a loop like this. We could also just parse it ourselves...
+ var skip bool
+ for _, elem := range strings.Split(pkg, "/") {
+ if strings.HasPrefix(elem, ".") || strings.HasPrefix(elem, "_") || elem == "testdata" {
+ skip = true
+ break
+ }
+ }
+
+ if !skip {
+ for _, ex := range reach {
+ exm[ex] = struct{}{}
+ }
+ }
+ }
+
+ if len(exm) == 0 {
+ return nil
+ }
+
+ ex := make([]string, len(exm))
+ k := 0
+ for p := range exm {
+ ex[k] = p
+ k++
+ }
+
+ sort.Strings(ex)
+ return ex
+}
+
+// checkPrefixSlash checks to see if the prefix is a prefix of the string as-is,
+// and that it is either equal OR the prefix + / is still a prefix.
+func checkPrefixSlash(s, prefix string) bool {
+ if !strings.HasPrefix(s, prefix) {
+ return false
+ }
+ return s == prefix || strings.HasPrefix(s, ensureTrailingSlash(prefix))
+}
diff --git a/vendor/github.com/sdboyer/vsolver/analysis_test.go b/vendor/github.com/sdboyer/gps/analysis_test.go
similarity index 67%
rename from vendor/github.com/sdboyer/vsolver/analysis_test.go
rename to vendor/github.com/sdboyer/gps/analysis_test.go
index 4abb537..210d036 100644
--- a/vendor/github.com/sdboyer/vsolver/analysis_test.go
+++ b/vendor/github.com/sdboyer/gps/analysis_test.go
@@ -1,6 +1,7 @@
-package vsolver
+package gps
import (
+ "fmt"
"go/build"
"os"
"path/filepath"
@@ -9,23 +10,21 @@
"testing"
)
-// externalReach() uses an easily separable algorithm, wmToReach(), to turn a
-// discovered set of packages and their imports into a proper external reach
-// map.
+// PackageTree.ExternalReach() uses an easily separable algorithm, wmToReach(),
+// to turn a discovered set of packages and their imports into a proper external
+// reach map.
//
// That algorithm is purely symbolic (no filesystem interaction), and thus is
// easy to test. This is that test.
func TestWorkmapToReach(t *testing.T) {
- empty := func() map[string]struct{} {
- return make(map[string]struct{})
+ empty := func() map[string]bool {
+ return make(map[string]bool)
}
table := map[string]struct {
- name string
workmap map[string]wm
basedir string
out map[string][]string
- err error
}{
"single": {
workmap: map[string]wm{
@@ -58,8 +57,8 @@
workmap: map[string]wm{
"foo": {
ex: empty(),
- in: map[string]struct{}{
- "foo/bar": struct{}{},
+ in: map[string]bool{
+ "foo/bar": true,
},
},
"foo/bar": {
@@ -76,13 +75,13 @@
workmap: map[string]wm{
"foo": {
ex: empty(),
- in: map[string]struct{}{
- "foo/bar": struct{}{},
+ in: map[string]bool{
+ "foo/bar": true,
},
},
"foo/bar": {
- ex: map[string]struct{}{
- "baz": struct{}{},
+ ex: map[string]bool{
+ "baz": true,
},
in: empty(),
},
@@ -96,23 +95,128 @@
},
},
},
+ "missing package is poison": {
+ workmap: map[string]wm{
+ "A": {
+ ex: map[string]bool{
+ "B/foo": true,
+ },
+ in: map[string]bool{
+ "A/foo": true, // missing
+ "A/bar": true,
+ },
+ },
+ "A/bar": {
+ ex: map[string]bool{
+ "B/baz": true,
+ },
+ in: empty(),
+ },
+ },
+ out: map[string][]string{
+ "A/bar": {
+ "B/baz",
+ },
+ },
+ },
+ "transitive missing package is poison": {
+ workmap: map[string]wm{
+ "A": {
+ ex: map[string]bool{
+ "B/foo": true,
+ },
+ in: map[string]bool{
+ "A/foo": true, // transitively missing
+ "A/quux": true,
+ },
+ },
+ "A/foo": {
+ ex: map[string]bool{
+ "C/flugle": true,
+ },
+ in: map[string]bool{
+ "A/bar": true, // missing
+ },
+ },
+ "A/quux": {
+ ex: map[string]bool{
+ "B/baz": true,
+ },
+ in: empty(),
+ },
+ },
+ out: map[string][]string{
+ "A/quux": {
+ "B/baz",
+ },
+ },
+ },
+ "err'd package is poison": {
+ workmap: map[string]wm{
+ "A": {
+ ex: map[string]bool{
+ "B/foo": true,
+ },
+ in: map[string]bool{
+ "A/foo": true, // err'd
+ "A/bar": true,
+ },
+ },
+ "A/foo": {
+ err: fmt.Errorf("err pkg"),
+ },
+ "A/bar": {
+ ex: map[string]bool{
+ "B/baz": true,
+ },
+ in: empty(),
+ },
+ },
+ out: map[string][]string{
+ "A/bar": {
+ "B/baz",
+ },
+ },
+ },
+ "transitive err'd package is poison": {
+ workmap: map[string]wm{
+ "A": {
+ ex: map[string]bool{
+ "B/foo": true,
+ },
+ in: map[string]bool{
+ "A/foo": true, // transitively err'd
+ "A/quux": true,
+ },
+ },
+ "A/foo": {
+ ex: map[string]bool{
+ "C/flugle": true,
+ },
+ in: map[string]bool{
+ "A/bar": true, // err'd
+ },
+ },
+ "A/bar": {
+ err: fmt.Errorf("err pkg"),
+ },
+ "A/quux": {
+ ex: map[string]bool{
+ "B/baz": true,
+ },
+ in: empty(),
+ },
+ },
+ out: map[string][]string{
+ "A/quux": {
+ "B/baz",
+ },
+ },
+ },
}
for name, fix := range table {
- out, err := wmToReach(fix.workmap, fix.basedir)
-
- if fix.out == nil {
- if err == nil {
- t.Errorf("wmToReach(%q): Error expected but not received", name)
- }
- continue
- }
-
- if err != nil {
- t.Errorf("wmToReach(%q): %v", name, err)
- continue
- }
-
+ out := wmToReach(fix.workmap, fix.basedir)
if !reflect.DeepEqual(out, fix.out) {
t.Errorf("wmToReach(%q): Did not get expected reach map:\n\t(GOT): %s\n\t(WNT): %s", name, out, fix.out)
}
@@ -137,7 +241,7 @@
out: PackageTree{
ImportRoot: "empty",
Packages: map[string]PackageOrErr{
- "empty": PackageOrErr{
+ "empty": {
Err: &build.NoGoError{
Dir: j("empty"),
},
@@ -152,13 +256,13 @@
out: PackageTree{
ImportRoot: "simple",
Packages: map[string]PackageOrErr{
- "simple": PackageOrErr{
+ "simple": {
P: Package{
ImportPath: "simple",
CommentPath: "",
Name: "simple",
Imports: []string{
- "github.com/sdboyer/vsolver",
+ "github.com/sdboyer/gps",
"sort",
},
},
@@ -172,13 +276,13 @@
out: PackageTree{
ImportRoot: "arbitrary",
Packages: map[string]PackageOrErr{
- "arbitrary": PackageOrErr{
+ "arbitrary": {
P: Package{
ImportPath: "arbitrary",
CommentPath: "",
Name: "simple",
Imports: []string{
- "github.com/sdboyer/vsolver",
+ "github.com/sdboyer/gps",
"sort",
},
},
@@ -192,7 +296,7 @@
out: PackageTree{
ImportRoot: "simple",
Packages: map[string]PackageOrErr{
- "simple": PackageOrErr{
+ "simple": {
P: Package{
ImportPath: "simple",
CommentPath: "",
@@ -213,7 +317,7 @@
out: PackageTree{
ImportRoot: "simple",
Packages: map[string]PackageOrErr{
- "simple": PackageOrErr{
+ "simple": {
P: Package{
ImportPath: "simple",
CommentPath: "",
@@ -234,13 +338,13 @@
out: PackageTree{
ImportRoot: "simple",
Packages: map[string]PackageOrErr{
- "simple": PackageOrErr{
+ "simple": {
P: Package{
ImportPath: "simple",
CommentPath: "",
Name: "simple",
Imports: []string{
- "github.com/sdboyer/vsolver",
+ "github.com/sdboyer/gps",
"sort",
},
TestImports: []string{
@@ -258,13 +362,13 @@
out: PackageTree{
ImportRoot: "simple",
Packages: map[string]PackageOrErr{
- "simple": PackageOrErr{
+ "simple": {
P: Package{
ImportPath: "simple",
CommentPath: "",
Name: "simple",
Imports: []string{
- "github.com/sdboyer/vsolver",
+ "github.com/sdboyer/gps",
"sort",
},
TestImports: []string{
@@ -282,13 +386,13 @@
out: PackageTree{
ImportRoot: "simple",
Packages: map[string]PackageOrErr{
- "simple": PackageOrErr{
+ "simple": {
P: Package{
ImportPath: "simple",
CommentPath: "",
Name: "simple",
Imports: []string{
- "github.com/sdboyer/vsolver",
+ "github.com/sdboyer/gps",
"sort",
},
TestImports: []string{
@@ -307,13 +411,13 @@
out: PackageTree{
ImportRoot: "m1p",
Packages: map[string]PackageOrErr{
- "m1p": PackageOrErr{
+ "m1p": {
P: Package{
ImportPath: "m1p",
CommentPath: "",
Name: "m1p",
Imports: []string{
- "github.com/sdboyer/vsolver",
+ "github.com/sdboyer/gps",
"os",
"sort",
},
@@ -328,24 +432,24 @@
out: PackageTree{
ImportRoot: "nest",
Packages: map[string]PackageOrErr{
- "nest": PackageOrErr{
+ "nest": {
P: Package{
ImportPath: "nest",
CommentPath: "",
Name: "simple",
Imports: []string{
- "github.com/sdboyer/vsolver",
+ "github.com/sdboyer/gps",
"sort",
},
},
},
- "nest/m1p": PackageOrErr{
+ "nest/m1p": {
P: Package{
ImportPath: "nest/m1p",
CommentPath: "",
Name: "m1p",
Imports: []string{
- "github.com/sdboyer/vsolver",
+ "github.com/sdboyer/gps",
"os",
"sort",
},
@@ -360,30 +464,116 @@
out: PackageTree{
ImportRoot: "ren",
Packages: map[string]PackageOrErr{
- "ren": PackageOrErr{
+ "ren": {
Err: &build.NoGoError{
Dir: j("ren"),
},
},
- "ren/m1p": PackageOrErr{
+ "ren/m1p": {
P: Package{
ImportPath: "ren/m1p",
CommentPath: "",
Name: "m1p",
Imports: []string{
- "github.com/sdboyer/vsolver",
+ "github.com/sdboyer/gps",
"os",
"sort",
},
},
},
- "ren/simple": PackageOrErr{
+ "ren/simple": {
P: Package{
ImportPath: "ren/simple",
CommentPath: "",
Name: "simple",
Imports: []string{
- "github.com/sdboyer/vsolver",
+ "github.com/sdboyer/gps",
+ "sort",
+ },
+ },
+ },
+ },
+ },
+ },
+ "internal name mismatch": {
+ fileRoot: j("doublenest"),
+ importRoot: "doublenest",
+ out: PackageTree{
+ ImportRoot: "doublenest",
+ Packages: map[string]PackageOrErr{
+ "doublenest": {
+ P: Package{
+ ImportPath: "doublenest",
+ CommentPath: "",
+ Name: "base",
+ Imports: []string{
+ "github.com/sdboyer/gps",
+ "go/parser",
+ },
+ },
+ },
+ "doublenest/namemismatch": {
+ P: Package{
+ ImportPath: "doublenest/namemismatch",
+ CommentPath: "",
+ Name: "nm",
+ Imports: []string{
+ "github.com/Masterminds/semver",
+ "os",
+ },
+ },
+ },
+ "doublenest/namemismatch/m1p": {
+ P: Package{
+ ImportPath: "doublenest/namemismatch/m1p",
+ CommentPath: "",
+ Name: "m1p",
+ Imports: []string{
+ "github.com/sdboyer/gps",
+ "os",
+ "sort",
+ },
+ },
+ },
+ },
+ },
+ },
+ "file and importroot mismatch": {
+ fileRoot: j("doublenest"),
+ importRoot: "other",
+ out: PackageTree{
+ ImportRoot: "other",
+ Packages: map[string]PackageOrErr{
+ "other": {
+ P: Package{
+ ImportPath: "other",
+ CommentPath: "",
+ Name: "base",
+ Imports: []string{
+ "github.com/sdboyer/gps",
+ "go/parser",
+ },
+ },
+ },
+ "other/namemismatch": {
+ P: Package{
+ ImportPath: "other/namemismatch",
+ CommentPath: "",
+ Name: "nm",
+ Imports: []string{
+ "github.com/Masterminds/semver",
+ "os",
+ },
+ },
+ },
+ "other/namemismatch/m1p": {
+ P: Package{
+ ImportPath: "other/namemismatch/m1p",
+ CommentPath: "",
+ Name: "m1p",
+ Imports: []string{
+ "github.com/sdboyer/gps",
+ "os",
"sort",
},
},
@@ -397,13 +587,34 @@
out: PackageTree{
ImportRoot: "simple",
Packages: map[string]PackageOrErr{
- "simple": PackageOrErr{
+ "simple": {
P: Package{
ImportPath: "simple",
CommentPath: "",
Name: "simple",
Imports: []string{
- "github.com/sdboyer/vsolver",
+ "github.com/sdboyer/gps",
+ "sort",
+ "unicode",
+ },
+ },
+ },
+ },
+ },
+ },
+ "code and ignored main with comment leader": {
+ fileRoot: j("igmainlong"),
+ importRoot: "simple",
+ out: PackageTree{
+ ImportRoot: "simple",
+ Packages: map[string]PackageOrErr{
+ "simple": {
+ P: Package{
+ ImportPath: "simple",
+ CommentPath: "",
+ Name: "simple",
+ Imports: []string{
+ "github.com/sdboyer/gps",
"sort",
"unicode",
},
@@ -418,13 +629,13 @@
out: PackageTree{
ImportRoot: "simple",
Packages: map[string]PackageOrErr{
- "simple": PackageOrErr{
+ "simple": {
P: Package{
ImportPath: "simple",
CommentPath: "",
Name: "simple",
Imports: []string{
- "github.com/sdboyer/vsolver",
+ "github.com/sdboyer/gps",
"sort",
"unicode",
},
@@ -443,7 +654,7 @@
out: PackageTree{
ImportRoot: "twopkgs",
Packages: map[string]PackageOrErr{
- "twopkgs": PackageOrErr{
+ "twopkgs": {
Err: &build.MultiplePackageError{
Dir: j("twopkgs"),
Packages: []string{"simple", "m1p"},
@@ -453,6 +664,86 @@
},
},
},
+ // imports a missing pkg
+ "missing import": {
+ fileRoot: j("missing"),
+ importRoot: "missing",
+ out: PackageTree{
+ ImportRoot: "missing",
+ Packages: map[string]PackageOrErr{
+ "missing": {
+ P: Package{
+ ImportPath: "missing",
+ CommentPath: "",
+ Name: "simple",
+ Imports: []string{
+ "github.com/sdboyer/gps",
+ "missing/missing",
+ "sort",
+ },
+ },
+ },
+ "missing/m1p": {
+ P: Package{
+ ImportPath: "missing/m1p",
+ CommentPath: "",
+ Name: "m1p",
+ Imports: []string{
+ "github.com/sdboyer/gps",
+ "os",
+ "sort",
+ },
+ },
+ },
+ },
+ },
+ },
+ // has disallowed dir names
+ "disallowed dirs": {
+ fileRoot: j("disallow"),
+ importRoot: "disallow",
+ out: PackageTree{
+ ImportRoot: "disallow",
+ Packages: map[string]PackageOrErr{
+ "disallow": {
+ P: Package{
+ ImportPath: "disallow",
+ CommentPath: "",
+ Name: "disallow",
+ Imports: []string{
+ "disallow/testdata",
+ "github.com/sdboyer/gps",
+ "sort",
+ },
+ },
+ },
+ // disallow/.m1p is ignored by listPackages...for now. Kept
+ // here commented because this might change again...
+ //"disallow/.m1p": {
+ //P: Package{
+ //ImportPath: "disallow/.m1p",
+ //CommentPath: "",
+ //Name: "m1p",
+ //Imports: []string{
+ //"github.com/sdboyer/gps",
+ //"os",
+ //"sort",
+ //},
+ //},
+ //},
+ "disallow/testdata": {
+ P: Package{
+ ImportPath: "disallow/testdata",
+ CommentPath: "",
+ Name: "testdata",
+ Imports: []string{
+ "hash",
+ },
+ },
+ },
+ },
+ },
+ },
// This case mostly exists for the PackageTree methods, but it does
// cover a bit of range
"varied": {
@@ -461,7 +752,7 @@
out: PackageTree{
ImportRoot: "varied",
Packages: map[string]PackageOrErr{
- "varied": PackageOrErr{
+ "varied": {
P: Package{
ImportPath: "varied",
CommentPath: "",
@@ -474,7 +765,7 @@
},
},
},
- "varied/otherpath": PackageOrErr{
+ "varied/otherpath": {
P: Package{
ImportPath: "varied/otherpath",
CommentPath: "",
@@ -485,19 +776,19 @@
},
},
},
- "varied/simple": PackageOrErr{
+ "varied/simple": {
P: Package{
ImportPath: "varied/simple",
CommentPath: "",
Name: "simple",
Imports: []string{
- "github.com/sdboyer/vsolver",
+ "github.com/sdboyer/gps",
"go/parser",
"varied/simple/another",
},
},
},
- "varied/simple/another": PackageOrErr{
+ "varied/simple/another": {
P: Package{
ImportPath: "varied/simple/another",
CommentPath: "",
@@ -511,7 +802,7 @@
},
},
},
- "varied/namemismatch": PackageOrErr{
+ "varied/namemismatch": {
P: Package{
ImportPath: "varied/namemismatch",
CommentPath: "",
@@ -522,13 +813,13 @@
},
},
},
- "varied/m1p": PackageOrErr{
+ "varied/m1p": {
P: Package{
ImportPath: "varied/m1p",
CommentPath: "",
Name: "m1p",
Imports: []string{
- "github.com/sdboyer/vsolver",
+ "github.com/sdboyer/gps",
"os",
"sort",
},
@@ -574,7 +865,7 @@
for path, perr := range fix.out.Packages {
seen[path] = true
if operr, exists := out.Packages[path]; !exists {
- t.Errorf("listPackages(%q): Expected PackageOrErr for path %s was missing from output:\n\t%s", path, perr)
+ t.Errorf("listPackages(%q): Expected PackageOrErr for path %s was missing from output:\n\t%s", name, path, perr)
} else {
if !reflect.DeepEqual(perr, operr) {
t.Errorf("listPackages(%q): PkgOrErr for path %s was not as expected:\n\t(GOT): %s\n\t(WNT): %s", name, path, operr, perr)
@@ -587,7 +878,7 @@
continue
}
- t.Errorf("listPackages(%q): Got PackageOrErr for path %s, but none was expected:\n\t%s", path, operr)
+ t.Errorf("listPackages(%q): Got PackageOrErr for path %s, but none was expected:\n\t%s", name, path, operr)
}
}
}
@@ -609,10 +900,7 @@
var main, tests bool
validate := func() {
- result, err := vptree.ListExternalImports(main, tests, ignore)
- if err != nil {
- t.Errorf("%q case returned err: %s", name, err)
- }
+ result := vptree.ListExternalImports(main, tests, ignore)
if !reflect.DeepEqual(expect, result) {
t.Errorf("Wrong imports in %q case:\n\t(GOT): %s\n\t(WNT): %s", name, result, expect)
}
@@ -621,7 +909,7 @@
all := []string{
"encoding/binary",
"github.com/Masterminds/semver",
- "github.com/sdboyer/vsolver",
+ "github.com/sdboyer/gps",
"go/parser",
"hash",
"net/http",
@@ -697,8 +985,7 @@
ignore = map[string]bool{
"varied/simple": true,
}
- // we get github.com/sdboyer/vsolver from m1p, too, so it should still be
- // there
+ // we get github.com/sdboyer/gps from m1p, too, so it should still be there
except("go/parser")
validate()
@@ -727,24 +1014,36 @@
main, tests = true, true
- // ignore two that should knock out vsolver
+ // ignore two that should knock out gps
name = "ignore both importers"
ignore = map[string]bool{
"varied/simple": true,
"varied/m1p": true,
}
- except("sort", "github.com/sdboyer/vsolver", "go/parser")
+ except("sort", "github.com/sdboyer/gps", "go/parser")
validate()
// finally, directly ignore some external packages
name = "ignore external"
ignore = map[string]bool{
- "github.com/sdboyer/vsolver": true,
- "go/parser": true,
- "sort": true,
+ "github.com/sdboyer/gps": true,
+ "go/parser": true,
+ "sort": true,
}
- except("sort", "github.com/sdboyer/vsolver", "go/parser")
+ except("sort", "github.com/sdboyer/gps", "go/parser")
validate()
+
+ // The only thing varied *doesn't* cover is disallowed path patterns
+ ptree, err := listPackages(filepath.Join(getwd(t), "_testdata", "src", "disallow"), "disallow")
+ if err != nil {
+ t.Fatalf("listPackages failed on disallow test case: %s", err)
+ }
+
+ result := ptree.ListExternalImports(false, false, nil)
+ expect = []string{"github.com/sdboyer/gps", "hash", "sort"}
+ if !reflect.DeepEqual(expect, result) {
+ t.Errorf("Wrong imports in %q case:\n\t(GOT): %s\n\t(WNT): %s", name, result, expect)
+ }
}
func TestExternalReach(t *testing.T) {
@@ -761,10 +1060,7 @@
var ignore map[string]bool
validate := func() {
- result, err := vptree.ExternalReach(main, tests, ignore)
- if err != nil {
- t.Errorf("ver(%q): case returned err: %s", name, err)
- }
+ result := vptree.ExternalReach(main, tests, ignore)
if !reflect.DeepEqual(expect, result) {
seen := make(map[string]bool)
for ip, epkgs := range expect {
@@ -788,12 +1084,12 @@
}
all := map[string][]string{
- "varied": {"encoding/binary", "github.com/Masterminds/semver", "github.com/sdboyer/vsolver", "go/parser", "hash", "net/http", "os", "sort"},
- "varied/m1p": {"github.com/sdboyer/vsolver", "os", "sort"},
+ "varied": {"encoding/binary", "github.com/Masterminds/semver", "github.com/sdboyer/gps", "go/parser", "hash", "net/http", "os", "sort"},
+ "varied/m1p": {"github.com/sdboyer/gps", "os", "sort"},
"varied/namemismatch": {"github.com/Masterminds/semver", "os"},
- "varied/otherpath": {"github.com/sdboyer/vsolver", "os", "sort"},
- "varied/simple": {"encoding/binary", "github.com/sdboyer/vsolver", "go/parser", "hash", "os", "sort"},
- "varied/simple/another": {"encoding/binary", "github.com/sdboyer/vsolver", "hash", "os", "sort"},
+ "varied/otherpath": {"github.com/sdboyer/gps", "os", "sort"},
+ "varied/simple": {"encoding/binary", "github.com/sdboyer/gps", "go/parser", "hash", "os", "sort"},
+ "varied/simple/another": {"encoding/binary", "github.com/sdboyer/gps", "hash", "os", "sort"},
}
// build a map to validate the exception inputs. do this because shit is
// hard enough to keep track of that it's preferable not to have silent
@@ -891,7 +1187,7 @@
"varied encoding/binary",
"varied/simple encoding/binary",
"varied/simple/another encoding/binary",
- "varied/otherpath github.com/sdboyer/vsolver os sort",
+ "varied/otherpath github.com/sdboyer/gps os sort",
)
// almost the same as previous, but varied just goes away completely
@@ -901,7 +1197,7 @@
"varied",
"varied/simple encoding/binary",
"varied/simple/another encoding/binary",
- "varied/otherpath github.com/sdboyer/vsolver os sort",
+ "varied/otherpath github.com/sdboyer/gps os sort",
)
validate()
@@ -929,7 +1225,7 @@
}
except(
// root pkg loses on everything in varied/simple/another and varied/m1p
- "varied hash encoding/binary go/parser github.com/sdboyer/vsolver sort",
+ "varied hash encoding/binary go/parser github.com/sdboyer/gps sort",
"varied/otherpath",
"varied/simple",
)
@@ -940,22 +1236,21 @@
ignore["varied/namemismatch"] = true
except(
// root pkg loses on everything in varied/simple/another and varied/m1p
- "varied hash encoding/binary go/parser github.com/sdboyer/vsolver sort os github.com/Masterminds/semver",
+ "varied hash encoding/binary go/parser github.com/sdboyer/gps sort os github.com/Masterminds/semver",
"varied/otherpath",
"varied/simple",
"varied/namemismatch",
)
validate()
-
}
var _ = map[string][]string{
- "varied": {"encoding/binary", "github.com/Masterminds/semver", "github.com/sdboyer/vsolver", "go/parser", "hash", "net/http", "os", "sort"},
- "varied/m1p": {"github.com/sdboyer/vsolver", "os", "sort"},
+ "varied": {"encoding/binary", "github.com/Masterminds/semver", "github.com/sdboyer/gps", "go/parser", "hash", "net/http", "os", "sort"},
+ "varied/m1p": {"github.com/sdboyer/gps", "os", "sort"},
"varied/namemismatch": {"github.com/Masterminds/semver", "os"},
- "varied/otherpath": {"github.com/sdboyer/vsolver", "os", "sort"},
- "varied/simple": {"encoding/binary", "github.com/sdboyer/vsolver", "go/parser", "hash", "os", "sort"},
- "varied/simple/another": {"encoding/binary", "github.com/sdboyer/vsolver", "hash", "os", "sort"},
+ "varied/otherpath": {"github.com/sdboyer/gps", "os", "sort"},
+ "varied/simple": {"encoding/binary", "github.com/sdboyer/gps", "go/parser", "hash", "os", "sort"},
+ "varied/simple/another": {"encoding/binary", "github.com/sdboyer/gps", "hash", "os", "sort"},
}
func getwd(t *testing.T) string {
diff --git a/vendor/github.com/sdboyer/vsolver/appveyor.yml b/vendor/github.com/sdboyer/gps/appveyor.yml
similarity index 86%
rename from vendor/github.com/sdboyer/vsolver/appveyor.yml
rename to vendor/github.com/sdboyer/gps/appveyor.yml
index cbaa941..9bf23a3 100644
--- a/vendor/github.com/sdboyer/vsolver/appveyor.yml
+++ b/vendor/github.com/sdboyer/gps/appveyor.yml
@@ -1,6 +1,6 @@
version: build-{build}.{branch}
-clone_folder: C:\gopath\src\github.com\sdboyer\vsolver
+clone_folder: C:\gopath\src\github.com\sdboyer\gps
shallow_clone: true
environment:
diff --git a/vendor/github.com/sdboyer/vsolver/bridge.go b/vendor/github.com/sdboyer/gps/bridge.go
similarity index 88%
rename from vendor/github.com/sdboyer/vsolver/bridge.go
rename to vendor/github.com/sdboyer/gps/bridge.go
index 7f57f15..8b26e6b 100644
--- a/vendor/github.com/sdboyer/vsolver/bridge.go
+++ b/vendor/github.com/sdboyer/gps/bridge.go
@@ -1,8 +1,9 @@
-package vsolver
+package gps
import (
"fmt"
"os"
+ "path/filepath"
"sort"
)
@@ -11,6 +12,9 @@
type sourceBridge interface {
getProjectInfo(pa atom) (Manifest, Lock, error)
listVersions(id ProjectIdentifier) ([]Version, error)
+ listPackages(id ProjectIdentifier, v Version) (PackageTree, error)
+ computeRootReach() ([]string, error)
+ revisionPresentIn(id ProjectIdentifier, r Revision) (bool, error)
pairRevision(id ProjectIdentifier, r Revision) []Version
pairVersion(id ProjectIdentifier, v UnpairedVersion) PairedVersion
repoExists(id ProjectIdentifier) (bool, error)
@@ -18,9 +22,7 @@
matches(id ProjectIdentifier, c Constraint, v Version) bool
matchesAny(id ProjectIdentifier, c1, c2 Constraint) bool
intersect(id ProjectIdentifier, c1, c2 Constraint) Constraint
- listPackages(id ProjectIdentifier, v Version) (PackageTree, error)
- computeRootReach() ([]string, error)
- verifyRoot(path string) error
+ verifyRootDir(path string) error
deduceRemoteRepo(path string) (*remoteRepo, error)
}
@@ -28,7 +30,7 @@
// 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 ProjectName, which is what the
+// 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
@@ -41,17 +43,12 @@
// The underlying, adapted-to SourceManager
sm SourceManager
- // Direction to sort the version list. False indicates sorting for upgrades;
- // true for downgrades.
- sortdown bool
-
- // The name of the root project we're operating on. Used to redirect some
- // calls that would ordinarily go to the SourceManager to a root-specific
- // logical path, instead.
- name ProjectName
-
- // The path to the base directory of the root project.
- root string
+ // The solver which we're assisting.
+ //
+ // The link between solver and bridge is circular, which is typically a bit
+ // awkward, but the bridge needs access to so many of the input arguments
+ // held by the solver that it ends up being easier and saner to do this.
+ s *solver
// Simple, local cache of the root's PackageTree
crp *struct {
@@ -59,24 +56,34 @@
err error
}
- // A map of packages to ignore.
- ignore map[string]bool
-
// Map of project root name to their available version list. This cache is
// layered on top of the proper SourceManager's cache; the only difference
// is that this keeps the versions sorted in the direction required by the
// current solve run
- vlists map[ProjectName][]Version
+ vlists map[ProjectRoot][]Version
+}
+
+// Global factory func to create a bridge. This exists solely to allow tests to
+// override it with a custom bridge and sm.
+var mkBridge func(*solver, SourceManager) sourceBridge = func(s *solver, sm SourceManager) sourceBridge {
+ return &bridge{
+ sm: sm,
+ s: s,
+ vlists: make(map[ProjectRoot][]Version),
+ }
}
func (b *bridge) getProjectInfo(pa atom) (Manifest, Lock, error) {
- return b.sm.GetProjectInfo(ProjectName(pa.id.netName()), pa.v)
+ if pa.id.ProjectRoot == b.s.params.ImportRoot {
+ return b.s.rm, b.s.rl, nil
+ }
+ return b.sm.GetProjectInfo(ProjectRoot(pa.id.netName()), pa.v)
}
-func (b *bridge) key(id ProjectIdentifier) ProjectName {
- k := ProjectName(id.NetworkName)
+func (b *bridge) key(id ProjectIdentifier) ProjectRoot {
+ k := ProjectRoot(id.NetworkName)
if k == "" {
- k = id.LocalName
+ k = id.ProjectRoot
}
return k
@@ -90,12 +97,12 @@
}
vl, err := b.sm.ListVersions(k)
- // TODO cache errors, too?
+ // TODO(sdboyer) cache errors, too?
if err != nil {
return nil, err
}
- if b.sortdown {
+ if b.s.params.Downgrade {
sort.Sort(downgradeVersionSorter(vl))
} else {
sort.Sort(upgradeVersionSorter(vl))
@@ -105,14 +112,25 @@
return vl, nil
}
+func (b *bridge) revisionPresentIn(id ProjectIdentifier, r Revision) (bool, error) {
+ k := b.key(id)
+ return b.sm.RevisionPresentIn(k, r)
+}
+
func (b *bridge) repoExists(id ProjectIdentifier) (bool, error) {
k := b.key(id)
return b.sm.RepoExists(k)
}
func (b *bridge) vendorCodeExists(id ProjectIdentifier) (bool, error) {
- k := b.key(id)
- return b.sm.VendorCodeExists(k)
+ fi, err := os.Stat(filepath.Join(b.s.params.RootDir, "vendor", string(id.ProjectRoot)))
+ if err != nil {
+ return false, err
+ } else if fi.IsDir() {
+ return true, nil
+ }
+
+ return false, nil
}
func (b *bridge) pairVersion(id ProjectIdentifier, v UnpairedVersion) PairedVersion {
@@ -349,7 +367,7 @@
// potentially messy root project source location on disk. Together, this means
// that we can't ask the real SourceManager to do it.
func (b *bridge) computeRootReach() ([]string, error) {
- // TODO i now cannot remember the reasons why i thought being less stringent
+ // TODO(sdboyer) i now cannot remember the reasons why i thought being less stringent
// in the analysis was OK. so, for now, we just compute a bog-standard list
// of externally-touched packages, including mains and test.
ptree, err := b.listRootPackages()
@@ -357,12 +375,12 @@
return nil, err
}
- return ptree.ListExternalImports(true, true, b.ignore)
+ return ptree.ListExternalImports(true, true, b.s.ig), nil
}
func (b *bridge) listRootPackages() (PackageTree, error) {
if b.crp == nil {
- ptree, err := listPackages(b.root, string(b.name))
+ ptree, err := listPackages(b.s.params.RootDir, string(b.s.params.ImportRoot))
b.crp = &struct {
ptree PackageTree
@@ -385,7 +403,7 @@
// The root project is handled separately, as the source manager isn't
// responsible for that code.
func (b *bridge) listPackages(id ProjectIdentifier, v Version) (PackageTree, error) {
- if id.LocalName == b.name {
+ if id.ProjectRoot == b.s.params.ImportRoot {
return b.listRootPackages()
}
@@ -397,11 +415,11 @@
// verifyRoot ensures that the provided path to the project root is in good
// working condition. This check is made only once, at the beginning of a solve
// run.
-func (b *bridge) verifyRoot(path string) error {
+func (b *bridge) verifyRootDir(path string) error {
if fi, err := os.Stat(path); err != nil {
- return badOptsFailure(fmt.Sprintf("Could not read project root (%s): %s", path, err))
+ return badOptsFailure(fmt.Sprintf("could not read project root (%s): %s", path, err))
} else if !fi.IsDir() {
- return badOptsFailure(fmt.Sprintf("Project root (%s) is a file, not a directory.", path))
+ return badOptsFailure(fmt.Sprintf("project root (%s) is a file, not a directory", path))
}
return nil
diff --git a/vendor/github.com/sdboyer/vsolver/circle.yml b/vendor/github.com/sdboyer/gps/circle.yml
similarity index 100%
rename from vendor/github.com/sdboyer/vsolver/circle.yml
rename to vendor/github.com/sdboyer/gps/circle.yml
diff --git a/vendor/github.com/sdboyer/vsolver/constraint_test.go b/vendor/github.com/sdboyer/gps/constraint_test.go
similarity index 99%
rename from vendor/github.com/sdboyer/vsolver/constraint_test.go
rename to vendor/github.com/sdboyer/gps/constraint_test.go
index 8dc7bb6..3863e65 100644
--- a/vendor/github.com/sdboyer/vsolver/constraint_test.go
+++ b/vendor/github.com/sdboyer/gps/constraint_test.go
@@ -1,4 +1,4 @@
-package vsolver
+package gps
import (
"fmt"
@@ -89,7 +89,7 @@
}
// Now add same rev to different branches
- // TODO this might not actually be a good idea, when you consider the
+ // TODO(sdboyer) this might not actually be a good idea, when you consider the
// semantics of floating versions...matching on an underlying rev might be
// nice in the short term, but it's probably shit most of the time
v5 := v2.Is(Revision("snuffleupagus")).(versionPair)
@@ -586,7 +586,7 @@
v5 := v2.Is(fozzie).(versionPair)
v6 := v3.Is(fozzie).(versionPair)
- // TODO we can't use the same range as below b/c semver.rangeConstraint is
+ // TODO(sdboyer) we can't use the same range as below b/c semver.rangeConstraint is
// still an incomparable type
c1, err := NewSemverConstraint("=1.0.0")
if err != nil {
diff --git a/vendor/github.com/sdboyer/vsolver/constraints.go b/vendor/github.com/sdboyer/gps/constraints.go
similarity index 97%
rename from vendor/github.com/sdboyer/vsolver/constraints.go
rename to vendor/github.com/sdboyer/gps/constraints.go
index 3cfe5ee..43b8b09 100644
--- a/vendor/github.com/sdboyer/vsolver/constraints.go
+++ b/vendor/github.com/sdboyer/gps/constraints.go
@@ -1,4 +1,4 @@
-package vsolver
+package gps
import (
"fmt"
@@ -14,7 +14,7 @@
// A Constraint provides structured limitations on the versions that are
// admissible for a given project.
//
-// As with Version, it has a private method because the vsolver's internal
+// As with Version, it has a private method because the gps's internal
// implementation of the problem is complete, and the system relies on type
// magic to operate.
type Constraint interface {
diff --git a/vendor/github.com/sdboyer/vsolver/discovery.go b/vendor/github.com/sdboyer/gps/discovery.go
similarity index 99%
rename from vendor/github.com/sdboyer/vsolver/discovery.go
rename to vendor/github.com/sdboyer/gps/discovery.go
index 5543bee..8da4a66 100644
--- a/vendor/github.com/sdboyer/vsolver/discovery.go
+++ b/vendor/github.com/sdboyer/gps/discovery.go
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-package vsolver
+package gps
// This code is taken from cmd/go/discovery.go; it is the logic go get itself
// uses to interpret meta imports information.
diff --git a/vendor/github.com/sdboyer/vsolver/errors.go b/vendor/github.com/sdboyer/gps/errors.go
similarity index 85%
rename from vendor/github.com/sdboyer/vsolver/errors.go
rename to vendor/github.com/sdboyer/gps/errors.go
index 18f50fb..26c8413 100644
--- a/vendor/github.com/sdboyer/vsolver/errors.go
+++ b/vendor/github.com/sdboyer/gps/errors.go
@@ -1,4 +1,4 @@
-package vsolver
+package gps
import (
"bytes"
@@ -8,7 +8,7 @@
type errorLevel uint8
-// TODO consistent, sensible way of handling 'type' and 'severity' - or figure
+// TODO(sdboyer) consistent, sensible way of handling 'type' and 'severity' - or figure
// out that they're not orthogonal and collapse into just 'type'
const (
@@ -41,11 +41,11 @@
func (e *noVersionError) Error() string {
if len(e.fails) == 0 {
- return fmt.Sprintf("No versions found for project %q.", e.pn.LocalName)
+ 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.LocalName)
+ 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())
}
@@ -59,7 +59,7 @@
}
var buf bytes.Buffer
- fmt.Fprintf(&buf, "No versions of %s met constraints:", e.pn.LocalName)
+ 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())
@@ -110,10 +110,10 @@
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.LocalName, f.depender.v)
+ 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.LocalName, f.depender.v)
+ 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()
@@ -134,7 +134,7 @@
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.LocalName, e.goal.depender.v, e.goal.dep.Ident.LocalName, e.goal.dep.Constraint, e.v)
+ 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 {
@@ -164,9 +164,9 @@
func (e *versionNotAllowedFailure) traceString() string {
var buf bytes.Buffer
- fmt.Fprintf(&buf, "%s at %s not allowed by constraint %s:\n", e.goal.id.LocalName, e.goal.v, e.c.String())
+ 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.LocalName, f.depender.v)
+ fmt.Fprintf(&buf, " %s from %s at %s\n", f.dep.Constraint.String(), f.depender.id.ProjectRoot, f.depender.v)
}
return buf.String()
@@ -188,7 +188,7 @@
}
type sourceMismatchFailure struct {
- shared ProjectName
+ shared ProjectRoot
sel []dependency
current, mismatch string
prob atom
@@ -197,7 +197,7 @@
func (e *sourceMismatchFailure) Error() string {
var cur []string
for _, c := range e.sel {
- cur = append(cur, string(c.depender.id.LocalName))
+ 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"
@@ -278,7 +278,7 @@
func (e *checkeeHasProblemPackagesFailure) traceString() string {
var buf bytes.Buffer
- fmt.Fprintf(&buf, "%s at %s has problem subpkg(s):\n", e.goal.id.LocalName, e.goal.v)
+ 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)
@@ -375,3 +375,31 @@
return buf.String()
}
+
+// nonexistentRevisionFailure indicates that a revision constraint was specified
+// for a given project, but that that revision does not exist in the source
+// repository.
+type nonexistentRevisionFailure struct {
+ goal dependency
+ r Revision
+}
+
+func (e *nonexistentRevisionFailure) Error() string {
+ return fmt.Sprintf(
+ "Could not introduce %s at %s, as it requires %s at revision %s, but that revision does not exist",
+ e.goal.depender.id.errString(),
+ e.goal.depender.v,
+ e.goal.dep.Ident.errString(),
+ e.r,
+ )
+}
+
+func (e *nonexistentRevisionFailure) traceString() string {
+ return fmt.Sprintf(
+ "%s at %s wants missing rev %s of %s",
+ e.goal.depender.id.errString(),
+ e.goal.depender.v,
+ e.r,
+ e.goal.dep.Ident.errString(),
+ )
+}
diff --git a/vendor/github.com/sdboyer/gps/example.go b/vendor/github.com/sdboyer/gps/example.go
new file mode 100644
index 0000000..1a5a31a
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/example.go
@@ -0,0 +1,58 @@
+// +build ignore
+
+package main
+
+import (
+ "go/build"
+ "log"
+ "os"
+ "path/filepath"
+ "strings"
+
+ gps "github.com/sdboyer/gps"
+)
+
+// This is probably the simplest possible implementation of gps. It does the
+// substantive work that `go get` does, except:
+// 1. It drops the resulting tree into vendor instead of GOPATH
+// 2. It prefers semver tags (if available) over branches
+// 3. It removes any vendor directories nested within dependencies
+//
+// This will compile and work...and then blow away the vendor directory present
+// in the cwd, if any. Be careful!
+func main() {
+ // Operate on the current directory
+ root, _ := os.Getwd()
+ // Assume the current directory is correctly placed on a GOPATH, and derive
+ // the ProjectRoot from it
+ srcprefix := filepath.Join(build.Default.GOPATH, "src") + string(filepath.Separator)
+ importroot := filepath.ToSlash(strings.TrimPrefix(root, srcprefix))
+
+ // Set up params, including tracing
+ params := gps.SolveParameters{
+ RootDir: root,
+ ImportRoot: gps.ProjectRoot(importroot),
+ Trace: true,
+ TraceLogger: log.New(os.Stdout, "", 0),
+ }
+
+ // Set up a SourceManager with the NaiveAnalyzer
+ sourcemgr, _ := gps.NewSourceManager(NaiveAnalyzer{}, ".repocache", false)
+ defer sourcemgr.Release()
+
+ // Prep and run the solver
+ solver, _ := gps.Prepare(params, sourcemgr)
+ solution, err := solver.Solve()
+ if err == nil {
+ // If no failure, blow away the vendor dir and write a new one out,
+ // stripping nested vendor directories as we go.
+ os.RemoveAll(filepath.Join(root, "vendor"))
+ gps.CreateVendorTree(filepath.Join(root, "vendor"), solution, sourcemgr, true)
+ }
+}
+
+type NaiveAnalyzer struct{}
+
+func (a NaiveAnalyzer) GetInfo(path string, n gps.ProjectRoot) (gps.Manifest, gps.Lock, error) {
+ return nil, nil, nil
+}
diff --git a/vendor/github.com/sdboyer/vsolver/flags.go b/vendor/github.com/sdboyer/gps/flags.go
similarity index 98%
rename from vendor/github.com/sdboyer/vsolver/flags.go
rename to vendor/github.com/sdboyer/gps/flags.go
index 8a7880f..a7172c1 100644
--- a/vendor/github.com/sdboyer/vsolver/flags.go
+++ b/vendor/github.com/sdboyer/gps/flags.go
@@ -1,4 +1,4 @@
-package vsolver
+package gps
// projectExistence values represent the extent to which a project "exists."
type projectExistence uint8
diff --git a/vendor/github.com/sdboyer/vsolver/glide.lock b/vendor/github.com/sdboyer/gps/glide.lock
similarity index 100%
rename from vendor/github.com/sdboyer/vsolver/glide.lock
rename to vendor/github.com/sdboyer/gps/glide.lock
diff --git a/vendor/github.com/sdboyer/vsolver/glide.yaml b/vendor/github.com/sdboyer/gps/glide.yaml
similarity index 78%
rename from vendor/github.com/sdboyer/vsolver/glide.yaml
rename to vendor/github.com/sdboyer/gps/glide.yaml
index fed9822..690f9e1 100644
--- a/vendor/github.com/sdboyer/vsolver/glide.yaml
+++ b/vendor/github.com/sdboyer/gps/glide.yaml
@@ -1,4 +1,4 @@
-package: github.com/sdboyer/vsolver
+package: github.com/sdboyer/gps
owners:
- name: Sam Boyer
email: tech@samboyer.org
@@ -11,5 +11,4 @@
- package: github.com/termie/go-shutil
version: bcacb06fecaeec8dc42af03c87c6949f4a05c74c
vcs: git
-- package: github.com/hashicorp/go-immutable-radix
- package: github.com/armon/go-radix
diff --git a/vendor/github.com/sdboyer/vsolver/hash.go b/vendor/github.com/sdboyer/gps/hash.go
similarity index 76%
rename from vendor/github.com/sdboyer/vsolver/hash.go
rename to vendor/github.com/sdboyer/gps/hash.go
index 5fe87aa..9e27bcd 100644
--- a/vendor/github.com/sdboyer/vsolver/hash.go
+++ b/vendor/github.com/sdboyer/gps/hash.go
@@ -1,4 +1,4 @@
-package vsolver
+package gps
import (
"crypto/sha256"
@@ -19,18 +19,13 @@
func (s *solver) HashInputs() ([]byte, error) {
// Do these checks up front before any other work is needed, as they're the
// only things that can cause errors
- if err := s.b.verifyRoot(s.args.Root); err != nil {
- // This will already be a BadOptsFailure
- return nil, err
- }
-
// Pass in magic root values, and the bridge will analyze the right thing
- ptree, err := s.b.listPackages(ProjectIdentifier{LocalName: s.args.Name}, nil)
+ ptree, err := s.b.listPackages(ProjectIdentifier{ProjectRoot: s.params.ImportRoot}, nil)
if err != nil {
- return nil, badOptsFailure(fmt.Sprintf("Error while parsing imports under %s: %s", s.args.Root, err.Error()))
+ return nil, badOptsFailure(fmt.Sprintf("Error while parsing packages under %s: %s", s.params.RootDir, err.Error()))
}
- d, dd := s.args.Manifest.DependencyConstraints(), s.args.Manifest.TestDependencyConstraints()
+ d, dd := s.params.Manifest.DependencyConstraints(), s.params.Manifest.TestDependencyConstraints()
p := make(sortedDeps, len(d))
copy(p, d)
p = append(p, dd...)
@@ -40,7 +35,7 @@
// We have everything we need; now, compute the hash.
h := sha256.New()
for _, pd := range p {
- h.Write([]byte(pd.Ident.LocalName))
+ h.Write([]byte(pd.Ident.ProjectRoot))
h.Write([]byte(pd.Ident.NetworkName))
// FIXME Constraint.String() is a surjective-only transformation - tags
// and branches with the same name are written out as the same string.
@@ -49,10 +44,11 @@
h.Write([]byte(pd.Constraint.String()))
}
- // The stdlib packages play the same functional role in solving as ignores.
- // Because they change, albeit quite infrequently, we have to include them
- // in the hash.
+ // The stdlib and old appengine packages play the same functional role in
+ // solving as ignores. Because they change, albeit quite infrequently, we
+ // have to include them in the hash.
h.Write([]byte(stdlibPkgs))
+ h.Write([]byte(appenginePkgs))
// Write each of the packages, or the errors that were found for a
// particular subpath, into the hash.
@@ -88,12 +84,12 @@
}
}
- // TODO overrides
- // TODO aliases
+ // TODO(sdboyer) overrides
+ // TODO(sdboyer) aliases
return h.Sum(nil), nil
}
-type sortedDeps []ProjectDep
+type sortedDeps []ProjectConstraint
func (s sortedDeps) Len() int {
return len(s)
diff --git a/vendor/github.com/sdboyer/gps/hash_test.go b/vendor/github.com/sdboyer/gps/hash_test.go
new file mode 100644
index 0000000..dc27ddf
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/hash_test.go
@@ -0,0 +1,35 @@
+package gps
+
+import (
+ "bytes"
+ "crypto/sha256"
+ "testing"
+)
+
+func TestHashInputs(t *testing.T) {
+ fix := basicFixtures["shared dependency with overlapping constraints"]
+
+ params := SolveParameters{
+ RootDir: string(fix.ds[0].n),
+ ImportRoot: fix.ds[0].n,
+ Manifest: fix.ds[0],
+ Ignore: []string{"foo", "bar"},
+ }
+
+ s, err := Prepare(params, newdepspecSM(fix.ds, nil))
+
+ dig, err := s.HashInputs()
+ if err != nil {
+ t.Fatalf("HashInputs returned unexpected err: %s", err)
+ }
+
+ h := sha256.New()
+ for _, v := range []string{"a", "a", "1.0.0", "b", "b", "1.0.0", stdlibPkgs, appenginePkgs, "root", "", "root", "a", "b", "bar", "foo"} {
+ h.Write([]byte(v))
+ }
+ correct := h.Sum(nil)
+
+ if !bytes.Equal(dig, correct) {
+ t.Errorf("Hashes are not equal")
+ }
+}
diff --git a/vendor/github.com/sdboyer/vsolver/import_mode_go15.go b/vendor/github.com/sdboyer/gps/import_mode_go15.go
similarity index 94%
rename from vendor/github.com/sdboyer/vsolver/import_mode_go15.go
rename to vendor/github.com/sdboyer/gps/import_mode_go15.go
index 05ae43a..5ef11c2 100644
--- a/vendor/github.com/sdboyer/vsolver/import_mode_go15.go
+++ b/vendor/github.com/sdboyer/gps/import_mode_go15.go
@@ -1,6 +1,6 @@
// +build !go1.6
-package vsolver
+package gps
import "go/build"
diff --git a/vendor/github.com/sdboyer/vsolver/import_mode_go16.go b/vendor/github.com/sdboyer/gps/import_mode_go16.go
similarity index 93%
rename from vendor/github.com/sdboyer/vsolver/import_mode_go16.go
rename to vendor/github.com/sdboyer/gps/import_mode_go16.go
index 1b798ce..edb534a 100644
--- a/vendor/github.com/sdboyer/vsolver/import_mode_go16.go
+++ b/vendor/github.com/sdboyer/gps/import_mode_go16.go
@@ -1,6 +1,6 @@
// +build go1.6
-package vsolver
+package gps
import "go/build"
diff --git a/vendor/github.com/sdboyer/vsolver/lock.go b/vendor/github.com/sdboyer/gps/lock.go
similarity index 86%
rename from vendor/github.com/sdboyer/vsolver/lock.go
rename to vendor/github.com/sdboyer/gps/lock.go
index 19a75d3..1d4db56 100644
--- a/vendor/github.com/sdboyer/vsolver/lock.go
+++ b/vendor/github.com/sdboyer/gps/lock.go
@@ -1,17 +1,17 @@
-package vsolver
+package gps
// Lock represents data from a lock file (or however the implementing tool
// chooses to store it) at a particular version that is relevant to the
// satisfiability solving process.
//
-// In general, the information produced by vsolver on finding a successful
+// In general, the information produced by gps on finding a successful
// solution is all that would be necessary to constitute a lock file, though
// tools can include whatever other information they want in their storage.
type Lock interface {
// Indicates the version of the solver used to generate this lock data
//SolverVersion() string
- // The hash of inputs to vsolver that resulted in this lock data
+ // The hash of inputs to gps that resulted in this lock data
InputHash() []byte
// Projects returns the list of LockedProjects contained in the lock data.
@@ -26,7 +26,6 @@
pi ProjectIdentifier
v UnpairedVersion
r Revision
- path string
pkgs []string
}
@@ -49,8 +48,7 @@
}
// NewLockedProject creates a new LockedProject struct with a given name,
-// version, upstream repository URI, and on-disk path at which the project is to
-// be checked out under a vendor directory.
+// version, and upstream repository URL.
//
// Note that passing a nil version will cause a panic. This is a correctness
// measure to ensure that the solver is never exposed to a version-less lock
@@ -58,17 +56,16 @@
// to simply dismiss that project. By creating a hard failure case via panic
// instead, we are trying to avoid inflicting the resulting pain on the user by
// instead forcing a decision on the Analyzer implementation.
-func NewLockedProject(n ProjectName, v Version, uri, path string, pkgs []string) LockedProject {
+func NewLockedProject(n ProjectRoot, v Version, url string, pkgs []string) LockedProject {
if v == nil {
panic("must provide a non-nil version to create a LockedProject")
}
lp := LockedProject{
pi: ProjectIdentifier{
- LocalName: n,
- NetworkName: uri,
+ ProjectRoot: n,
+ NetworkName: url,
},
- path: path,
pkgs: pkgs,
}
@@ -110,12 +107,6 @@
return lp.v.Is(lp.r)
}
-// Path returns the path relative to the vendor directory to which the locked
-// project should be checked out.
-func (lp LockedProject) Path() string {
- return lp.path
-}
-
func (lp LockedProject) toAtom() atom {
pa := atom{
id: lp.Ident(),
diff --git a/vendor/github.com/sdboyer/vsolver/manager_test.go b/vendor/github.com/sdboyer/gps/manager_test.go
similarity index 87%
rename from vendor/github.com/sdboyer/vsolver/manager_test.go
rename to vendor/github.com/sdboyer/gps/manager_test.go
index 98e0e38..ebc8091 100644
--- a/vendor/github.com/sdboyer/vsolver/manager_test.go
+++ b/vendor/github.com/sdboyer/gps/manager_test.go
@@ -1,8 +1,7 @@
-package vsolver
+package gps
import (
"fmt"
- "go/build"
"io/ioutil"
"os"
"path"
@@ -15,10 +14,13 @@
var bd string
-type dummyAnalyzer struct{}
+// An analyzer that passes nothing back, but doesn't error. This is the naive
+// case - no constraints, no lock, and no errors. The SourceMgr will interpret
+// this as open/Any constraints on everything in the import graph.
+type naiveAnalyzer struct{}
-func (dummyAnalyzer) GetInfo(ctx build.Context, p ProjectName) (Manifest, Lock, error) {
- return SimpleManifest{N: p}, nil, nil
+func (naiveAnalyzer) GetInfo(string, ProjectRoot) (Manifest, Lock, error) {
+ return nil, nil, nil
}
func sv(s string) *semver.Version {
@@ -40,7 +42,7 @@
if err != nil {
t.Errorf("Failed to create temp dir: %s", err)
}
- _, err = NewSourceManager(dummyAnalyzer{}, cpath, bd, false)
+ _, err = NewSourceManager(naiveAnalyzer{}, cpath, false)
if err != nil {
t.Errorf("Unexpected error on SourceManager creation: %s", err)
@@ -52,12 +54,12 @@
}
}()
- _, err = NewSourceManager(dummyAnalyzer{}, cpath, bd, false)
+ _, err = NewSourceManager(naiveAnalyzer{}, cpath, false)
if err == nil {
t.Errorf("Creating second SourceManager should have failed due to file lock contention")
}
- sm, err := NewSourceManager(dummyAnalyzer{}, cpath, bd, true)
+ sm, err := NewSourceManager(naiveAnalyzer{}, cpath, true)
defer sm.Release()
if err != nil {
t.Errorf("Creating second SourceManager should have succeeded when force flag was passed, but failed with err %s", err)
@@ -78,7 +80,7 @@
if err != nil {
t.Errorf("Failed to create temp dir: %s", err)
}
- sm, err := NewSourceManager(dummyAnalyzer{}, cpath, bd, false)
+ sm, err := NewSourceManager(naiveAnalyzer{}, cpath, false)
if err != nil {
t.Errorf("Unexpected error on SourceManager creation: %s", err)
@@ -92,7 +94,7 @@
}()
defer sm.Release()
- pn := ProjectName("github.com/Masterminds/VCSTestRepo")
+ pn := ProjectRoot("github.com/Masterminds/VCSTestRepo")
v, err := sm.ListVersions(pn)
if err != nil {
t.Errorf("Unexpected error during initial project setup/fetching %s", err)
@@ -124,10 +126,11 @@
// ensure its sorting works, as well.
smc := &bridge{
sm: sm,
- vlists: make(map[ProjectName][]Version),
+ vlists: make(map[ProjectRoot][]Version),
+ s: &solver{},
}
- v, err = smc.listVersions(ProjectIdentifier{LocalName: pn})
+ v, err = smc.listVersions(ProjectIdentifier{ProjectRoot: pn})
if err != nil {
t.Errorf("Unexpected error during initial project setup/fetching %s", err)
}
@@ -157,7 +160,7 @@
_, err = os.Stat(path.Join(cpath, "metadata", "github.com", "Masterminds", "VCSTestRepo", "cache.json"))
if err != nil {
- // TODO temporarily disabled until we turn caching back on
+ // TODO(sdboyer) temporarily disabled until we turn caching back on
//t.Error("Metadata cache json file does not exist in expected location")
}
@@ -171,16 +174,8 @@
t.Error("Repo should exist after non-erroring call to ListVersions")
}
- exists, err = sm.VendorCodeExists(pn)
- if err != nil {
- t.Errorf("Error on checking VendorCodeExists: %s", err)
- }
- if exists {
- t.Error("Shouldn't be any vendor code after just calling ListVersions")
- }
-
// Now reach inside the black box
- pms, err := sm.(*sourceManager).getProjectManager(pn)
+ pms, err := sm.getProjectManager(pn)
if err != nil {
t.Errorf("Error on grabbing project manager obj: %s", err)
}
@@ -202,14 +197,13 @@
t.Errorf("Failed to create temp dir: %s", err)
}
- smi, err := NewSourceManager(dummyAnalyzer{}, cpath, bd, false)
+ sm, err := NewSourceManager(naiveAnalyzer{}, cpath, false)
if err != nil {
t.Errorf("Unexpected error on SourceManager creation: %s", err)
t.FailNow()
}
- sm := smi.(*sourceManager)
- upstreams := []ProjectName{
+ upstreams := []ProjectRoot{
"github.com/Masterminds/VCSTestRepo",
"bitbucket.org/mattfarina/testhgrepo",
"launchpad.net/govcstestbzrrepo",
@@ -314,7 +308,7 @@
if err != nil {
t.Errorf("Failed to create temp dir: %s", err)
}
- sm, err := NewSourceManager(dummyAnalyzer{}, cpath, bd, false)
+ sm, err := NewSourceManager(naiveAnalyzer{}, cpath, false)
if err != nil {
t.Errorf("Unexpected error on SourceManager creation: %s", err)
@@ -330,7 +324,7 @@
// setup done, now do the test
- pn := ProjectName("github.com/Masterminds/VCSTestRepo")
+ pn := ProjectRoot("github.com/Masterminds/VCSTestRepo")
_, _, err = sm.GetProjectInfo(pn, NewVersion("1.0.0"))
if err != nil {
diff --git a/vendor/github.com/sdboyer/gps/manifest.go b/vendor/github.com/sdboyer/gps/manifest.go
new file mode 100644
index 0000000..83fd9d7
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/manifest.go
@@ -0,0 +1,77 @@
+package gps
+
+// Manifest represents manifest-type data for a project at a particular version.
+// That means dependency constraints, both for normal dependencies and for
+// tests. The constraints expressed in a manifest determine the set of versions that
+// are acceptable to try for a given project.
+//
+// Expressing a constraint in a manifest does not guarantee that a particular
+// dependency will be present. It only guarantees that if packages in the
+// project specified by the dependency are discovered through static analysis of
+// the (transitive) import graph, then they will conform to the constraint.
+//
+// This does entail that manifests can express constraints on projects they do
+// not themselves import. This is by design, but its implications are complex.
+// See the gps docs for more information: https://github.com/sdboyer/gps/wiki
+type Manifest interface {
+ // Returns a list of project-level constraints.
+ DependencyConstraints() []ProjectConstraint
+ // Returns a list of constraints applicable to test imports. Note that this
+ // will only be consulted for root manifests.
+ TestDependencyConstraints() []ProjectConstraint
+}
+
+// SimpleManifest is a helper for tools to enumerate manifest data. It's
+// generally intended for ephemeral manifests, such as those Analyzers create on
+// the fly for projects with no manifest metadata, or metadata through a foreign
+// tool's idioms.
+type SimpleManifest struct {
+ Deps []ProjectConstraint
+ TestDeps []ProjectConstraint
+}
+
+var _ Manifest = SimpleManifest{}
+
+// DependencyConstraints returns the project's dependencies.
+func (m SimpleManifest) DependencyConstraints() []ProjectConstraint {
+ return m.Deps
+}
+
+// TestDependencyConstraints returns the project's test dependencies.
+func (m SimpleManifest) TestDependencyConstraints() []ProjectConstraint {
+ return m.TestDeps
+}
+
+// prepManifest ensures a manifest is prepared and safe for use by the solver.
+// This entails two things:
+//
+// * Ensuring that all ProjectIdentifiers are normalized (otherwise matching
+// can get screwy and the queues go out of alignment)
+// * Defensively ensuring that no outside routine can modify the manifest while
+// the solver is in-flight.
+//
+// This is achieved by copying the manifest's data into a new SimpleManifest.
+func prepManifest(m Manifest) Manifest {
+ if m == nil {
+ return SimpleManifest{}
+ }
+
+ deps := m.DependencyConstraints()
+ ddeps := m.TestDependencyConstraints()
+
+ rm := SimpleManifest{
+ Deps: make([]ProjectConstraint, len(deps)),
+ TestDeps: make([]ProjectConstraint, len(ddeps)),
+ }
+
+ for k, d := range deps {
+ d.Ident = d.Ident.normalize()
+ rm.Deps[k] = d
+ }
+ for k, d := range ddeps {
+ d.Ident = d.Ident.normalize()
+ rm.TestDeps[k] = d
+ }
+
+ return rm
+}
diff --git a/vendor/github.com/sdboyer/gps/marker-header.png b/vendor/github.com/sdboyer/gps/marker-header.png
new file mode 100644
index 0000000..66965c5
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/marker-header.png
Binary files differ
diff --git a/vendor/github.com/sdboyer/vsolver/project_manager.go b/vendor/github.com/sdboyer/gps/project_manager.go
similarity index 81%
rename from vendor/github.com/sdboyer/vsolver/project_manager.go
rename to vendor/github.com/sdboyer/gps/project_manager.go
index dd10e6a..e174fde 100644
--- a/vendor/github.com/sdboyer/vsolver/project_manager.go
+++ b/vendor/github.com/sdboyer/gps/project_manager.go
@@ -1,4 +1,4 @@
-package vsolver
+package gps
import (
"bytes"
@@ -18,14 +18,11 @@
type projectManager struct {
// The identifier of the project. At this level, corresponds to the
// '$GOPATH/src'-relative path, *and* the network name.
- n ProjectName
+ n ProjectRoot
// build.Context to use in any analysis, and to pass to the analyzer
ctx build.Context
- // Top-level project vendor dir
- vendordir string
-
// Object for the cache repository
crepo *repo
@@ -42,6 +39,7 @@
// The project metadata cache. This is persisted to disk, for reuse across
// solver runs.
+ // TODO(sdboyer) protect with mutex
dc *projectDataCache
}
@@ -53,12 +51,13 @@
f projectExistence
}
-// TODO figure out shape of versions, then implement marshaling/unmarshaling
+// TODO(sdboyer) figure out shape of versions, then implement marshaling/unmarshaling
type projectDataCache struct {
- Version string `json:"version"` // TODO use this
- Infos map[Revision]projectInfo `json:"infos"`
- VMap map[Version]Revision `json:"vmap"`
- RMap map[Revision][]Version `json:"rmap"`
+ 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
@@ -110,13 +109,13 @@
}
pm.crepo.mut.Unlock()
if err != nil {
- // TODO More-er proper-er error
+ // 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(pm.ctx, pm.n)
- // TODO cache results
+ 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 {
@@ -126,10 +125,12 @@
// If m is nil, prepManifest will provide an empty one.
pi := projectInfo{
- Manifest: prepManifest(m, pm.n),
+ 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
}
@@ -140,34 +141,62 @@
return nil, nil, err
}
-func (pm *projectManager) ListPackages(v Version) (PackageTree, error) {
- var err error
+func (pm *projectManager) ListPackages(v Version) (ptree PackageTree, err error) {
if err = pm.ensureCacheExistence(); err != nil {
- return PackageTree{}, err
+ 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 pv, ok := v.(PairedVersion); ok {
+ if r != "" {
// Always prefer a rev, if it's available
- err = pm.crepo.r.UpdateVersion(pv.Underlying().String())
+ 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")
+ return PackageTree{}, fmt.Errorf("Could not fetch latest updates into repository: %s", err)
}
pm.crepo.synced = true
}
err = pm.crepo.r.UpdateVersion(v.String())
}
- ex, err := listPackages(filepath.Join(pm.ctx.GOPATH, "src", string(pm.n)), string(pm.n))
+ ptree, err = listPackages(filepath.Join(pm.ctx.GOPATH, "src", string(pm.n)), string(pm.n))
pm.crepo.mut.Unlock()
- return ex, err
+ // TODO(sdboyer) cache errs?
+ if err != nil {
+ pm.dc.Packages[r] = ptree
+ }
+
+ return
}
func (pm *projectManager) ensureCacheExistence() error {
@@ -178,14 +207,17 @@
// 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)
+ 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 repository cache for %s does not exist", pm.n)
+ return fmt.Errorf("project %s does not exist upstream", pm.n)
}
}
@@ -202,7 +234,7 @@
pm.ex.f |= exbits
if err != nil {
- // TODO More-er proper-er error
+ // TODO(sdboyer) More-er proper-er error
fmt.Println(err)
return nil, err
}
@@ -214,7 +246,7 @@
}
// Process the version data into the cache
- // TODO detect out-of-sync data as we do this?
+ // 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)
@@ -223,9 +255,9 @@
} else {
vlist = make([]Version, len(pm.dc.VMap))
k := 0
- // TODO key type of VMap should be string; recombine here
+ // TODO(sdboyer) key type of VMap should be string; recombine here
//for v, r := range pm.dc.VMap {
- for v, _ := range pm.dc.VMap {
+ for v := range pm.dc.VMap {
vlist[k] = v
k++
}
@@ -234,6 +266,25 @@
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.
@@ -244,12 +295,7 @@
func (pm *projectManager) CheckExistence(ex projectExistence) bool {
if pm.ex.s&ex != ex {
if ex&existsInVendorRoot != 0 && pm.ex.s&existsInVendorRoot == 0 {
- pm.ex.s |= existsInVendorRoot
-
- fi, err := os.Stat(path.Join(pm.vendordir, string(pm.n)))
- if err == nil && fi.IsDir() {
- pm.ex.f |= existsInVendorRoot
- }
+ panic("should now be implemented in bridge")
}
if ex&existsInCache != 0 && pm.ex.s&existsInCache == 0 {
pm.crepo.mut.RLock()
@@ -290,7 +336,7 @@
all := bytes.Split(bytes.TrimSpace(out), []byte("\n"))
if err != nil || len(all) == 0 {
- // TODO remove this path? it really just complicates things, for
+ // 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
@@ -436,8 +482,8 @@
vlist = append(vlist, v)
}
case *vcs.SvnRepo:
- // TODO is it ok to return empty vlist and no error?
- // TODO ...gotta do something for svn, right?
+ // 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")
}
@@ -458,7 +504,7 @@
return err
}
- // TODO could have an err here
+ // TODO(sdboyer) could have an err here
defer os.Rename(bak, idx)
vstr := v.String()
@@ -482,7 +528,7 @@
_, err = r.r.RunFromDir("git", "checkout-index", "-a", "--prefix="+to)
return err
default:
- // TODO This is a dumb, slow approach, but we're punting on making these
+ // 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())
diff --git a/vendor/github.com/sdboyer/vsolver/remote.go b/vendor/github.com/sdboyer/gps/remote.go
similarity index 95%
rename from vendor/github.com/sdboyer/vsolver/remote.go
rename to vendor/github.com/sdboyer/gps/remote.go
index b04b9ce..c808d9a 100644
--- a/vendor/github.com/sdboyer/vsolver/remote.go
+++ b/vendor/github.com/sdboyer/gps/remote.go
@@ -1,4 +1,4 @@
-package vsolver
+package gps
import (
"fmt"
@@ -27,7 +27,7 @@
//err error
//}
-// TODO sync access to this map
+// TODO(sdboyer) sync access to this map
//var remoteCache = make(map[string]remoteResult)
// Regexes for the different known import path flavors
@@ -69,7 +69,7 @@
User: url.User(m[1]),
Host: m[2],
Path: "/" + m[3],
- // TODO This is what stdlib sets; grok why better
+ // TODO(sdboyer) This is what stdlib sets; grok why better
//RawPath: m[3],
}
} else {
@@ -93,7 +93,7 @@
rr.Schemes = []string{rr.CloneURL.Scheme}
}
- // TODO instead of a switch, encode base domain in radix tree and pick
+ // 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 {
@@ -156,7 +156,7 @@
//return
case lpRegex.MatchString(path):
- // TODO lp handling is nasty - there's ambiguities which can only really
+ // 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)
@@ -169,7 +169,7 @@
return
case glpRegex.MatchString(path):
- // TODO same ambiguity issues as with normal bzr lp
+ // TODO(sdboyer) same ambiguity issues as with normal bzr lp
v := glpRegex.FindStringSubmatch(path)
rr.CloneURL.Host = "git.launchpad.net"
@@ -208,7 +208,7 @@
switch v[5] {
case "git", "hg", "bzr":
x := strings.SplitN(v[1], "/", 2)
- // TODO is this actually correct for bzr?
+ // TODO(sdboyer) is this actually correct for bzr?
rr.CloneURL.Host = x[0]
rr.CloneURL.Path = x[1]
rr.VCS = []string{v[5]}
diff --git a/vendor/github.com/sdboyer/vsolver/remote_test.go b/vendor/github.com/sdboyer/gps/remote_test.go
similarity index 88%
rename from vendor/github.com/sdboyer/vsolver/remote_test.go
rename to vendor/github.com/sdboyer/gps/remote_test.go
index 3bac9ae..17de00f 100644
--- a/vendor/github.com/sdboyer/vsolver/remote_test.go
+++ b/vendor/github.com/sdboyer/gps/remote_test.go
@@ -1,4 +1,4 @@
-package vsolver
+package gps
import (
"fmt"
@@ -17,69 +17,69 @@
want *remoteRepo
}{
{
- "github.com/sdboyer/vsolver",
+ "github.com/sdboyer/gps",
&remoteRepo{
- Base: "github.com/sdboyer/vsolver",
+ Base: "github.com/sdboyer/gps",
RelPkg: "",
CloneURL: &url.URL{
Host: "github.com",
- Path: "sdboyer/vsolver",
+ Path: "sdboyer/gps",
},
Schemes: nil,
VCS: []string{"git"},
},
},
{
- "github.com/sdboyer/vsolver/foo",
+ "github.com/sdboyer/gps/foo",
&remoteRepo{
- Base: "github.com/sdboyer/vsolver",
+ Base: "github.com/sdboyer/gps",
RelPkg: "foo",
CloneURL: &url.URL{
Host: "github.com",
- Path: "sdboyer/vsolver",
+ Path: "sdboyer/gps",
},
Schemes: nil,
VCS: []string{"git"},
},
},
{
- "git@github.com:sdboyer/vsolver",
+ "git@github.com:sdboyer/gps",
&remoteRepo{
- Base: "github.com/sdboyer/vsolver",
+ Base: "github.com/sdboyer/gps",
RelPkg: "",
CloneURL: &url.URL{
Scheme: "ssh",
User: url.User("git"),
Host: "github.com",
- Path: "sdboyer/vsolver",
+ Path: "sdboyer/gps",
},
Schemes: []string{"ssh"},
VCS: []string{"git"},
},
},
{
- "https://github.com/sdboyer/vsolver/foo",
+ "https://github.com/sdboyer/gps/foo",
&remoteRepo{
- Base: "github.com/sdboyer/vsolver",
+ Base: "github.com/sdboyer/gps",
RelPkg: "foo",
CloneURL: &url.URL{
Scheme: "https",
Host: "github.com",
- Path: "sdboyer/vsolver",
+ Path: "sdboyer/gps",
},
Schemes: []string{"https"},
VCS: []string{"git"},
},
},
{
- "https://github.com/sdboyer/vsolver/foo/bar",
+ "https://github.com/sdboyer/gps/foo/bar",
&remoteRepo{
- Base: "github.com/sdboyer/vsolver",
+ Base: "github.com/sdboyer/gps",
RelPkg: "foo/bar",
CloneURL: &url.URL{
Scheme: "https",
Host: "github.com",
- Path: "sdboyer/vsolver",
+ Path: "sdboyer/gps",
},
Schemes: []string{"https"},
VCS: []string{"git"},
@@ -87,53 +87,53 @@
},
// some invalid github username patterns
{
- "github.com/-sdboyer/vsolver/foo",
+ "github.com/-sdboyer/gps/foo",
nil,
},
{
- "github.com/sdboyer-/vsolver/foo",
+ "github.com/sdboyer-/gps/foo",
nil,
},
{
- "github.com/sdbo.yer/vsolver/foo",
+ "github.com/sdbo.yer/gps/foo",
nil,
},
{
- "github.com/sdbo_yer/vsolver/foo",
+ "github.com/sdbo_yer/gps/foo",
nil,
},
{
- "gopkg.in/sdboyer/vsolver.v0",
+ "gopkg.in/sdboyer/gps.v0",
&remoteRepo{
- Base: "gopkg.in/sdboyer/vsolver.v0",
+ Base: "gopkg.in/sdboyer/gps.v0",
RelPkg: "",
CloneURL: &url.URL{
Host: "github.com",
- Path: "sdboyer/vsolver",
+ Path: "sdboyer/gps",
},
VCS: []string{"git"},
},
},
{
- "gopkg.in/sdboyer/vsolver.v0/foo",
+ "gopkg.in/sdboyer/gps.v0/foo",
&remoteRepo{
- Base: "gopkg.in/sdboyer/vsolver.v0",
+ Base: "gopkg.in/sdboyer/gps.v0",
RelPkg: "foo",
CloneURL: &url.URL{
Host: "github.com",
- Path: "sdboyer/vsolver",
+ Path: "sdboyer/gps",
},
VCS: []string{"git"},
},
},
{
- "gopkg.in/sdboyer/vsolver.v0/foo/bar",
+ "gopkg.in/sdboyer/gps.v0/foo/bar",
&remoteRepo{
- Base: "gopkg.in/sdboyer/vsolver.v0",
+ Base: "gopkg.in/sdboyer/gps.v0",
RelPkg: "foo/bar",
CloneURL: &url.URL{
Host: "github.com",
- Path: "sdboyer/vsolver",
+ Path: "sdboyer/gps",
},
VCS: []string{"git"},
},
@@ -451,7 +451,7 @@
t.Errorf("deduceRemoteRepo(%q): RelPkg was %s, wanted %s", fix.path, got.RelPkg, want.RelPkg)
}
if !reflect.DeepEqual(got.CloneURL, want.CloneURL) {
- // mispelling things is cool when it makes columns line up
+ // 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) {
diff --git a/vendor/github.com/sdboyer/vsolver/remove_go16.go b/vendor/github.com/sdboyer/gps/remove_go16.go
similarity index 97%
rename from vendor/github.com/sdboyer/vsolver/remove_go16.go
rename to vendor/github.com/sdboyer/gps/remove_go16.go
index 21a3530..8c7844d 100644
--- a/vendor/github.com/sdboyer/vsolver/remove_go16.go
+++ b/vendor/github.com/sdboyer/gps/remove_go16.go
@@ -1,6 +1,6 @@
// +build !go1.7
-package vsolver
+package gps
import (
"os"
diff --git a/vendor/github.com/sdboyer/vsolver/remove_go17.go b/vendor/github.com/sdboyer/gps/remove_go17.go
similarity index 92%
rename from vendor/github.com/sdboyer/vsolver/remove_go17.go
rename to vendor/github.com/sdboyer/gps/remove_go17.go
index cb18bae..59c19a6 100644
--- a/vendor/github.com/sdboyer/vsolver/remove_go17.go
+++ b/vendor/github.com/sdboyer/gps/remove_go17.go
@@ -1,6 +1,6 @@
// +build go1.7
-package vsolver
+package gps
import "os"
diff --git a/vendor/github.com/sdboyer/vsolver/result.go b/vendor/github.com/sdboyer/gps/result.go
similarity index 66%
rename from vendor/github.com/sdboyer/vsolver/result.go
rename to vendor/github.com/sdboyer/gps/result.go
index e6e929e..e601de9 100644
--- a/vendor/github.com/sdboyer/vsolver/result.go
+++ b/vendor/github.com/sdboyer/gps/result.go
@@ -1,4 +1,4 @@
-package vsolver
+package gps
import (
"fmt"
@@ -7,14 +7,14 @@
"path/filepath"
)
-// A Result is returned by a solver run. It is mostly just a Lock, with some
+// A Solution is returned by a solver run. It is mostly just a Lock, with some
// additional methods that report information about the solve run.
-type Result interface {
+type Solution interface {
Lock
Attempts() int
}
-type result struct {
+type solution struct {
// A list of the projects selected by the solver.
p []LockedProject
@@ -37,37 +37,37 @@
return err
}
- // TODO parallelize
+ // TODO(sdboyer) parallelize
for _, p := range l.Projects() {
- to := path.Join(basedir, string(p.Ident().LocalName))
+ to := path.Join(basedir, string(p.Ident().ProjectRoot))
err := os.MkdirAll(to, 0777)
if err != nil {
return err
}
- err = sm.ExportProject(p.Ident().LocalName, p.Version(), to)
+ err = sm.ExportProject(p.Ident().ProjectRoot, p.Version(), to)
if err != nil {
removeAll(basedir)
- return fmt.Errorf("Error while exporting %s: %s", p.Ident().LocalName, err)
+ return fmt.Errorf("Error while exporting %s: %s", p.Ident().ProjectRoot, err)
}
if sv {
filepath.Walk(to, stripVendor)
}
- // TODO dump version metadata file
+ // TODO(sdboyer) dump version metadata file
}
return nil
}
-func (r result) Projects() []LockedProject {
+func (r solution) Projects() []LockedProject {
return r.p
}
-func (r result) Attempts() int {
+func (r solution) Attempts() int {
return r.att
}
-func (r result) InputHash() []byte {
+func (r solution) InputHash() []byte {
return r.hd
}
diff --git a/vendor/github.com/sdboyer/vsolver/result_test.go b/vendor/github.com/sdboyer/gps/result_test.go
similarity index 73%
rename from vendor/github.com/sdboyer/vsolver/result_test.go
rename to vendor/github.com/sdboyer/gps/result_test.go
index 5419d32..1aed83b 100644
--- a/vendor/github.com/sdboyer/vsolver/result_test.go
+++ b/vendor/github.com/sdboyer/gps/result_test.go
@@ -1,32 +1,22 @@
-package vsolver
+package gps
import (
- "go/build"
"os"
"path"
"testing"
)
-var basicResult result
+var basicResult solution
var kub atom
-// An analyzer that passes nothing back, but doesn't error. This expressly
-// creates a situation that shouldn't be able to happen from a general solver
-// perspective, so it's only useful for particular situations in tests
-type passthruAnalyzer struct{}
-
-func (passthruAnalyzer) GetInfo(ctx build.Context, p ProjectName) (Manifest, Lock, error) {
- return nil, nil, nil
-}
-
func pi(n string) ProjectIdentifier {
return ProjectIdentifier{
- LocalName: ProjectName(n),
+ ProjectRoot: ProjectRoot(n),
}
}
func init() {
- basicResult = result{
+ basicResult = solution{
att: 1,
p: []LockedProject{
pa2lp(atom{
@@ -58,7 +48,7 @@
tmp := path.Join(os.TempDir(), "vsolvtest")
os.RemoveAll(tmp)
- sm, err := NewSourceManager(passthruAnalyzer{}, path.Join(tmp, "cache"), path.Join(tmp, "base"), false)
+ sm, err := NewSourceManager(naiveAnalyzer{}, path.Join(tmp, "cache"), false)
if err != nil {
t.Errorf("NewSourceManager errored unexpectedly: %q", err)
}
@@ -68,7 +58,7 @@
t.Errorf("Unexpected error while creating vendor tree: %s", err)
}
- // TODO add more checks
+ // TODO(sdboyer) add more checks
}
func BenchmarkCreateVendorTree(b *testing.B) {
@@ -79,7 +69,7 @@
tmp := path.Join(os.TempDir(), "vsolvtest")
clean := true
- sm, err := NewSourceManager(passthruAnalyzer{}, path.Join(tmp, "cache"), path.Join(tmp, "base"), true)
+ sm, err := NewSourceManager(naiveAnalyzer{}, path.Join(tmp, "cache"), true)
if err != nil {
b.Errorf("NewSourceManager errored unexpectedly: %q", err)
clean = false
@@ -87,7 +77,7 @@
// Prefetch the projects before timer starts
for _, lp := range r.p {
- _, _, err := sm.GetProjectInfo(lp.Ident().LocalName, lp.Version())
+ _, _, err := sm.GetProjectInfo(lp.Ident().ProjectRoot, lp.Version())
if err != nil {
b.Errorf("failed getting project info during prefetch: %s", err)
clean = false
diff --git a/vendor/github.com/sdboyer/vsolver/satisfy.go b/vendor/github.com/sdboyer/gps/satisfy.go
similarity index 76%
rename from vendor/github.com/sdboyer/vsolver/satisfy.go
rename to vendor/github.com/sdboyer/gps/satisfy.go
index c431cdc..8c99f47 100644
--- a/vendor/github.com/sdboyer/vsolver/satisfy.go
+++ b/vendor/github.com/sdboyer/gps/satisfy.go
@@ -1,4 +1,4 @@
-package vsolver
+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
@@ -12,41 +12,54 @@
}
if err := s.checkAtomAllowable(pa); err != nil {
+ s.logSolve(err)
return err
}
if err := s.checkRequiredPackagesExist(a); err != nil {
+ s.logSolve(err)
return err
}
deps, err := s.getImportsAndConstraintsOf(a)
if err != nil {
// An err here would be from the package fetcher; pass it straight back
+ // TODO(sdboyer) can we logSolve this?
return err
}
for _, dep := range deps {
if err := s.checkIdentMatches(a, dep); err != nil {
+ s.logSolve(err)
return err
}
if err := s.checkDepsConstraintsAllowable(a, dep); err != nil {
+ s.logSolve(err)
return err
}
if err := s.checkDepsDisallowsSelected(a, dep); err != nil {
+ s.logSolve(err)
return err
}
+ // TODO(sdboyer) decide how to refactor in order to re-enable this. Checking for
+ // revision existence is important...but kinda obnoxious.
+ //if err := s.checkRevisionExists(a, dep); err != nil {
+ //s.logSolve(err)
+ //return err
+ //}
if err := s.checkPackageImportsFromDepExist(a, dep); err != nil {
+ s.logSolve(err)
return err
}
- // TODO add check that fails if adding this atom would create a loop
+ // TODO(sdboyer) add check that fails if adding this atom would create a loop
}
return nil
}
-// checkPackages performs all constraint checks new packages being added to an
-// already-selected project. It determines if selecting the packages would
+// 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 {
@@ -60,20 +73,31 @@
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
}
}
@@ -88,7 +112,7 @@
if s.b.matches(pa.id, constraint, pa.v) {
return nil
}
- // TODO collect constraint failure reason (wait...aren't we, below?)
+ // TODO(sdboyer) collect constraint failure reason (wait...aren't we, below?)
deps := s.sel.getDependenciesOn(pa.id)
var failparent []dependency
@@ -105,7 +129,6 @@
c: constraint,
}
- s.logSolve(err)
return err
}
@@ -114,7 +137,7 @@
func (s *solver) checkRequiredPackagesExist(a atomWithPackages) error {
ptree, err := s.b.listPackages(a.a.id, a.a.v)
if err != nil {
- // TODO handle this more gracefully
+ // TODO(sdboyer) handle this more gracefully
return err
}
@@ -122,7 +145,7 @@
fp := make(map[string]errDeppers)
// We inspect these in a bit of a roundabout way, in order to incrementally
// build up the failure we'd return if there is, indeed, a missing package.
- // TODO rechecking all of these every time is wasteful. Is there a shortcut?
+ // TODO(sdboyer) rechecking all of these every time is wasteful. Is there a shortcut?
for _, dep := range deps {
for _, pkg := range dep.dep.pl {
if errdep, seen := fp[pkg]; seen {
@@ -141,12 +164,10 @@
}
if len(fp) > 0 {
- e := &checkeeHasProblemPackagesFailure{
+ return &checkeeHasProblemPackagesFailure{
goal: a.a,
failpkg: fp,
}
- s.logSolve(e)
- return e
}
return nil
}
@@ -154,7 +175,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.ProjectDep
+ dep := cdep.ProjectConstraint
constraint := s.sel.getConstraint(dep.Ident)
// Ensure the constraint expressed by the dep has at least some possible
// intersection with the intersection of existing constraints.
@@ -175,31 +196,27 @@
}
}
- err := &disjointConstraintFailure{
+ return &disjointConstraintFailure{
goal: dependency{depender: a.a, dep: cdep},
failsib: failsib,
nofailsib: nofailsib,
c: constraint,
}
- s.logSolve(err)
- return err
}
// checkDepsDisallowsSelected ensures that an atom's constraints on a particular
// dep are not incompatible with the version of that dep that's already been
// selected.
func (s *solver) checkDepsDisallowsSelected(a atomWithPackages, cdep completeDep) error {
- dep := cdep.ProjectDep
+ dep := cdep.ProjectConstraint
selected, exists := s.sel.selected(dep.Ident)
if exists && !s.b.matches(dep.Ident, dep.Constraint, selected.a.v) {
s.fail(dep.Ident)
- err := &constraintNotAllowedFailure{
+ return &constraintNotAllowedFailure{
goal: dependency{depender: a.a, dep: cdep},
v: selected.a.v,
}
- s.logSolve(err)
- return err
}
return nil
}
@@ -212,8 +229,8 @@
// 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.ProjectDep
- if cur, exists := s.names[dep.Ident.LocalName]; exists {
+ dep := cdep.ProjectConstraint
+ if cur, exists := s.names[dep.Ident.ProjectRoot]; exists {
if cur != dep.Ident.netName() {
deps := s.sel.getDependenciesOn(a.a.id)
// Fail all the other deps, as there's no way atom can ever be
@@ -222,15 +239,13 @@
s.fail(d.depender.id)
}
- err := &sourceMismatchFailure{
- shared: dep.Ident.LocalName,
+ return &sourceMismatchFailure{
+ shared: dep.Ident.ProjectRoot,
sel: deps,
current: cur,
mismatch: dep.Ident.netName(),
prob: a.a,
}
- s.logSolve(err)
- return err
}
}
@@ -240,7 +255,7 @@
// 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.ProjectDep.Ident)
+ sel, is := s.sel.selected(cdep.ProjectConstraint.Ident)
if !is {
// dep is not already selected; nothing to do
return nil
@@ -248,7 +263,7 @@
ptree, err := s.b.listPackages(sel.a.id, sel.a.v)
if err != nil {
- // TODO handle this more gracefully
+ // TODO(sdboyer) handle this more gracefully
return err
}
@@ -272,8 +287,30 @@
}
if len(e.pl) > 0 {
- s.logSolve(e)
return e
}
return nil
}
+
+// checkRevisionExists ensures that if a dependency is constrained by a
+// revision, that that revision actually exists.
+func (s *solver) checkRevisionExists(a atomWithPackages, cdep completeDep) error {
+ r, isrev := cdep.Constraint.(Revision)
+ if !isrev {
+ // Constraint is not a revision; nothing to do
+ return nil
+ }
+
+ present, _ := s.b.revisionPresentIn(cdep.Ident, r)
+ if present {
+ return nil
+ }
+
+ return &nonexistentRevisionFailure{
+ goal: dependency{
+ depender: a.a,
+ dep: cdep,
+ },
+ r: r,
+ }
+}
diff --git a/vendor/github.com/sdboyer/vsolver/selection.go b/vendor/github.com/sdboyer/gps/selection.go
similarity index 92%
rename from vendor/github.com/sdboyer/vsolver/selection.go
rename to vendor/github.com/sdboyer/gps/selection.go
index 9aaac4d..6d84643 100644
--- a/vendor/github.com/sdboyer/vsolver/selection.go
+++ b/vendor/github.com/sdboyer/gps/selection.go
@@ -1,4 +1,4 @@
-package vsolver
+package gps
type selection struct {
projects []selected
@@ -60,7 +60,7 @@
// Compute a list of the unique packages within the given ProjectIdentifier that
// have dependers, and the number of dependers they have.
func (s *selection) getRequiredPackagesIn(id ProjectIdentifier) map[string]int {
- // TODO this is horribly inefficient to do on the fly; we need a method to
+ // TODO(sdboyer) this is horribly inefficient to do on the fly; we need a method to
// precompute it on pushing a new dep, and preferably with an immut
// structure so that we can pop with zero cost.
uniq := make(map[string]int)
@@ -82,7 +82,7 @@
// are currently selected, and the number of times each package has been
// independently selected.
func (s *selection) getSelectedPackagesIn(id ProjectIdentifier) map[string]int {
- // TODO this is horribly inefficient to do on the fly; we need a method to
+ // TODO(sdboyer) this is horribly inefficient to do on the fly; we need a method to
// precompute it on pushing a new dep, and preferably with an immut
// structure so that we can pop with zero cost.
uniq := make(map[string]int)
@@ -108,7 +108,7 @@
return any
}
- // TODO recomputing this sucks and is quite wasteful. Precompute/cache it
+ // TODO(sdboyer) recomputing this sucks and is quite wasteful. Precompute/cache it
// on changes to the constraint set, instead.
// The solver itself is expected to maintain the invariant that all the
@@ -141,8 +141,6 @@
return atomWithPackages{a: nilpa}, false
}
-// TODO take a ProjectName, but optionally also a preferred version. This will
-// enable the lock files of dependencies to remain slightly more stable.
type unselected struct {
sl []bimodalIdentifier
cmp func(i, j int) bool
@@ -179,7 +177,6 @@
// The worst case for both of these is O(n), but in practice the first case is
// be O(1), as we iterate the queue from front to back.
func (u *unselected) remove(bmi bimodalIdentifier) {
- // TODO is it worth implementing a binary search here?
for k, pi := range u.sl {
if pi.id.eq(bmi.id) {
// Simple slice comparison - assume they're both sorted the same
diff --git a/vendor/github.com/sdboyer/gps/solve_basic_test.go b/vendor/github.com/sdboyer/gps/solve_basic_test.go
new file mode 100644
index 0000000..055ecc8
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/solve_basic_test.go
@@ -0,0 +1,1362 @@
+package gps
+
+import (
+ "fmt"
+ "regexp"
+ "strings"
+
+ "github.com/Masterminds/semver"
+)
+
+var regfrom = regexp.MustCompile(`^(\w*) from (\w*) ([0-9\.]*)`)
+
+// nvSplit splits an "info" string on " " into the pair of name and
+// version/constraint, and returns each individually.
+//
+// This is for narrow use - panics if there are less than two resulting items in
+// the slice.
+func nvSplit(info string) (id ProjectIdentifier, version string) {
+ if strings.Contains(info, " from ") {
+ parts := regfrom.FindStringSubmatch(info)
+ info = parts[1] + " " + parts[3]
+ id.NetworkName = parts[2]
+ }
+
+ s := strings.SplitN(info, " ", 2)
+ if len(s) < 2 {
+ panic(fmt.Sprintf("Malformed name/version info string '%s'", info))
+ }
+
+ id.ProjectRoot, version = ProjectRoot(s[0]), s[1]
+ if id.NetworkName == "" {
+ id.NetworkName = string(id.ProjectRoot)
+ }
+ return
+}
+
+// nvrSplit splits an "info" string on " " into the triplet of name,
+// version/constraint, and revision, and returns each individually.
+//
+// It will work fine if only name and version/constraint are provided.
+//
+// This is for narrow use - panics if there are less than two resulting items in
+// the slice.
+func nvrSplit(info string) (id ProjectIdentifier, version string, revision Revision) {
+ if strings.Contains(info, " from ") {
+ parts := regfrom.FindStringSubmatch(info)
+ info = parts[1] + " " + parts[3]
+ id.NetworkName = parts[2]
+ }
+
+ s := strings.SplitN(info, " ", 3)
+ if len(s) < 2 {
+ panic(fmt.Sprintf("Malformed name/version info string '%s'", info))
+ }
+
+ id.ProjectRoot, version = ProjectRoot(s[0]), s[1]
+ if id.NetworkName == "" {
+ id.NetworkName = string(id.ProjectRoot)
+ }
+
+ if len(s) == 3 {
+ revision = Revision(s[2])
+ }
+ return
+}
+
+// mkAtom splits the input string on a space, and uses the first two elements as
+// the project identifier and version, respectively.
+//
+// The version segment may have a leading character indicating the type of
+// version to create:
+//
+// p: create a "plain" (non-semver) version.
+// b: create a branch version.
+// r: create a revision.
+//
+// No prefix is assumed to indicate a semver version.
+//
+// If a third space-delimited element is provided, it will be interepreted as a
+// revision, and used as the underlying version in a PairedVersion. No prefix
+// should be provided in this case. It is an error (and will panic) to try to
+// pass a revision with an underlying revision.
+func mkAtom(info string) atom {
+ id, ver, rev := nvrSplit(info)
+
+ var v Version
+ switch ver[0] {
+ case 'r':
+ if rev != "" {
+ panic("Cannot pair a revision with a revision")
+ }
+ v = Revision(ver[1:])
+ case 'p':
+ v = NewVersion(ver[1:])
+ case 'b':
+ v = NewBranch(ver[1:])
+ default:
+ _, err := semver.NewVersion(ver)
+ if err != nil {
+ // don't want to allow bad test data at this level, so just panic
+ panic(fmt.Sprintf("Error when converting '%s' into semver: %s", ver, err))
+ }
+ v = NewVersion(ver)
+ }
+
+ if rev != "" {
+ v = v.(UnpairedVersion).Is(rev)
+ }
+
+ return atom{
+ id: id,
+ v: v,
+ }
+}
+
+// mkPDep splits the input string on a space, and uses the first two elements
+// as the project identifier and constraint body, respectively.
+//
+// The constraint body may have a leading character indicating the type of
+// version to create:
+//
+// p: create a "plain" (non-semver) version.
+// b: create a branch version.
+// r: create a revision.
+//
+// If no leading character is used, a semver constraint is assumed.
+func mkPDep(info string) ProjectConstraint {
+ id, ver, rev := nvrSplit(info)
+
+ var c Constraint
+ switch ver[0] {
+ case 'r':
+ c = Revision(ver[1:])
+ case 'p':
+ c = NewVersion(ver[1:])
+ case 'b':
+ c = NewBranch(ver[1:])
+ default:
+ // Without one of those leading characters, we know it's a proper semver
+ // expression, so use the other parser that doesn't look for a rev
+ rev = ""
+ id, ver = nvSplit(info)
+ var err error
+ c, err = NewSemverConstraint(ver)
+ if err != nil {
+ // don't want bad test data at this level, so just panic
+ panic(fmt.Sprintf("Error when converting '%s' into semver constraint: %s (full info: %s)", ver, err, info))
+ }
+ }
+
+ // There's no practical reason that a real tool would need to produce a
+ // constraint that's a PairedVersion, but it is a possibility admitted by the
+ // system, so we at least allow for it in our testing harness.
+ if rev != "" {
+ // Of course, this *will* panic if the predicate is a revision or a
+ // semver constraint, neither of which implement UnpairedVersion. This
+ // is as intended, to prevent bad data from entering the system.
+ c = c.(UnpairedVersion).Is(rev)
+ }
+
+ return ProjectConstraint{
+ Ident: id,
+ Constraint: c,
+ }
+}
+
+// A depspec is a fixture representing all the information a SourceManager would
+// ordinarily glean directly from interrogating a repository.
+type depspec struct {
+ n ProjectRoot
+ v Version
+ deps []ProjectConstraint
+ devdeps []ProjectConstraint
+ pkgs []tpkg
+}
+
+// mkDepspec creates a depspec by processing a series of strings, each of which
+// contains an identiifer and version information.
+//
+// The first string is broken out into the name and version of the package being
+// described - see the docs on mkAtom for details. subsequent strings are
+// interpreted as dep constraints of that dep at that version. See the docs on
+// mkPDep for details.
+//
+// If a string other than the first includes a "(dev) " prefix, it will be
+// treated as a test-only dependency.
+func mkDepspec(pi string, deps ...string) depspec {
+ pa := mkAtom(pi)
+ if string(pa.id.ProjectRoot) != pa.id.NetworkName {
+ panic("alternate source on self makes no sense")
+ }
+
+ ds := depspec{
+ n: pa.id.ProjectRoot,
+ v: pa.v,
+ }
+
+ for _, dep := range deps {
+ var sl *[]ProjectConstraint
+ if strings.HasPrefix(dep, "(dev) ") {
+ dep = strings.TrimPrefix(dep, "(dev) ")
+ sl = &ds.devdeps
+ } else {
+ sl = &ds.deps
+ }
+
+ *sl = append(*sl, mkPDep(dep))
+ }
+
+ return ds
+}
+
+// mklock makes a fixLock, suitable to act as a lock file
+func mklock(pairs ...string) fixLock {
+ l := make(fixLock, 0)
+ for _, s := range pairs {
+ pa := mkAtom(s)
+ l = append(l, NewLockedProject(pa.id.ProjectRoot, pa.v, pa.id.netName(), nil))
+ }
+
+ return l
+}
+
+// mkrevlock makes a fixLock, suitable to act as a lock file, with only a name
+// and a rev
+func mkrevlock(pairs ...string) fixLock {
+ l := make(fixLock, 0)
+ for _, s := range pairs {
+ pa := mkAtom(s)
+ l = append(l, NewLockedProject(pa.id.ProjectRoot, pa.v.(PairedVersion).Underlying(), pa.id.netName(), nil))
+ }
+
+ return l
+}
+
+// mksolution makes a result set
+func mksolution(pairs ...string) map[string]Version {
+ m := make(map[string]Version)
+ for _, pair := range pairs {
+ a := mkAtom(pair)
+ // TODO(sdboyer) identifierify
+ m[string(a.id.ProjectRoot)] = a.v
+ }
+
+ return m
+}
+
+// computeBasicReachMap takes a depspec and computes a reach map which is
+// identical to the explicit depgraph.
+//
+// Using a reachMap here is overkill for what the basic fixtures actually need,
+// but we use it anyway for congruence with the more general cases.
+func computeBasicReachMap(ds []depspec) reachMap {
+ rm := make(reachMap)
+
+ for k, d := range ds {
+ n := string(d.n)
+ lm := map[string][]string{
+ n: nil,
+ }
+ v := d.v
+ if k == 0 {
+ // Put the root in with a nil rev, to accommodate the solver
+ v = nil
+ }
+ rm[pident{n: d.n, v: v}] = lm
+
+ for _, dep := range d.deps {
+ lm[n] = append(lm[n], string(dep.Ident.ProjectRoot))
+ }
+
+ // first is root
+ if k == 0 {
+ for _, dep := range d.devdeps {
+ lm[n] = append(lm[n], string(dep.Ident.ProjectRoot))
+ }
+ }
+ }
+
+ return rm
+}
+
+type pident struct {
+ n ProjectRoot
+ v Version
+}
+
+type specfix interface {
+ name() string
+ specs() []depspec
+ maxTries() int
+ expectErrs() []string
+ solution() map[string]Version
+}
+
+// A basicFixture is a declarative test fixture that can cover a wide variety of
+// solver cases. All cases, however, maintain one invariant: package == project.
+// There are no subpackages, and so it is impossible for them to trigger or
+// require bimodal solving.
+//
+// This type is separate from bimodalFixture in part for legacy reasons - many
+// of these were adapted from similar tests in dart's pub lib, where there is no
+// such thing as "bimodal solving".
+//
+// But it's also useful to keep them separate because bimodal solving involves
+// considerably more complexity than simple solving, both in terms of fixture
+// declaration and actual solving mechanics. Thus, we gain a lot of value for
+// contributors and maintainers by keeping comprehension costs relatively low
+// while still covering important cases.
+type basicFixture struct {
+ // name of this fixture datum
+ n string
+ // depspecs. always treat first as root
+ ds []depspec
+ // results; map of name/version pairs
+ r map[string]Version
+ // max attempts the solver should need to find solution. 0 means no limit
+ maxAttempts int
+ // Use downgrade instead of default upgrade sorter
+ downgrade bool
+ // lock file simulator, if one's to be used at all
+ l fixLock
+ // projects expected to have errors, if any
+ errp []string
+ // request up/downgrade to all projects
+ changeall bool
+}
+
+func (f basicFixture) name() string {
+ return f.n
+}
+
+func (f basicFixture) specs() []depspec {
+ return f.ds
+}
+
+func (f basicFixture) maxTries() int {
+ return f.maxAttempts
+}
+
+func (f basicFixture) expectErrs() []string {
+ return f.errp
+}
+
+func (f basicFixture) solution() map[string]Version {
+ return f.r
+}
+
+// A table of basicFixtures, used in the basic solving test set.
+var basicFixtures = map[string]basicFixture{
+ // basic fixtures
+ "no dependencies": {
+ ds: []depspec{
+ mkDepspec("root 0.0.0"),
+ },
+ r: mksolution(),
+ },
+ "simple dependency tree": {
+ ds: []depspec{
+ mkDepspec("root 0.0.0", "a 1.0.0", "b 1.0.0"),
+ mkDepspec("a 1.0.0", "aa 1.0.0", "ab 1.0.0"),
+ mkDepspec("aa 1.0.0"),
+ mkDepspec("ab 1.0.0"),
+ mkDepspec("b 1.0.0", "ba 1.0.0", "bb 1.0.0"),
+ mkDepspec("ba 1.0.0"),
+ mkDepspec("bb 1.0.0"),
+ },
+ r: mksolution(
+ "a 1.0.0",
+ "aa 1.0.0",
+ "ab 1.0.0",
+ "b 1.0.0",
+ "ba 1.0.0",
+ "bb 1.0.0",
+ ),
+ },
+ "shared dependency with overlapping constraints": {
+ ds: []depspec{
+ mkDepspec("root 0.0.0", "a 1.0.0", "b 1.0.0"),
+ mkDepspec("a 1.0.0", "shared >=2.0.0, <4.0.0"),
+ mkDepspec("b 1.0.0", "shared >=3.0.0, <5.0.0"),
+ mkDepspec("shared 2.0.0"),
+ mkDepspec("shared 3.0.0"),
+ mkDepspec("shared 3.6.9"),
+ mkDepspec("shared 4.0.0"),
+ mkDepspec("shared 5.0.0"),
+ },
+ r: mksolution(
+ "a 1.0.0",
+ "b 1.0.0",
+ "shared 3.6.9",
+ ),
+ },
+ "downgrade on overlapping constraints": {
+ ds: []depspec{
+ mkDepspec("root 0.0.0", "a 1.0.0", "b 1.0.0"),
+ mkDepspec("a 1.0.0", "shared >=2.0.0, <=4.0.0"),
+ mkDepspec("b 1.0.0", "shared >=3.0.0, <5.0.0"),
+ mkDepspec("shared 2.0.0"),
+ mkDepspec("shared 3.0.0"),
+ mkDepspec("shared 3.6.9"),
+ mkDepspec("shared 4.0.0"),
+ mkDepspec("shared 5.0.0"),
+ },
+ r: mksolution(
+ "a 1.0.0",
+ "b 1.0.0",
+ "shared 3.0.0",
+ ),
+ downgrade: true,
+ },
+ "shared dependency where dependent version in turn affects other dependencies": {
+ ds: []depspec{
+ mkDepspec("root 0.0.0", "foo <=1.0.2", "bar 1.0.0"),
+ mkDepspec("foo 1.0.0"),
+ mkDepspec("foo 1.0.1", "bang 1.0.0"),
+ mkDepspec("foo 1.0.2", "whoop 1.0.0"),
+ mkDepspec("foo 1.0.3", "zoop 1.0.0"),
+ mkDepspec("bar 1.0.0", "foo <=1.0.1"),
+ mkDepspec("bang 1.0.0"),
+ mkDepspec("whoop 1.0.0"),
+ mkDepspec("zoop 1.0.0"),
+ },
+ r: mksolution(
+ "foo 1.0.1",
+ "bar 1.0.0",
+ "bang 1.0.0",
+ ),
+ },
+ "removed dependency": {
+ ds: []depspec{
+ mkDepspec("root 1.0.0", "foo 1.0.0", "bar *"),
+ mkDepspec("foo 1.0.0"),
+ mkDepspec("foo 2.0.0"),
+ mkDepspec("bar 1.0.0"),
+ mkDepspec("bar 2.0.0", "baz 1.0.0"),
+ mkDepspec("baz 1.0.0", "foo 2.0.0"),
+ },
+ r: mksolution(
+ "foo 1.0.0",
+ "bar 1.0.0",
+ ),
+ maxAttempts: 2,
+ },
+ "with mismatched net addrs": {
+ ds: []depspec{
+ mkDepspec("root 1.0.0", "foo 1.0.0", "bar 1.0.0"),
+ mkDepspec("foo 1.0.0", "bar from baz 1.0.0"),
+ mkDepspec("bar 1.0.0"),
+ },
+ // TODO(sdboyer) ugh; do real error comparison instead of shitty abstraction
+ errp: []string{"foo", "foo", "root"},
+ },
+ // fixtures with locks
+ "with compatible locked dependency": {
+ ds: []depspec{
+ mkDepspec("root 0.0.0", "foo *"),
+ mkDepspec("foo 1.0.0", "bar 1.0.0"),
+ mkDepspec("foo 1.0.1", "bar 1.0.1"),
+ mkDepspec("foo 1.0.2", "bar 1.0.2"),
+ mkDepspec("bar 1.0.0"),
+ mkDepspec("bar 1.0.1"),
+ mkDepspec("bar 1.0.2"),
+ },
+ l: mklock(
+ "foo 1.0.1",
+ ),
+ r: mksolution(
+ "foo 1.0.1",
+ "bar 1.0.1",
+ ),
+ },
+ "upgrade through lock": {
+ ds: []depspec{
+ mkDepspec("root 0.0.0", "foo *"),
+ mkDepspec("foo 1.0.0", "bar 1.0.0"),
+ mkDepspec("foo 1.0.1", "bar 1.0.1"),
+ mkDepspec("foo 1.0.2", "bar 1.0.2"),
+ mkDepspec("bar 1.0.0"),
+ mkDepspec("bar 1.0.1"),
+ mkDepspec("bar 1.0.2"),
+ },
+ l: mklock(
+ "foo 1.0.1",
+ ),
+ r: mksolution(
+ "foo 1.0.2",
+ "bar 1.0.2",
+ ),
+ changeall: true,
+ },
+ "downgrade through lock": {
+ ds: []depspec{
+ mkDepspec("root 0.0.0", "foo *"),
+ mkDepspec("foo 1.0.0", "bar 1.0.0"),
+ mkDepspec("foo 1.0.1", "bar 1.0.1"),
+ mkDepspec("foo 1.0.2", "bar 1.0.2"),
+ mkDepspec("bar 1.0.0"),
+ mkDepspec("bar 1.0.1"),
+ mkDepspec("bar 1.0.2"),
+ },
+ l: mklock(
+ "foo 1.0.1",
+ ),
+ r: mksolution(
+ "foo 1.0.0",
+ "bar 1.0.0",
+ ),
+ changeall: true,
+ downgrade: true,
+ },
+ "with incompatible locked dependency": {
+ ds: []depspec{
+ mkDepspec("root 0.0.0", "foo >1.0.1"),
+ mkDepspec("foo 1.0.0", "bar 1.0.0"),
+ mkDepspec("foo 1.0.1", "bar 1.0.1"),
+ mkDepspec("foo 1.0.2", "bar 1.0.2"),
+ mkDepspec("bar 1.0.0"),
+ mkDepspec("bar 1.0.1"),
+ mkDepspec("bar 1.0.2"),
+ },
+ l: mklock(
+ "foo 1.0.1",
+ ),
+ r: mksolution(
+ "foo 1.0.2",
+ "bar 1.0.2",
+ ),
+ },
+ "with unrelated locked dependency": {
+ ds: []depspec{
+ mkDepspec("root 0.0.0", "foo *"),
+ mkDepspec("foo 1.0.0", "bar 1.0.0"),
+ mkDepspec("foo 1.0.1", "bar 1.0.1"),
+ mkDepspec("foo 1.0.2", "bar 1.0.2"),
+ mkDepspec("bar 1.0.0"),
+ mkDepspec("bar 1.0.1"),
+ mkDepspec("bar 1.0.2"),
+ mkDepspec("baz 1.0.0 bazrev"),
+ },
+ l: mklock(
+ "baz 1.0.0 bazrev",
+ ),
+ r: mksolution(
+ "foo 1.0.2",
+ "bar 1.0.2",
+ ),
+ },
+ "unlocks dependencies if necessary to ensure that a new dependency is satisfied": {
+ ds: []depspec{
+ mkDepspec("root 0.0.0", "foo *", "newdep *"),
+ mkDepspec("foo 1.0.0 foorev", "bar <2.0.0"),
+ mkDepspec("bar 1.0.0 barrev", "baz <2.0.0"),
+ mkDepspec("baz 1.0.0 bazrev", "qux <2.0.0"),
+ mkDepspec("qux 1.0.0 quxrev"),
+ mkDepspec("foo 2.0.0", "bar <3.0.0"),
+ mkDepspec("bar 2.0.0", "baz <3.0.0"),
+ mkDepspec("baz 2.0.0", "qux <3.0.0"),
+ mkDepspec("qux 2.0.0"),
+ mkDepspec("newdep 2.0.0", "baz >=1.5.0"),
+ },
+ l: mklock(
+ "foo 1.0.0 foorev",
+ "bar 1.0.0 barrev",
+ "baz 1.0.0 bazrev",
+ "qux 1.0.0 quxrev",
+ ),
+ r: mksolution(
+ "foo 2.0.0",
+ "bar 2.0.0",
+ "baz 2.0.0",
+ "qux 1.0.0 quxrev",
+ "newdep 2.0.0",
+ ),
+ maxAttempts: 4,
+ },
+ "locked atoms are matched on both local and net name": {
+ ds: []depspec{
+ mkDepspec("root 0.0.0", "foo *"),
+ mkDepspec("foo 1.0.0 foorev"),
+ mkDepspec("foo 2.0.0 foorev2"),
+ },
+ l: mklock(
+ "foo from baz 1.0.0 foorev",
+ ),
+ r: mksolution(
+ "foo 2.0.0 foorev2",
+ ),
+ },
+ "pairs bare revs in lock with versions": {
+ ds: []depspec{
+ mkDepspec("root 0.0.0", "foo ~1.0.1"),
+ mkDepspec("foo 1.0.0", "bar 1.0.0"),
+ mkDepspec("foo 1.0.1 foorev", "bar 1.0.1"),
+ mkDepspec("foo 1.0.2", "bar 1.0.2"),
+ mkDepspec("bar 1.0.0"),
+ mkDepspec("bar 1.0.1"),
+ mkDepspec("bar 1.0.2"),
+ },
+ l: mkrevlock(
+ "foo 1.0.1 foorev", // mkrevlock drops the 1.0.1
+ ),
+ r: mksolution(
+ "foo 1.0.1 foorev",
+ "bar 1.0.1",
+ ),
+ },
+ "pairs bare revs in lock with all versions": {
+ ds: []depspec{
+ mkDepspec("root 0.0.0", "foo ~1.0.1"),
+ mkDepspec("foo 1.0.0", "bar 1.0.0"),
+ mkDepspec("foo 1.0.1 foorev", "bar 1.0.1"),
+ mkDepspec("foo 1.0.2 foorev", "bar 1.0.2"),
+ mkDepspec("bar 1.0.0"),
+ mkDepspec("bar 1.0.1"),
+ mkDepspec("bar 1.0.2"),
+ },
+ l: mkrevlock(
+ "foo 1.0.1 foorev", // mkrevlock drops the 1.0.1
+ ),
+ r: mksolution(
+ "foo 1.0.2 foorev",
+ "bar 1.0.1",
+ ),
+ },
+ "does not pair bare revs in manifest with unpaired lock version": {
+ ds: []depspec{
+ mkDepspec("root 0.0.0", "foo ~1.0.1"),
+ mkDepspec("foo 1.0.0", "bar 1.0.0"),
+ mkDepspec("foo 1.0.1 foorev", "bar 1.0.1"),
+ mkDepspec("foo 1.0.2", "bar 1.0.2"),
+ mkDepspec("bar 1.0.0"),
+ mkDepspec("bar 1.0.1"),
+ mkDepspec("bar 1.0.2"),
+ },
+ l: mkrevlock(
+ "foo 1.0.1 foorev", // mkrevlock drops the 1.0.1
+ ),
+ r: mksolution(
+ "foo 1.0.1 foorev",
+ "bar 1.0.1",
+ ),
+ },
+ "includes root package's dev dependencies": {
+ ds: []depspec{
+ mkDepspec("root 1.0.0", "(dev) foo 1.0.0", "(dev) bar 1.0.0"),
+ mkDepspec("foo 1.0.0"),
+ mkDepspec("bar 1.0.0"),
+ },
+ r: mksolution(
+ "foo 1.0.0",
+ "bar 1.0.0",
+ ),
+ },
+ "includes dev dependency's transitive dependencies": {
+ ds: []depspec{
+ mkDepspec("root 1.0.0", "(dev) foo 1.0.0"),
+ mkDepspec("foo 1.0.0", "bar 1.0.0"),
+ mkDepspec("bar 1.0.0"),
+ },
+ r: mksolution(
+ "foo 1.0.0",
+ "bar 1.0.0",
+ ),
+ },
+ "ignores transitive dependency's dev dependencies": {
+ ds: []depspec{
+ mkDepspec("root 1.0.0", "(dev) foo 1.0.0"),
+ mkDepspec("foo 1.0.0", "(dev) bar 1.0.0"),
+ mkDepspec("bar 1.0.0"),
+ },
+ r: mksolution(
+ "foo 1.0.0",
+ ),
+ },
+ "no version that matches requirement": {
+ ds: []depspec{
+ mkDepspec("root 0.0.0", "foo >=1.0.0, <2.0.0"),
+ mkDepspec("foo 2.0.0"),
+ mkDepspec("foo 2.1.3"),
+ },
+ errp: []string{"foo", "root"},
+ },
+ "no version that matches combined constraint": {
+ ds: []depspec{
+ mkDepspec("root 0.0.0", "foo 1.0.0", "bar 1.0.0"),
+ mkDepspec("foo 1.0.0", "shared >=2.0.0, <3.0.0"),
+ mkDepspec("bar 1.0.0", "shared >=2.9.0, <4.0.0"),
+ mkDepspec("shared 2.5.0"),
+ mkDepspec("shared 3.5.0"),
+ },
+ errp: []string{"shared", "foo", "bar"},
+ },
+ "disjoint constraints": {
+ ds: []depspec{
+ mkDepspec("root 0.0.0", "foo 1.0.0", "bar 1.0.0"),
+ mkDepspec("foo 1.0.0", "shared <=2.0.0"),
+ mkDepspec("bar 1.0.0", "shared >3.0.0"),
+ mkDepspec("shared 2.0.0"),
+ mkDepspec("shared 4.0.0"),
+ },
+ //errp: []string{"shared", "foo", "bar"}, // dart's has this...
+ errp: []string{"foo", "bar"},
+ },
+ "no valid solution": {
+ ds: []depspec{
+ mkDepspec("root 0.0.0", "a *", "b *"),
+ mkDepspec("a 1.0.0", "b 1.0.0"),
+ mkDepspec("a 2.0.0", "b 2.0.0"),
+ mkDepspec("b 1.0.0", "a 2.0.0"),
+ mkDepspec("b 2.0.0", "a 1.0.0"),
+ },
+ errp: []string{"b", "a"},
+ maxAttempts: 2,
+ },
+ "no version that matches while backtracking": {
+ ds: []depspec{
+ mkDepspec("root 0.0.0", "a *", "b >1.0.0"),
+ mkDepspec("a 1.0.0"),
+ mkDepspec("b 1.0.0"),
+ },
+ errp: []string{"b", "root"},
+ },
+ // The latest versions of a and b disagree on c. An older version of either
+ // will resolve the problem. This test validates that b, which is farther
+ // in the dependency graph from myapp is downgraded first.
+ "rolls back leaf versions first": {
+ ds: []depspec{
+ mkDepspec("root 0.0.0", "a *"),
+ mkDepspec("a 1.0.0", "b *"),
+ mkDepspec("a 2.0.0", "b *", "c 2.0.0"),
+ mkDepspec("b 1.0.0"),
+ mkDepspec("b 2.0.0", "c 1.0.0"),
+ mkDepspec("c 1.0.0"),
+ mkDepspec("c 2.0.0"),
+ },
+ r: mksolution(
+ "a 2.0.0",
+ "b 1.0.0",
+ "c 2.0.0",
+ ),
+ maxAttempts: 2,
+ },
+ // Only one version of baz, so foo and bar will have to downgrade until they
+ // reach it.
+ "mutual downgrading": {
+ ds: []depspec{
+ mkDepspec("root 0.0.0", "foo *"),
+ mkDepspec("foo 1.0.0", "bar 1.0.0"),
+ mkDepspec("foo 2.0.0", "bar 2.0.0"),
+ mkDepspec("foo 3.0.0", "bar 3.0.0"),
+ mkDepspec("bar 1.0.0", "baz *"),
+ mkDepspec("bar 2.0.0", "baz 2.0.0"),
+ mkDepspec("bar 3.0.0", "baz 3.0.0"),
+ mkDepspec("baz 1.0.0"),
+ },
+ r: mksolution(
+ "foo 1.0.0",
+ "bar 1.0.0",
+ "baz 1.0.0",
+ ),
+ maxAttempts: 3,
+ },
+ // Ensures the solver doesn't exhaustively search all versions of b when
+ // it's a-2.0.0 whose dependency on c-2.0.0-nonexistent led to the
+ // problem. We make sure b has more versions than a so that the solver
+ // tries a first since it sorts sibling dependencies by number of
+ // versions.
+ "search real failer": {
+ ds: []depspec{
+ mkDepspec("root 0.0.0", "a *", "b *"),
+ mkDepspec("a 1.0.0", "c 1.0.0"),
+ mkDepspec("a 2.0.0", "c 2.0.0"),
+ mkDepspec("b 1.0.0"),
+ mkDepspec("b 2.0.0"),
+ mkDepspec("b 3.0.0"),
+ mkDepspec("c 1.0.0"),
+ },
+ r: mksolution(
+ "a 1.0.0",
+ "b 3.0.0",
+ "c 1.0.0",
+ ),
+ maxAttempts: 2,
+ },
+ // Dependencies are ordered so that packages with fewer versions are tried
+ // first. Here, there are two valid solutions (either a or b must be
+ // downgraded once). The chosen one depends on which dep is traversed first.
+ // Since b has fewer versions, it will be traversed first, which means a
+ // will come later. Since later selections are revised first, a gets
+ // downgraded.
+ "traverse into package with fewer versions first": {
+ ds: []depspec{
+ mkDepspec("root 0.0.0", "a *", "b *"),
+ mkDepspec("a 1.0.0", "c *"),
+ mkDepspec("a 2.0.0", "c *"),
+ mkDepspec("a 3.0.0", "c *"),
+ mkDepspec("a 4.0.0", "c *"),
+ mkDepspec("a 5.0.0", "c 1.0.0"),
+ mkDepspec("b 1.0.0", "c *"),
+ mkDepspec("b 2.0.0", "c *"),
+ mkDepspec("b 3.0.0", "c *"),
+ mkDepspec("b 4.0.0", "c 2.0.0"),
+ mkDepspec("c 1.0.0"),
+ mkDepspec("c 2.0.0"),
+ },
+ r: mksolution(
+ "a 4.0.0",
+ "b 4.0.0",
+ "c 2.0.0",
+ ),
+ maxAttempts: 2,
+ },
+ // This is similar to the preceding fixture. When getting the number of
+ // versions of a package to determine which to traverse first, versions that
+ // are disallowed by the root package's constraints should not be
+ // considered. Here, foo has more versions than bar in total (4), but fewer
+ // that meet myapp"s constraints (only 2). There is no solution, but we will
+ // do less backtracking if foo is tested first.
+ "root constraints pre-eliminate versions": {
+ ds: []depspec{
+ mkDepspec("root 0.0.0", "foo *", "bar *"),
+ mkDepspec("foo 1.0.0", "none 2.0.0"),
+ mkDepspec("foo 2.0.0", "none 2.0.0"),
+ mkDepspec("foo 3.0.0", "none 2.0.0"),
+ mkDepspec("foo 4.0.0", "none 2.0.0"),
+ mkDepspec("bar 1.0.0"),
+ mkDepspec("bar 2.0.0"),
+ mkDepspec("bar 3.0.0"),
+ mkDepspec("none 1.0.0"),
+ },
+ errp: []string{"none", "foo"},
+ maxAttempts: 1,
+ },
+ // If there"s a disjoint constraint on a package, then selecting other
+ // versions of it is a waste of time: no possible versions can match. We
+ // need to jump past it to the most recent package that affected the
+ // constraint.
+ "backjump past failed package on disjoint constraint": {
+ ds: []depspec{
+ mkDepspec("root 0.0.0", "a *", "foo *"),
+ mkDepspec("a 1.0.0", "foo *"),
+ mkDepspec("a 2.0.0", "foo <1.0.0"),
+ mkDepspec("foo 2.0.0"),
+ mkDepspec("foo 2.0.1"),
+ mkDepspec("foo 2.0.2"),
+ mkDepspec("foo 2.0.3"),
+ mkDepspec("foo 2.0.4"),
+ mkDepspec("none 1.0.0"),
+ },
+ r: mksolution(
+ "a 1.0.0",
+ "foo 2.0.4",
+ ),
+ maxAttempts: 2,
+ },
+ // Revision enters vqueue if a dep has a constraint on that revision
+ "revision injected into vqueue": {
+ ds: []depspec{
+ mkDepspec("root 0.0.0", "foo r123abc"),
+ mkDepspec("foo r123abc"),
+ mkDepspec("foo 1.0.0 foorev"),
+ mkDepspec("foo 2.0.0 foorev2"),
+ },
+ r: mksolution(
+ "foo r123abc",
+ ),
+ },
+ // TODO(sdboyer) decide how to refactor the solver in order to re-enable these.
+ // Checking for revision existence is important...but kinda obnoxious.
+ //{
+ //// Solve fails if revision constraint calls for a nonexistent revision
+ //n: "fail on missing revision",
+ //ds: []depspec{
+ //mkDepspec("root 0.0.0", "bar *"),
+ //mkDepspec("bar 1.0.0", "foo r123abc"),
+ //mkDepspec("foo r123nomatch"),
+ //mkDepspec("foo 1.0.0"),
+ //mkDepspec("foo 2.0.0"),
+ //},
+ //errp: []string{"bar", "foo", "bar"},
+ //},
+ //{
+ //// Solve fails if revision constraint calls for a nonexistent revision,
+ //// even if rev constraint is specified by root
+ //n: "fail on missing revision from root",
+ //ds: []depspec{
+ //mkDepspec("root 0.0.0", "foo r123nomatch"),
+ //mkDepspec("foo r123abc"),
+ //mkDepspec("foo 1.0.0"),
+ //mkDepspec("foo 2.0.0"),
+ //},
+ //errp: []string{"foo", "root", "foo"},
+ //},
+
+ // TODO(sdboyer) add fixture that tests proper handling of loops via aliases (where
+ // a project that wouldn't be a loop is aliased to a project that is a loop)
+}
+
+func init() {
+ // This sets up a hundred versions of foo and bar, 0.0.0 through 9.9.0. Each
+ // version of foo depends on a baz with the same major version. Each version
+ // of bar depends on a baz with the same minor version. There is only one
+ // version of baz, 0.0.0, so only older versions of foo and bar will
+ // satisfy it.
+ fix := basicFixture{
+ ds: []depspec{
+ mkDepspec("root 0.0.0", "foo *", "bar *"),
+ mkDepspec("baz 0.0.0"),
+ },
+ r: mksolution(
+ "foo 0.9.0",
+ "bar 9.0.0",
+ "baz 0.0.0",
+ ),
+ maxAttempts: 10,
+ }
+
+ for i := 0; i < 10; i++ {
+ for j := 0; j < 10; j++ {
+ fix.ds = append(fix.ds, mkDepspec(fmt.Sprintf("foo %v.%v.0", i, j), fmt.Sprintf("baz %v.0.0", i)))
+ fix.ds = append(fix.ds, mkDepspec(fmt.Sprintf("bar %v.%v.0", i, j), fmt.Sprintf("baz 0.%v.0", j)))
+ }
+ }
+
+ basicFixtures["complex backtrack"] = fix
+
+ for k, fix := range basicFixtures {
+ // Assign the name into the fixture itself
+ fix.n = k
+ basicFixtures[k] = fix
+ }
+}
+
+// reachMaps contain externalReach()-type data for a given depspec fixture's
+// universe of proejcts, packages, and versions.
+type reachMap map[pident]map[string][]string
+
+type depspecSourceManager struct {
+ specs []depspec
+ rm reachMap
+ ig map[string]bool
+}
+
+type fixSM interface {
+ SourceManager
+ rootSpec() depspec
+ allSpecs() []depspec
+ ignore() map[string]bool
+}
+
+var _ fixSM = &depspecSourceManager{}
+
+func newdepspecSM(ds []depspec, ignore []string) *depspecSourceManager {
+ ig := make(map[string]bool)
+ if len(ignore) > 0 {
+ for _, pkg := range ignore {
+ ig[pkg] = true
+ }
+ }
+
+ return &depspecSourceManager{
+ specs: ds,
+ rm: computeBasicReachMap(ds),
+ ig: ig,
+ }
+}
+
+func (sm *depspecSourceManager) GetProjectInfo(n ProjectRoot, v Version) (Manifest, Lock, error) {
+ for _, ds := range sm.specs {
+ if n == ds.n && v.Matches(ds.v) {
+ return ds, dummyLock{}, nil
+ }
+ }
+
+ // TODO(sdboyer) proper solver-type errors
+ return nil, nil, fmt.Errorf("Project %s at version %s could not be found", n, v)
+}
+
+func (sm *depspecSourceManager) ExternalReach(n ProjectRoot, v Version) (map[string][]string, error) {
+ id := pident{n: n, v: v}
+ if m, exists := sm.rm[id]; exists {
+ return m, nil
+ }
+ return nil, fmt.Errorf("No reach data for %s at version %s", n, v)
+}
+
+func (sm *depspecSourceManager) ListExternal(n ProjectRoot, v Version) ([]string, error) {
+ // This should only be called for the root
+ id := pident{n: n, v: v}
+ if r, exists := sm.rm[id]; exists {
+ return r[string(n)], nil
+ }
+ return nil, fmt.Errorf("No reach data for %s at version %s", n, v)
+}
+
+func (sm *depspecSourceManager) ListPackages(n ProjectRoot, v Version) (PackageTree, error) {
+ id := pident{n: n, v: v}
+ if r, exists := sm.rm[id]; exists {
+ ptree := PackageTree{
+ ImportRoot: string(n),
+ Packages: map[string]PackageOrErr{
+ string(n): {
+ P: Package{
+ ImportPath: string(n),
+ Name: string(n),
+ Imports: r[string(n)],
+ },
+ },
+ },
+ }
+ return ptree, nil
+ }
+
+ return PackageTree{}, fmt.Errorf("Project %s at version %s could not be found", n, v)
+}
+
+func (sm *depspecSourceManager) ListVersions(name ProjectRoot) (pi []Version, err error) {
+ for _, ds := range sm.specs {
+ // To simulate the behavior of the real SourceManager, we do not return
+ // revisions from ListVersions().
+ if _, isrev := ds.v.(Revision); !isrev && name == ds.n {
+ pi = append(pi, ds.v)
+ }
+ }
+
+ if len(pi) == 0 {
+ err = fmt.Errorf("Project %s could not be found", name)
+ }
+
+ return
+}
+
+func (sm *depspecSourceManager) RevisionPresentIn(name ProjectRoot, r Revision) (bool, error) {
+ for _, ds := range sm.specs {
+ if name == ds.n && r == ds.v {
+ return true, nil
+ }
+ }
+
+ return false, fmt.Errorf("Project %s has no revision %s", name, r)
+}
+
+func (sm *depspecSourceManager) RepoExists(name ProjectRoot) (bool, error) {
+ for _, ds := range sm.specs {
+ if name == ds.n {
+ return true, nil
+ }
+ }
+
+ return false, nil
+}
+
+func (sm *depspecSourceManager) VendorCodeExists(name ProjectRoot) (bool, error) {
+ return false, nil
+}
+
+func (sm *depspecSourceManager) Release() {}
+
+func (sm *depspecSourceManager) ExportProject(n ProjectRoot, v Version, to string) error {
+ return fmt.Errorf("dummy sm doesn't support exporting")
+}
+
+func (sm *depspecSourceManager) rootSpec() depspec {
+ return sm.specs[0]
+}
+
+func (sm *depspecSourceManager) allSpecs() []depspec {
+ return sm.specs
+}
+
+func (sm *depspecSourceManager) ignore() map[string]bool {
+ return sm.ig
+}
+
+type depspecBridge struct {
+ *bridge
+}
+
+// override computeRootReach() on bridge to read directly out of the depspecs
+func (b *depspecBridge) computeRootReach() ([]string, error) {
+ // This only gets called for the root project, so grab that one off the test
+ // source manager
+ dsm := b.sm.(fixSM)
+ root := dsm.rootSpec()
+
+ ptree, err := dsm.ListPackages(root.n, nil)
+ if err != nil {
+ return nil, err
+ }
+
+ return ptree.ListExternalImports(true, true, dsm.ignore()), nil
+}
+
+// override verifyRoot() on bridge to prevent any filesystem interaction
+func (b *depspecBridge) verifyRootDir(path string) error {
+ root := b.sm.(fixSM).rootSpec()
+ if string(root.n) != path {
+ return fmt.Errorf("Expected only root project %q to computeRootReach(), got %q", root.n, path)
+ }
+
+ return nil
+}
+
+func (b *depspecBridge) listPackages(id ProjectIdentifier, v Version) (PackageTree, error) {
+ return b.sm.(fixSM).ListPackages(b.key(id), v)
+}
+
+// override deduceRemoteRepo on bridge to make all our pkg/project mappings work
+// as expected
+func (b *depspecBridge) deduceRemoteRepo(path string) (*remoteRepo, error) {
+ for _, ds := range b.sm.(fixSM).allSpecs() {
+ n := string(ds.n)
+ if path == n || strings.HasPrefix(path, n+"/") {
+ return &remoteRepo{
+ Base: n,
+ RelPkg: strings.TrimPrefix(path, n+"/"),
+ }, nil
+ }
+ }
+ return nil, fmt.Errorf("Could not find %s, or any parent, in list of known fixtures", path)
+}
+
+// enforce interfaces
+var _ Manifest = depspec{}
+var _ Lock = dummyLock{}
+var _ Lock = fixLock{}
+
+// impl Spec interface
+func (ds depspec) DependencyConstraints() []ProjectConstraint {
+ return ds.deps
+}
+
+// impl Spec interface
+func (ds depspec) TestDependencyConstraints() []ProjectConstraint {
+ return ds.devdeps
+}
+
+type fixLock []LockedProject
+
+func (fixLock) SolverVersion() string {
+ return "-1"
+}
+
+// impl Lock interface
+func (fixLock) InputHash() []byte {
+ return []byte("fooooorooooofooorooofoo")
+}
+
+// impl Lock interface
+func (l fixLock) Projects() []LockedProject {
+ return l
+}
+
+type dummyLock struct{}
+
+// impl Lock interface
+func (dummyLock) SolverVersion() string {
+ return "-1"
+}
+
+// impl Lock interface
+func (dummyLock) InputHash() []byte {
+ return []byte("fooooorooooofooorooofoo")
+}
+
+// impl Lock interface
+func (dummyLock) Projects() []LockedProject {
+ return nil
+}
+
+// We've borrowed this bestiary from pub's tests:
+// https://github.com/dart-lang/pub/blob/master/test/version_solver_test.dart
+
+// TODO(sdboyer) finish converting all of these
+
+/*
+func basicGraph() {
+ testResolve("circular dependency", {
+ "myapp 1.0.0": {
+ "foo": "1.0.0"
+ },
+ "foo 1.0.0": {
+ "bar": "1.0.0"
+ },
+ "bar 1.0.0": {
+ "foo": "1.0.0"
+ }
+ }, result: {
+ "myapp from root": "1.0.0",
+ "foo": "1.0.0",
+ "bar": "1.0.0"
+ });
+
+}
+
+func withLockFile() {
+
+}
+
+func rootDependency() {
+ testResolve("with root source", {
+ "myapp 1.0.0": {
+ "foo": "1.0.0"
+ },
+ "foo 1.0.0": {
+ "myapp from root": ">=1.0.0"
+ }
+ }, result: {
+ "myapp from root": "1.0.0",
+ "foo": "1.0.0"
+ });
+
+ testResolve("with different source", {
+ "myapp 1.0.0": {
+ "foo": "1.0.0"
+ },
+ "foo 1.0.0": {
+ "myapp": ">=1.0.0"
+ }
+ }, result: {
+ "myapp from root": "1.0.0",
+ "foo": "1.0.0"
+ });
+
+ testResolve("with wrong version", {
+ "myapp 1.0.0": {
+ "foo": "1.0.0"
+ },
+ "foo 1.0.0": {
+ "myapp": "<1.0.0"
+ }
+ }, error: couldNotSolve);
+}
+
+func unsolvable() {
+
+ testResolve("mismatched descriptions", {
+ "myapp 0.0.0": {
+ "foo": "1.0.0",
+ "bar": "1.0.0"
+ },
+ "foo 1.0.0": {
+ "shared-x": "1.0.0"
+ },
+ "bar 1.0.0": {
+ "shared-y": "1.0.0"
+ },
+ "shared-x 1.0.0": {},
+ "shared-y 1.0.0": {}
+ }, error: descriptionMismatch("shared", "foo", "bar"));
+
+ testResolve("mismatched sources", {
+ "myapp 0.0.0": {
+ "foo": "1.0.0",
+ "bar": "1.0.0"
+ },
+ "foo 1.0.0": {
+ "shared": "1.0.0"
+ },
+ "bar 1.0.0": {
+ "shared from mock2": "1.0.0"
+ },
+ "shared 1.0.0": {},
+ "shared 1.0.0 from mock2": {}
+ }, error: sourceMismatch("shared", "foo", "bar"));
+
+
+
+ // This is a regression test for #18300.
+ testResolve("...", {
+ "myapp 0.0.0": {
+ "angular": "any",
+ "collection": "any"
+ },
+ "analyzer 0.12.2": {},
+ "angular 0.10.0": {
+ "di": ">=0.0.32 <0.1.0",
+ "collection": ">=0.9.1 <1.0.0"
+ },
+ "angular 0.9.11": {
+ "di": ">=0.0.32 <0.1.0",
+ "collection": ">=0.9.1 <1.0.0"
+ },
+ "angular 0.9.10": {
+ "di": ">=0.0.32 <0.1.0",
+ "collection": ">=0.9.1 <1.0.0"
+ },
+ "collection 0.9.0": {},
+ "collection 0.9.1": {},
+ "di 0.0.37": {"analyzer": ">=0.13.0 <0.14.0"},
+ "di 0.0.36": {"analyzer": ">=0.13.0 <0.14.0"}
+ }, error: noVersion(["analyzer", "di"]), maxTries: 2);
+}
+
+func badSource() {
+ testResolve("fail if the root package has a bad source in dep", {
+ "myapp 0.0.0": {
+ "foo from bad": "any"
+ },
+ }, error: unknownSource("myapp", "foo", "bad"));
+
+ testResolve("fail if the root package has a bad source in dev dep", {
+ "myapp 0.0.0": {
+ "(dev) foo from bad": "any"
+ },
+ }, error: unknownSource("myapp", "foo", "bad"));
+
+ testResolve("fail if all versions have bad source in dep", {
+ "myapp 0.0.0": {
+ "foo": "any"
+ },
+ "foo 1.0.0": {
+ "bar from bad": "any"
+ },
+ "foo 1.0.1": {
+ "baz from bad": "any"
+ },
+ "foo 1.0.3": {
+ "bang from bad": "any"
+ },
+ }, error: unknownSource("foo", "bar", "bad"), maxTries: 3);
+
+ testResolve("ignore versions with bad source in dep", {
+ "myapp 1.0.0": {
+ "foo": "any"
+ },
+ "foo 1.0.0": {
+ "bar": "any"
+ },
+ "foo 1.0.1": {
+ "bar from bad": "any"
+ },
+ "foo 1.0.3": {
+ "bar from bad": "any"
+ },
+ "bar 1.0.0": {}
+ }, result: {
+ "myapp from root": "1.0.0",
+ "foo": "1.0.0",
+ "bar": "1.0.0"
+ }, maxTries: 3);
+}
+
+func backtracking() {
+ testResolve("circular dependency on older version", {
+ "myapp 0.0.0": {
+ "a": ">=1.0.0"
+ },
+ "a 1.0.0": {},
+ "a 2.0.0": {
+ "b": "1.0.0"
+ },
+ "b 1.0.0": {
+ "a": "1.0.0"
+ }
+ }, result: {
+ "myapp from root": "0.0.0",
+ "a": "1.0.0"
+ }, maxTries: 2);
+}
+*/
diff --git a/vendor/github.com/sdboyer/vsolver/solve_bimodal_test.go b/vendor/github.com/sdboyer/gps/solve_bimodal_test.go
similarity index 65%
rename from vendor/github.com/sdboyer/vsolver/solve_bimodal_test.go
rename to vendor/github.com/sdboyer/gps/solve_bimodal_test.go
index 21df3cb..09333e0 100644
--- a/vendor/github.com/sdboyer/vsolver/solve_bimodal_test.go
+++ b/vendor/github.com/sdboyer/gps/solve_bimodal_test.go
@@ -1,4 +1,4 @@
-package vsolver
+package gps
import (
"fmt"
@@ -37,12 +37,12 @@
// including a single, simple import that is not expressed as a constraint
"simple bm-add": {
ds: []depspec{
- dsp(dsv("root 0.0.0"),
+ dsp(mkDepspec("root 0.0.0"),
pkg("root", "a")),
- dsp(dsv("a 1.0.0"),
+ dsp(mkDepspec("a 1.0.0"),
pkg("a")),
},
- r: mkresults(
+ r: mksolution(
"a 1.0.0",
),
},
@@ -50,77 +50,77 @@
// same path as root, but from a subpkg
"subpkg bm-add": {
ds: []depspec{
- dsp(dsv("root 0.0.0"),
+ dsp(mkDepspec("root 0.0.0"),
pkg("root", "root/foo"),
pkg("root/foo", "a"),
),
- dsp(dsv("a 1.0.0"),
+ dsp(mkDepspec("a 1.0.0"),
pkg("a"),
),
},
- r: mkresults(
+ r: mksolution(
"a 1.0.0",
),
},
// The same, but with a jump through two subpkgs
"double-subpkg bm-add": {
ds: []depspec{
- dsp(dsv("root 0.0.0"),
+ dsp(mkDepspec("root 0.0.0"),
pkg("root", "root/foo"),
pkg("root/foo", "root/bar"),
pkg("root/bar", "a"),
),
- dsp(dsv("a 1.0.0"),
+ dsp(mkDepspec("a 1.0.0"),
pkg("a"),
),
},
- r: mkresults(
+ r: mksolution(
"a 1.0.0",
),
},
// Same again, but now nest the subpkgs
"double nested subpkg bm-add": {
ds: []depspec{
- dsp(dsv("root 0.0.0"),
+ dsp(mkDepspec("root 0.0.0"),
pkg("root", "root/foo"),
pkg("root/foo", "root/foo/bar"),
pkg("root/foo/bar", "a"),
),
- dsp(dsv("a 1.0.0"),
+ dsp(mkDepspec("a 1.0.0"),
pkg("a"),
),
},
- r: mkresults(
+ r: mksolution(
"a 1.0.0",
),
},
// Importing package from project with no root package
"bm-add on project with no pkg in root dir": {
ds: []depspec{
- dsp(dsv("root 0.0.0"),
+ dsp(mkDepspec("root 0.0.0"),
pkg("root", "a/foo")),
- dsp(dsv("a 1.0.0"),
+ dsp(mkDepspec("a 1.0.0"),
pkg("a/foo")),
},
- r: mkresults(
+ r: mksolution(
"a 1.0.0",
),
},
// Import jump is in a dep, and points to a transitive dep
"transitive bm-add": {
ds: []depspec{
- dsp(dsv("root 0.0.0"),
+ dsp(mkDepspec("root 0.0.0"),
pkg("root", "root/foo"),
pkg("root/foo", "a"),
),
- dsp(dsv("a 1.0.0"),
+ dsp(mkDepspec("a 1.0.0"),
pkg("a", "b"),
),
- dsp(dsv("b 1.0.0"),
+ dsp(mkDepspec("b 1.0.0"),
pkg("b"),
),
},
- r: mkresults(
+ r: mksolution(
"a 1.0.0",
"b 1.0.0",
),
@@ -129,21 +129,21 @@
// reachable import
"constraints activated by import": {
ds: []depspec{
- dsp(dsv("root 0.0.0", "b 1.0.0"),
+ dsp(mkDepspec("root 0.0.0", "b 1.0.0"),
pkg("root", "root/foo"),
pkg("root/foo", "a"),
),
- dsp(dsv("a 1.0.0"),
+ dsp(mkDepspec("a 1.0.0"),
pkg("a", "b"),
),
- dsp(dsv("b 1.0.0"),
+ dsp(mkDepspec("b 1.0.0"),
pkg("b"),
),
- dsp(dsv("b 1.1.0"),
+ dsp(mkDepspec("b 1.1.0"),
pkg("b"),
),
},
- r: mkresults(
+ r: mksolution(
"a 1.0.0",
"b 1.1.0",
),
@@ -152,21 +152,21 @@
// the first version we try
"transitive bm-add on older version": {
ds: []depspec{
- dsp(dsv("root 0.0.0", "a ~1.0.0"),
+ dsp(mkDepspec("root 0.0.0", "a ~1.0.0"),
pkg("root", "root/foo"),
pkg("root/foo", "a"),
),
- dsp(dsv("a 1.0.0"),
+ dsp(mkDepspec("a 1.0.0"),
pkg("a", "b"),
),
- dsp(dsv("a 1.1.0"),
+ dsp(mkDepspec("a 1.1.0"),
pkg("a"),
),
- dsp(dsv("b 1.0.0"),
+ dsp(mkDepspec("b 1.0.0"),
pkg("b"),
),
},
- r: mkresults(
+ r: mksolution(
"a 1.0.0",
"b 1.0.0",
),
@@ -175,28 +175,28 @@
// get there via backtracking
"backtrack to dep on bm-add": {
ds: []depspec{
- dsp(dsv("root 0.0.0"),
+ dsp(mkDepspec("root 0.0.0"),
pkg("root", "root/foo"),
pkg("root/foo", "a", "b"),
),
- dsp(dsv("a 1.0.0"),
+ dsp(mkDepspec("a 1.0.0"),
pkg("a", "c"),
),
- dsp(dsv("a 1.1.0"),
+ dsp(mkDepspec("a 1.1.0"),
pkg("a"),
),
// Include two versions of b, otherwise it'll be selected first
- dsp(dsv("b 0.9.0"),
+ dsp(mkDepspec("b 0.9.0"),
pkg("b", "c"),
),
- dsp(dsv("b 1.0.0"),
+ dsp(mkDepspec("b 1.0.0"),
pkg("b", "c"),
),
- dsp(dsv("c 1.0.0", "a 1.0.0"),
+ dsp(mkDepspec("c 1.0.0", "a 1.0.0"),
pkg("c", "a"),
),
},
- r: mkresults(
+ r: mksolution(
"a 1.0.0",
"b 1.0.0",
"c 1.0.0",
@@ -205,19 +205,19 @@
// Import jump is in a dep subpkg, and points to a transitive dep
"transitive subpkg bm-add": {
ds: []depspec{
- dsp(dsv("root 0.0.0"),
+ dsp(mkDepspec("root 0.0.0"),
pkg("root", "root/foo"),
pkg("root/foo", "a"),
),
- dsp(dsv("a 1.0.0"),
+ dsp(mkDepspec("a 1.0.0"),
pkg("a", "a/bar"),
pkg("a/bar", "b"),
),
- dsp(dsv("b 1.0.0"),
+ dsp(mkDepspec("b 1.0.0"),
pkg("b"),
),
},
- r: mkresults(
+ r: mksolution(
"a 1.0.0",
"b 1.0.0",
),
@@ -226,23 +226,23 @@
// not the first version we try
"transitive subpkg bm-add on older version": {
ds: []depspec{
- dsp(dsv("root 0.0.0", "a ~1.0.0"),
+ dsp(mkDepspec("root 0.0.0", "a ~1.0.0"),
pkg("root", "root/foo"),
pkg("root/foo", "a"),
),
- dsp(dsv("a 1.0.0"),
+ dsp(mkDepspec("a 1.0.0"),
pkg("a", "a/bar"),
pkg("a/bar", "b"),
),
- dsp(dsv("a 1.1.0"),
+ dsp(mkDepspec("a 1.1.0"),
pkg("a", "a/bar"),
pkg("a/bar"),
),
- dsp(dsv("b 1.0.0"),
+ dsp(mkDepspec("b 1.0.0"),
pkg("b"),
),
},
- r: mkresults(
+ r: mksolution(
"a 1.0.0",
"b 1.0.0",
),
@@ -252,38 +252,38 @@
// is not part of the solution.
"ignore constraint without import": {
ds: []depspec{
- dsp(dsv("root 0.0.0", "a 1.0.0"),
+ dsp(mkDepspec("root 0.0.0", "a 1.0.0"),
pkg("root", "root/foo"),
pkg("root/foo"),
),
- dsp(dsv("a 1.0.0"),
+ dsp(mkDepspec("a 1.0.0"),
pkg("a"),
),
},
- r: mkresults(),
+ r: mksolution(),
},
// Transitive deps from one project (a) get incrementally included as other
// deps incorporate its various packages.
"multi-stage pkg incorporation": {
ds: []depspec{
- dsp(dsv("root 0.0.0"),
+ dsp(mkDepspec("root 0.0.0"),
pkg("root", "a", "d"),
),
- dsp(dsv("a 1.0.0"),
+ dsp(mkDepspec("a 1.0.0"),
pkg("a", "b"),
pkg("a/second", "c"),
),
- dsp(dsv("b 2.0.0"),
+ dsp(mkDepspec("b 2.0.0"),
pkg("b"),
),
- dsp(dsv("c 1.2.0"),
+ dsp(mkDepspec("c 1.2.0"),
pkg("c"),
),
- dsp(dsv("d 1.0.0"),
+ dsp(mkDepspec("d 1.0.0"),
pkg("d", "a/second"),
),
},
- r: mkresults(
+ r: mksolution(
"a 1.0.0",
"b 2.0.0",
"c 1.2.0",
@@ -295,17 +295,17 @@
// present.
"radix path separator post-check": {
ds: []depspec{
- dsp(dsv("root 0.0.0"),
+ dsp(mkDepspec("root 0.0.0"),
pkg("root", "foo", "foobar"),
),
- dsp(dsv("foo 1.0.0"),
+ dsp(mkDepspec("foo 1.0.0"),
pkg("foo"),
),
- dsp(dsv("foobar 1.0.0"),
+ dsp(mkDepspec("foobar 1.0.0"),
pkg("foobar"),
),
},
- r: mkresults(
+ r: mksolution(
"foo 1.0.0",
"foobar 1.0.0",
),
@@ -313,10 +313,10 @@
// Well-formed failure when there's a dependency on a pkg that doesn't exist
"fail when imports nonexistent package": {
ds: []depspec{
- dsp(dsv("root 0.0.0", "a 1.0.0"),
+ dsp(mkDepspec("root 0.0.0", "a 1.0.0"),
pkg("root", "a/foo"),
),
- dsp(dsv("a 1.0.0"),
+ dsp(mkDepspec("a 1.0.0"),
pkg("a"),
),
},
@@ -327,20 +327,20 @@
// discover one incrementally that isn't present
"fail multi-stage missing pkg": {
ds: []depspec{
- dsp(dsv("root 0.0.0"),
+ dsp(mkDepspec("root 0.0.0"),
pkg("root", "a", "d"),
),
- dsp(dsv("a 1.0.0"),
+ dsp(mkDepspec("a 1.0.0"),
pkg("a", "b"),
pkg("a/second", "c"),
),
- dsp(dsv("b 2.0.0"),
+ dsp(mkDepspec("b 2.0.0"),
pkg("b"),
),
- dsp(dsv("c 1.2.0"),
+ dsp(mkDepspec("c 1.2.0"),
pkg("c"),
),
- dsp(dsv("d 1.0.0"),
+ dsp(mkDepspec("d 1.0.0"),
pkg("d", "a/second"),
pkg("d", "a/nonexistent"),
),
@@ -350,43 +350,122 @@
// Check ignores on the root project
"ignore in double-subpkg": {
ds: []depspec{
- dsp(dsv("root 0.0.0"),
+ dsp(mkDepspec("root 0.0.0"),
pkg("root", "root/foo"),
pkg("root/foo", "root/bar", "b"),
pkg("root/bar", "a"),
),
- dsp(dsv("a 1.0.0"),
+ dsp(mkDepspec("a 1.0.0"),
pkg("a"),
),
- dsp(dsv("b 1.0.0"),
+ dsp(mkDepspec("b 1.0.0"),
pkg("b"),
),
},
ignore: []string{"root/bar"},
- r: mkresults(
+ r: mksolution(
"b 1.0.0",
),
},
// Ignores on a dep pkg
"ignore through dep pkg": {
ds: []depspec{
- dsp(dsv("root 0.0.0"),
+ dsp(mkDepspec("root 0.0.0"),
pkg("root", "root/foo"),
pkg("root/foo", "a"),
),
- dsp(dsv("a 1.0.0"),
+ dsp(mkDepspec("a 1.0.0"),
pkg("a", "a/bar"),
pkg("a/bar", "b"),
),
- dsp(dsv("b 1.0.0"),
+ dsp(mkDepspec("b 1.0.0"),
pkg("b"),
),
},
ignore: []string{"a/bar"},
- r: mkresults(
+ r: mksolution(
"a 1.0.0",
),
},
+ // Preferred version, as derived from a dep's lock, is attempted first
+ "respect prefv, simple case": {
+ ds: []depspec{
+ dsp(mkDepspec("root 0.0.0"),
+ pkg("root", "a")),
+ dsp(mkDepspec("a 1.0.0"),
+ pkg("a", "b")),
+ dsp(mkDepspec("b 1.0.0 foorev"),
+ pkg("b")),
+ dsp(mkDepspec("b 2.0.0 barrev"),
+ pkg("b")),
+ },
+ lm: map[string]fixLock{
+ "a 1.0.0": mklock(
+ "b 1.0.0 foorev",
+ ),
+ },
+ r: mksolution(
+ "a 1.0.0",
+ "b 1.0.0 foorev",
+ ),
+ },
+ // Preferred version, as derived from a dep's lock, is attempted first, even
+ // if the root also has a direct dep on it (root doesn't need to use
+ // preferreds, because it has direct control AND because the root lock
+ // already supercedes dep lock "preferences")
+ "respect dep prefv with root import": {
+ ds: []depspec{
+ dsp(mkDepspec("root 0.0.0"),
+ pkg("root", "a", "b")),
+ dsp(mkDepspec("a 1.0.0"),
+ pkg("a", "b")),
+ //dsp(newDepspec("a 1.0.1"),
+ //pkg("a", "b")),
+ //dsp(newDepspec("a 1.1.0"),
+ //pkg("a", "b")),
+ dsp(mkDepspec("b 1.0.0 foorev"),
+ pkg("b")),
+ dsp(mkDepspec("b 2.0.0 barrev"),
+ pkg("b")),
+ },
+ lm: map[string]fixLock{
+ "a 1.0.0": mklock(
+ "b 1.0.0 foorev",
+ ),
+ },
+ r: mksolution(
+ "a 1.0.0",
+ "b 1.0.0 foorev",
+ ),
+ },
+ // Preferred versions can only work if the thing offering it has been
+ // selected, or at least marked in the unselected queue
+ "prefv only works if depper is selected": {
+ ds: []depspec{
+ dsp(mkDepspec("root 0.0.0"),
+ pkg("root", "a", "b")),
+ // Three atoms for a, which will mean it gets visited after b
+ dsp(mkDepspec("a 1.0.0"),
+ pkg("a", "b")),
+ dsp(mkDepspec("a 1.0.1"),
+ pkg("a", "b")),
+ dsp(mkDepspec("a 1.1.0"),
+ pkg("a", "b")),
+ dsp(mkDepspec("b 1.0.0 foorev"),
+ pkg("b")),
+ dsp(mkDepspec("b 2.0.0 barrev"),
+ pkg("b")),
+ },
+ lm: map[string]fixLock{
+ "a 1.0.0": mklock(
+ "b 1.0.0 foorev",
+ ),
+ },
+ r: mksolution(
+ "a 1.1.0",
+ "b 2.0.0 barrev",
+ ),
+ },
}
// tpkg is a representation of a single package. It has its own import path, as
@@ -411,6 +490,9 @@
downgrade bool
// lock file simulator, if one's to be used at all
l fixLock
+ // map of locks for deps, if any. keys should be of the form:
+ // "<project> <version>"
+ lm map[string]fixLock
// projects expected to have errors, if any
errp []string
// request up/downgrade to all projects
@@ -435,29 +517,31 @@
return f.errp
}
-func (f bimodalFixture) result() map[string]Version {
+func (f bimodalFixture) solution() map[string]Version {
return f.r
}
// bmSourceManager is an SM specifically for the bimodal fixtures. It composes
-// the general depspec SM, and differs from it only in the way that it answers
-// some static analysis-type calls.
+// the general depspec SM, and differs from it in how it answers static analysis
+// calls, and its support for package ignores and dep lock data.
type bmSourceManager struct {
depspecSourceManager
+ lm map[string]fixLock
}
var _ SourceManager = &bmSourceManager{}
-func newbmSM(ds []depspec, ignore []string) *bmSourceManager {
+func newbmSM(bmf bimodalFixture) *bmSourceManager {
sm := &bmSourceManager{
- depspecSourceManager: *newdepspecSM(ds, ignore),
+ depspecSourceManager: *newdepspecSM(bmf.ds, bmf.ignore),
}
- sm.rm = computeBimodalExternalMap(ds)
+ sm.rm = computeBimodalExternalMap(bmf.ds)
+ sm.lm = bmf.lm
return sm
}
-func (sm *bmSourceManager) ListPackages(n ProjectName, v Version) (PackageTree, error) {
+func (sm *bmSourceManager) ListPackages(n ProjectRoot, v Version) (PackageTree, error) {
for k, ds := range sm.specs {
// Cheat for root, otherwise we blow up b/c version is empty
if n == ds.n && (k == 0 || ds.v.Matches(v)) {
@@ -482,6 +566,20 @@
return PackageTree{}, fmt.Errorf("Project %s at version %s could not be found", n, v)
}
+func (sm *bmSourceManager) GetProjectInfo(n ProjectRoot, v Version) (Manifest, Lock, error) {
+ for _, ds := range sm.specs {
+ if n == ds.n && v.Matches(ds.v) {
+ if l, exists := sm.lm[string(n)+" "+v.String()]; exists {
+ return ds, l, nil
+ }
+ return ds, dummyLock{}, nil
+ }
+ }
+
+ // TODO(sdboyer) proper solver-type errors
+ return nil, nil, fmt.Errorf("Project %s at version %s could not be found", n, v)
+}
+
// computeBimodalExternalMap takes a set of depspecs and computes an
// internally-versioned external reach map that is useful for quickly answering
// ListExternal()-type calls.
@@ -508,39 +606,36 @@
}
w := wm{
- ex: make(map[string]struct{}),
- in: make(map[string]struct{}),
+ ex: make(map[string]bool),
+ in: make(map[string]bool),
}
for _, imp := range pkg.imports {
if !checkPrefixSlash(filepath.Clean(imp), string(d.n)) {
// Easy case - if the import is not a child of the base
// project path, put it in the external map
- w.ex[imp] = struct{}{}
+ w.ex[imp] = true
} else {
if w2, seen := workmap[imp]; seen {
// If it is, and we've seen that path, dereference it
// immediately
for i := range w2.ex {
- w.ex[i] = struct{}{}
+ w.ex[i] = true
}
for i := range w2.in {
- w.in[i] = struct{}{}
+ w.in[i] = true
}
} else {
// Otherwise, put it in the 'in' map for later
// reprocessing
- w.in[imp] = struct{}{}
+ w.in[imp] = true
}
}
}
workmap[pkg.path] = w
}
- drm, err := wmToReach(workmap, "")
- if err != nil {
- panic(err)
- }
+ drm := wmToReach(workmap, "")
rm[pident{n: d.n, v: d.v}] = drm
}
diff --git a/vendor/github.com/sdboyer/gps/solve_test.go b/vendor/github.com/sdboyer/gps/solve_test.go
new file mode 100644
index 0000000..95db023
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/solve_test.go
@@ -0,0 +1,440 @@
+package gps
+
+import (
+ "flag"
+ "fmt"
+ "io/ioutil"
+ "log"
+ "math/rand"
+ "os"
+ "reflect"
+ "sort"
+ "strconv"
+ "strings"
+ "testing"
+)
+
+var fixtorun string
+
+// TODO(sdboyer) regression test ensuring that locks with only revs for projects don't cause errors
+func init() {
+ flag.StringVar(&fixtorun, "gps.fix", "", "A single fixture to run in TestBasicSolves")
+ overrideMkBridge()
+}
+
+// sets the mkBridge global func to one that allows virtualized RootDirs
+func overrideMkBridge() {
+ // For all tests, override the base bridge with the depspecBridge that skips
+ // verifyRootDir calls
+ mkBridge = func(s *solver, sm SourceManager) sourceBridge {
+ return &depspecBridge{
+ &bridge{
+ sm: sm,
+ s: s,
+ vlists: make(map[ProjectRoot][]Version),
+ },
+ }
+ }
+}
+
+var stderrlog = log.New(os.Stderr, "", 0)
+
+func fixSolve(params SolveParameters, sm SourceManager) (Solution, error) {
+ if testing.Verbose() {
+ params.Trace = true
+ params.TraceLogger = stderrlog
+ }
+
+ s, err := Prepare(params, sm)
+ if err != nil {
+ return nil, err
+ }
+
+ return s.Solve()
+}
+
+// Test all the basic table fixtures.
+//
+// Or, just the one named in the fix arg.
+func TestBasicSolves(t *testing.T) {
+ if fixtorun != "" {
+ if fix, exists := basicFixtures[fixtorun]; exists {
+ solveBasicsAndCheck(fix, t)
+ }
+ } else {
+ // sort them by their keys so we get stable output
+ var names []string
+ for n := range basicFixtures {
+ names = append(names, n)
+ }
+
+ sort.Strings(names)
+ for _, n := range names {
+ solveBasicsAndCheck(basicFixtures[n], t)
+ if testing.Verbose() {
+ // insert a line break between tests
+ stderrlog.Println("")
+ }
+ }
+ }
+}
+
+func solveBasicsAndCheck(fix basicFixture, t *testing.T) (res Solution, err error) {
+ if testing.Verbose() {
+ stderrlog.Printf("[[fixture %q]]", fix.n)
+ }
+ sm := newdepspecSM(fix.ds, nil)
+
+ params := SolveParameters{
+ RootDir: string(fix.ds[0].n),
+ ImportRoot: ProjectRoot(fix.ds[0].n),
+ Manifest: fix.ds[0],
+ Lock: dummyLock{},
+ Downgrade: fix.downgrade,
+ ChangeAll: fix.changeall,
+ }
+
+ if fix.l != nil {
+ params.Lock = fix.l
+ }
+
+ res, err = fixSolve(params, sm)
+
+ return fixtureSolveSimpleChecks(fix, res, err, t)
+}
+
+// Test all the bimodal table fixtures.
+//
+// Or, just the one named in the fix arg.
+func TestBimodalSolves(t *testing.T) {
+ if fixtorun != "" {
+ if fix, exists := bimodalFixtures[fixtorun]; exists {
+ solveBimodalAndCheck(fix, t)
+ }
+ } else {
+ // sort them by their keys so we get stable output
+ var names []string
+ for n := range bimodalFixtures {
+ names = append(names, n)
+ }
+
+ sort.Strings(names)
+ for _, n := range names {
+ solveBimodalAndCheck(bimodalFixtures[n], t)
+ if testing.Verbose() {
+ // insert a line break between tests
+ stderrlog.Println("")
+ }
+ }
+ }
+}
+
+func solveBimodalAndCheck(fix bimodalFixture, t *testing.T) (res Solution, err error) {
+ if testing.Verbose() {
+ stderrlog.Printf("[[fixture %q]]", fix.n)
+ }
+ sm := newbmSM(fix)
+
+ params := SolveParameters{
+ RootDir: string(fix.ds[0].n),
+ ImportRoot: ProjectRoot(fix.ds[0].n),
+ Manifest: fix.ds[0],
+ Lock: dummyLock{},
+ Ignore: fix.ignore,
+ Downgrade: fix.downgrade,
+ ChangeAll: fix.changeall,
+ }
+
+ if fix.l != nil {
+ params.Lock = fix.l
+ }
+
+ res, err = fixSolve(params, sm)
+
+ return fixtureSolveSimpleChecks(fix, res, err, t)
+}
+
+func fixtureSolveSimpleChecks(fix specfix, res Solution, err error, t *testing.T) (Solution, error) {
+ if err != nil {
+ errp := fix.expectErrs()
+ if len(errp) == 0 {
+ t.Errorf("(fixture: %q) Solver failed; error was type %T, text:\n%s", fix.name(), err, err)
+ return res, err
+ }
+
+ switch fail := err.(type) {
+ case *badOptsFailure:
+ t.Errorf("(fixture: %q) Unexpected bad opts failure solve error: %s", fix.name(), err)
+ case *noVersionError:
+ if errp[0] != string(fail.pn.ProjectRoot) { // TODO(sdboyer) identifierify
+ t.Errorf("(fixture: %q) Expected failure on project %s, but was on project %s", fix.name(), errp[0], fail.pn.ProjectRoot)
+ }
+
+ ep := make(map[string]struct{})
+ for _, p := range errp[1:] {
+ ep[p] = struct{}{}
+ }
+
+ found := make(map[string]struct{})
+ for _, vf := range fail.fails {
+ for _, f := range getFailureCausingProjects(vf.f) {
+ found[f] = struct{}{}
+ }
+ }
+
+ var missing []string
+ var extra []string
+ for p := range found {
+ if _, has := ep[p]; !has {
+ extra = append(extra, p)
+ }
+ }
+ if len(extra) > 0 {
+ t.Errorf("(fixture: %q) Expected solve failures due to projects %s, but solve failures also arose from %s", fix.name(), strings.Join(errp[1:], ", "), strings.Join(extra, ", "))
+ }
+
+ for p := range ep {
+ if _, has := found[p]; !has {
+ missing = append(missing, p)
+ }
+ }
+ if len(missing) > 0 {
+ t.Errorf("(fixture: %q) Expected solve failures due to projects %s, but %s had no failures", fix.name(), strings.Join(errp[1:], ", "), strings.Join(missing, ", "))
+ }
+
+ default:
+ // TODO(sdboyer) round these out
+ panic(fmt.Sprintf("unhandled solve failure type: %s", err))
+ }
+ } else if len(fix.expectErrs()) > 0 {
+ t.Errorf("(fixture: %q) Solver succeeded, but expected failure", fix.name())
+ } else {
+ r := res.(solution)
+ if fix.maxTries() > 0 && r.Attempts() > fix.maxTries() {
+ t.Errorf("(fixture: %q) Solver completed in %v attempts, but expected %v or fewer", fix.name(), r.att, fix.maxTries())
+ }
+
+ // Dump result projects into a map for easier interrogation
+ rp := make(map[string]Version)
+ for _, p := range r.p {
+ pa := p.toAtom()
+ rp[string(pa.id.ProjectRoot)] = pa.v
+ }
+
+ fixlen, rlen := len(fix.solution()), len(rp)
+ if fixlen != rlen {
+ // Different length, so they definitely disagree
+ t.Errorf("(fixture: %q) Solver reported %v package results, result expected %v", fix.name(), rlen, fixlen)
+ }
+
+ // Whether or not len is same, still have to verify that results agree
+ // Walk through fixture/expected results first
+ for p, v := range fix.solution() {
+ if av, exists := rp[p]; !exists {
+ t.Errorf("(fixture: %q) Project %q expected but missing from results", fix.name(), p)
+ } else {
+ // delete result from map so we skip it on the reverse pass
+ delete(rp, p)
+ if v != av {
+ t.Errorf("(fixture: %q) Expected version %q of project %q, but actual version was %q", fix.name(), v, p, av)
+ }
+ }
+ }
+
+ // Now walk through remaining actual results
+ for p, v := range rp {
+ if fv, exists := fix.solution()[p]; !exists {
+ t.Errorf("(fixture: %q) Unexpected project %q present in results", fix.name(), p)
+ } else if v != fv {
+ t.Errorf("(fixture: %q) Got version %q of project %q, but expected version was %q", fix.name(), v, p, fv)
+ }
+ }
+ }
+
+ return res, err
+}
+
+// This tests that, when a root lock is underspecified (has only a version) we
+// don't allow a match on that version from a rev in the manifest. We may allow
+// this in the future, but disallow it for now because going from an immutable
+// requirement to a mutable lock automagically is a bad direction that could
+// produce weird side effects.
+func TestRootLockNoVersionPairMatching(t *testing.T) {
+ fix := basicFixture{
+ n: "does not pair bare revs in manifest with unpaired lock version",
+ ds: []depspec{
+ mkDepspec("root 0.0.0", "foo *"), // foo's constraint rewritten below to foorev
+ mkDepspec("foo 1.0.0", "bar 1.0.0"),
+ mkDepspec("foo 1.0.1 foorev", "bar 1.0.1"),
+ mkDepspec("foo 1.0.2 foorev", "bar 1.0.2"),
+ mkDepspec("bar 1.0.0"),
+ mkDepspec("bar 1.0.1"),
+ mkDepspec("bar 1.0.2"),
+ },
+ l: mklock(
+ "foo 1.0.1",
+ ),
+ r: mksolution(
+ "foo 1.0.2 foorev",
+ "bar 1.0.1",
+ ),
+ }
+
+ pd := fix.ds[0].deps[0]
+ pd.Constraint = Revision("foorev")
+ fix.ds[0].deps[0] = pd
+
+ sm := newdepspecSM(fix.ds, nil)
+
+ l2 := make(fixLock, 1)
+ copy(l2, fix.l)
+ l2[0].v = nil
+
+ params := SolveParameters{
+ RootDir: string(fix.ds[0].n),
+ ImportRoot: ProjectRoot(fix.ds[0].n),
+ Manifest: fix.ds[0],
+ Lock: l2,
+ }
+
+ res, err := fixSolve(params, sm)
+
+ fixtureSolveSimpleChecks(fix, res, err, t)
+}
+
+func getFailureCausingProjects(err error) (projs []string) {
+ switch e := err.(type) {
+ case *noVersionError:
+ projs = append(projs, string(e.pn.ProjectRoot)) // TODO(sdboyer) identifierify
+ case *disjointConstraintFailure:
+ for _, f := range e.failsib {
+ projs = append(projs, string(f.depender.id.ProjectRoot))
+ }
+ case *versionNotAllowedFailure:
+ for _, f := range e.failparent {
+ projs = append(projs, string(f.depender.id.ProjectRoot))
+ }
+ case *constraintNotAllowedFailure:
+ // No sane way of knowing why the currently selected version is
+ // selected, so do nothing
+ case *sourceMismatchFailure:
+ projs = append(projs, string(e.prob.id.ProjectRoot))
+ for _, c := range e.sel {
+ projs = append(projs, string(c.depender.id.ProjectRoot))
+ }
+ case *checkeeHasProblemPackagesFailure:
+ projs = append(projs, string(e.goal.id.ProjectRoot))
+ for _, errdep := range e.failpkg {
+ for _, atom := range errdep.deppers {
+ projs = append(projs, string(atom.id.ProjectRoot))
+ }
+ }
+ case *depHasProblemPackagesFailure:
+ projs = append(projs, string(e.goal.depender.id.ProjectRoot), string(e.goal.dep.Ident.ProjectRoot))
+ case *nonexistentRevisionFailure:
+ projs = append(projs, string(e.goal.depender.id.ProjectRoot), string(e.goal.dep.Ident.ProjectRoot))
+ default:
+ panic(fmt.Sprintf("unknown failtype %T, msg: %s", err, err))
+ }
+
+ return
+}
+
+func TestBadSolveOpts(t *testing.T) {
+ pn := strconv.FormatInt(rand.Int63(), 36)
+ fix := basicFixtures["no dependencies"]
+ fix.ds[0].n = ProjectRoot(pn)
+
+ sm := newdepspecSM(fix.ds, nil)
+ params := SolveParameters{}
+
+ _, err := Prepare(params, nil)
+ if err == nil {
+ t.Errorf("Prepare should have errored on nil SourceManager")
+ } else if !strings.Contains(err.Error(), "non-nil SourceManager") {
+ t.Error("Prepare should have given error on nil SourceManager, but gave:", err)
+ }
+
+ _, err = Prepare(params, sm)
+ if err == nil {
+ t.Errorf("Prepare should have errored on empty root")
+ } else if !strings.Contains(err.Error(), "non-empty root directory") {
+ t.Error("Prepare should have given error on empty root, but gave:", err)
+ }
+
+ params.RootDir = pn
+ _, err = Prepare(params, sm)
+ if err == nil {
+ t.Errorf("Prepare should have errored on empty name")
+ } else if !strings.Contains(err.Error(), "non-empty import root") {
+ t.Error("Prepare should have given error on empty import root, but gave:", err)
+ }
+
+ params.ImportRoot = ProjectRoot(pn)
+ params.Trace = true
+ _, err = Prepare(params, sm)
+ if err == nil {
+ t.Errorf("Should have errored on trace with no logger")
+ } else if !strings.Contains(err.Error(), "no logger provided") {
+ t.Error("Prepare should have given error on missing trace logger, but gave:", err)
+ }
+
+ params.TraceLogger = log.New(ioutil.Discard, "", 0)
+ _, err = Prepare(params, sm)
+ if err != nil {
+ t.Error("Basic conditions satisfied, prepare should have completed successfully, err as:", err)
+ }
+
+ // swap out the test mkBridge override temporarily, just to make sure we get
+ // the right error
+ mkBridge = func(s *solver, sm SourceManager) sourceBridge {
+ return &bridge{
+ sm: sm,
+ s: s,
+ vlists: make(map[ProjectRoot][]Version),
+ }
+ }
+
+ _, err = Prepare(params, sm)
+ if err == nil {
+ t.Errorf("Should have errored on nonexistent root")
+ } else if !strings.Contains(err.Error(), "could not read project root") {
+ t.Error("Prepare should have given error nonexistent project root dir, but gave:", err)
+ }
+
+ // Pointing it at a file should also be an err
+ params.RootDir = "solve_test.go"
+ _, err = Prepare(params, sm)
+ if err == nil {
+ t.Errorf("Should have errored on file for RootDir")
+ } else if !strings.Contains(err.Error(), "is a file, not a directory") {
+ t.Error("Prepare should have given error on file as RootDir, but gave:", err)
+ }
+
+ // swap them back...not sure if this matters, but just in case
+ overrideMkBridge()
+}
+
+func TestIgnoreDedupe(t *testing.T) {
+ fix := basicFixtures["no dependencies"]
+
+ ig := []string{"foo", "foo", "bar"}
+ params := SolveParameters{
+ RootDir: string(fix.ds[0].n),
+ ImportRoot: ProjectRoot(fix.ds[0].n),
+ Manifest: fix.ds[0],
+ Ignore: ig,
+ }
+
+ s, _ := Prepare(params, newdepspecSM(basicFixtures["no dependencies"].ds, nil))
+ ts := s.(*solver)
+
+ expect := map[string]bool{
+ "foo": true,
+ "bar": true,
+ }
+
+ if !reflect.DeepEqual(ts.ig, expect) {
+ t.Errorf("Expected solver's ignore list to be deduplicated map, got %v", ts.ig)
+ }
+}
diff --git a/vendor/github.com/sdboyer/vsolver/solver.go b/vendor/github.com/sdboyer/gps/solver.go
similarity index 69%
rename from vendor/github.com/sdboyer/vsolver/solver.go
rename to vendor/github.com/sdboyer/gps/solver.go
index 0ea3dbe..121bc81 100644
--- a/vendor/github.com/sdboyer/vsolver/solver.go
+++ b/vendor/github.com/sdboyer/gps/solver.go
@@ -1,39 +1,53 @@
-package vsolver
+package gps
import (
"container/heap"
"fmt"
"log"
- "math/rand"
"os"
"sort"
- "strconv"
"strings"
"github.com/armon/go-radix"
)
-var (
- // With a random revision and no name, collisions are unlikely
- nilpa = atom{
- v: Revision(strconv.FormatInt(rand.Int63(), 36)),
- }
-)
+// SolveParameters hold all arguments to a solver run.
+//
+// Only RootDir and ImportRoot are absolutely required. A nil Manifest is
+// allowed, though it usually makes little sense.
+//
+// Of these properties, only Manifest and Ignore are (directly) incorporated in
+// memoization hashing.
+type SolveParameters struct {
+ // The path to the root of the project on which the solver should operate.
+ // This should point to the directory that should contain the vendor/
+ // directory.
+ //
+ // In general, it is wise for this to be under an active GOPATH, though it
+ // is not (currently) required.
+ //
+ // A real path to a readable directory is required.
+ RootDir string
-// SolveArgs comprise the required inputs for a Solve run.
-type SolveArgs struct {
- // The path to the root of the project on which the solver is working.
- Root string
+ // The import path at the base of all import paths covered by the project.
+ // For example, the appropriate value for gps itself here is:
+ //
+ // github.com/sdboyer/gps
+ //
+ // In most cases, this should match the latter portion of RootDir. However,
+ // that is not (currently) required.
+ //
+ // A non-empty string is required.
+ ImportRoot ProjectRoot
- // The 'name' of the project. Required. This should (must?) correspond to subpath of
- // Root that exists under a GOPATH.
- Name ProjectName
-
- // The root manifest. Required. This contains all the dependencies, constraints, and
+ // The root manifest. This contains all the dependencies, constraints, and
// other controls available to the root project.
+ //
+ // May be nil, but for most cases, that would be unwise.
Manifest Manifest
- // The root lock. Optional. Generally, this lock is the output of a previous solve run.
+ // The root lock. Optional. Generally, this lock is the output of a previous
+ // solve run.
//
// If provided, the solver will attempt to preserve the versions specified
// in the lock, unless ToChange or ChangeAll settings indicate otherwise.
@@ -43,21 +57,6 @@
// project, or from elsewhere. Ignoring a package means that both it and its
// imports will be disregarded by all relevant solver operations.
Ignore []string
-}
-
-// SolveOpts holds additional options that govern solving behavior.
-type SolveOpts struct {
- // Downgrade indicates whether the solver will attempt to upgrade (false) or
- // downgrade (true) projects that are not locked, or are marked for change.
- //
- // Upgrading is, by far, the most typical case. The field is named
- // 'Downgrade' so that the bool's zero value corresponds to that most
- // typical case.
- Downgrade bool
-
- // ChangeAll indicates that all projects should be changed - that is, any
- // versions specified in the root lock file should be ignored.
- ChangeAll bool
// 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
@@ -66,7 +65,19 @@
// Passing ChangeAll has subtly different behavior from enumerating all
// projects into ToChange. In general, ToChange should *only* be used if the
// user expressly requested an upgrade for a specific project.
- ToChange []ProjectName
+ ToChange []ProjectRoot
+
+ // ChangeAll indicates that all projects should be changed - that is, any
+ // versions specified in the root lock file should be ignored.
+ ChangeAll bool
+
+ // Downgrade indicates whether the solver will attempt to upgrade (false) or
+ // downgrade (true) projects that are not locked, or are marked for change.
+ //
+ // Upgrading is, by far, the most typical case. The field is named
+ // 'Downgrade' so that the bool's zero value corresponds to that most
+ // typical case.
+ Downgrade bool
// Trace controls whether the solver will generate informative trace output
// as it moves through the solving process.
@@ -85,13 +96,13 @@
// starts moving forward again.
attempts int
- // SolveArgs are the essential inputs to the solver. The solver will abort
- // early if these options are not appropriately set.
- args SolveArgs
-
- // SolveOpts are the configuration options provided to the solver. The
- // solver will abort early if certain options are not appropriately set.
- o SolveOpts
+ // SolveParameters are the inputs to the solver. They determine both what
+ // data the solver should operate on, and certain aspects of how solving
+ // proceeds.
+ //
+ // Prepare() validates these, so by the time we have a *solver instance, we
+ // know they're valid.
+ params SolveParameters
// Logger used exclusively for trace output, if the trace option is set.
tl *log.Logger
@@ -102,8 +113,9 @@
// names a SourceManager operates on.
b sourceBridge
- // The list of projects currently "selected" - that is, they have passed all
- // satisfiability checks, and are part of the current solution.
+ // A stack containing projects and packages that are currently "selected" -
+ // that is, they have passed all satisfiability checks, and are part of the
+ // current solution.
//
// The *selection type is mostly just a dumb data container; the solver
// itself is responsible for maintaining that invariant.
@@ -120,87 +132,100 @@
// removal.
unsel *unselected
- // Map of packages to ignore. This is derived by converting SolveArgs.Ignore
+ // Map of packages to ignore. Derived by converting SolveParameters.Ignore
// into a map during solver prep - which also, nicely, deduplicates it.
ig map[string]bool
- // A list of all the currently active versionQueues in the solver. The set
+ // A stack of all the currently active versionQueues in the solver. The set
// of projects represented here corresponds closely to what's in s.sel,
- // although s.sel will always contain the root project, and s.versions never
- // will.
- versions []*versionQueue // TODO rename to vq
+ // although s.sel will always contain the root project, and s.vqs never
+ // will. Also, s.vqs is only added to (or popped from during backtracking)
+ // when a new project is selected; it is untouched when new packages are
+ // added to an existing project.
+ vqs []*versionQueue
- // A map of the ProjectName (local names) that should be allowed to change
- chng map[ProjectName]struct{}
+ // A map of the ProjectRoot (local names) that should be allowed to change
+ chng map[ProjectRoot]struct{}
- // A map of the ProjectName (local names) that are currently selected, and
+ // A map of the ProjectRoot (local names) that are currently selected, and
// the network name to which they currently correspond.
- names map[ProjectName]string
+ names map[ProjectRoot]string
// A map of the names listed in the root's lock.
rlm map[ProjectIdentifier]LockedProject
// A normalized, copied version of the root manifest.
rm Manifest
+
+ // A normalized, copied version of the root lock.
+ rl Lock
}
-// A Solver is the main workhorse of vsolver: given a set of project inputs, it
+// A Solver is the main workhorse of gps: given a set of project inputs, it
// performs a constraint solving analysis to develop a complete Result that can
// be used as a lock file, and to populate a vendor directory.
type Solver interface {
HashInputs() ([]byte, error)
- Solve() (Result, error)
+ Solve() (Solution, error)
}
// Prepare readies a Solver for use.
//
-// This function reads and validates the provided SolveArgs and SolveOpts. If a
-// problem with the inputs is detected, an error is returned. Otherwise, a
-// Solver is returned, ready to hash and check inputs or perform a solving run.
-func Prepare(args SolveArgs, opts SolveOpts, sm SourceManager) (Solver, error) {
+// This function reads and validates the provided SolveParameters. If a problem
+// with the inputs is detected, an error is returned. Otherwise, a Solver is
+// returned, ready to hash and check inputs or perform a solving run.
+func Prepare(params SolveParameters, sm SourceManager) (Solver, error) {
// local overrides would need to be handled first.
- // TODO local overrides! heh
+ // TODO(sdboyer) local overrides! heh
- if args.Manifest == nil {
- return nil, badOptsFailure("Opts must include a manifest.")
+ if sm == nil {
+ return nil, badOptsFailure("must provide non-nil SourceManager")
}
- if args.Root == "" {
- return nil, badOptsFailure("Opts must specify a non-empty string for the project root directory. If cwd is desired, use \".\"")
+ if params.RootDir == "" {
+ return nil, badOptsFailure("params must specify a non-empty root directory")
}
- if args.Name == "" {
- return nil, badOptsFailure("Opts must include a project name. This should be the intended root import path of the project.")
+ if params.ImportRoot == "" {
+ return nil, badOptsFailure("params must include a non-empty import root")
}
- if opts.Trace && opts.TraceLogger == nil {
- return nil, badOptsFailure("Trace requested, but no logger provided.")
+ if params.Trace && params.TraceLogger == nil {
+ return nil, badOptsFailure("trace requested, but no logger provided")
+ }
+
+ if params.Manifest == nil {
+ params.Manifest = SimpleManifest{}
}
// Ensure the ignore map is at least initialized
ig := make(map[string]bool)
- if len(args.Ignore) > 0 {
- for _, pkg := range args.Ignore {
+ if len(params.Ignore) > 0 {
+ for _, pkg := range params.Ignore {
ig[pkg] = true
}
}
s := &solver{
- args: args,
- o: opts,
- ig: ig,
- b: &bridge{
- sm: sm,
- sortdown: opts.Downgrade,
- name: args.Name,
- root: args.Root,
- ignore: ig,
- vlists: make(map[ProjectName][]Version),
- },
- tl: opts.TraceLogger,
+ params: params,
+ ig: ig,
+ tl: params.TraceLogger,
+ }
+
+ // Set up the bridge and ensure the root dir is in good, working order
+ // before doing anything else. (This call is stubbed out in tests, via
+ // overriding mkBridge(), so we can run with virtual RootDir.)
+ s.b = mkBridge(s, sm)
+ err := s.b.verifyRootDir(s.params.RootDir)
+ if err != nil {
+ return nil, err
}
// Initialize maps
- s.chng = make(map[ProjectName]struct{})
+ s.chng = make(map[ProjectRoot]struct{})
s.rlm = make(map[ProjectIdentifier]LockedProject)
- s.names = make(map[ProjectName]string)
+ s.names = make(map[ProjectRoot]string)
+
+ for _, v := range s.params.ToChange {
+ s.chng[v] = struct{}{}
+ }
// Initialize stacks and queues
s.sel = &selection{
@@ -212,39 +237,31 @@
cmp: s.unselectedComparator,
}
+ // Prep safe, normalized versions of root manifest and lock data
+ s.rm = prepManifest(s.params.Manifest)
+ if s.params.Lock != nil {
+ for _, lp := range s.params.Lock.Projects() {
+ s.rlm[lp.Ident().normalize()] = lp
+ }
+
+ // Also keep a prepped one, mostly for the bridge. This is probably
+ // wasteful, but only minimally so, and yay symmetry
+ s.rl = prepLock(s.params.Lock)
+ }
+
return s, nil
}
// Solve attempts to find a dependency solution for the given project, as
-// represented by the SolveArgs and accompanying SolveOpts with which this
-// Solver was created.
+// represented by the SolveParameters with which this Solver was created.
//
-// This is the entry point to the main vsolver workhorse.
-func (s *solver) Solve() (Result, error) {
- // Ensure the root is in good, working order before doing anything else
- err := s.b.verifyRoot(s.args.Root)
- if err != nil {
- return nil, err
- }
-
- // Prep safe, normalized versions of root manifest and lock data
- s.rm = prepManifest(s.args.Manifest, s.args.Name)
-
- if s.args.Lock != nil {
- for _, lp := range s.args.Lock.Projects() {
- s.rlm[lp.Ident().normalize()] = lp
- }
- }
-
- for _, v := range s.o.ToChange {
- s.chng[v] = struct{}{}
- }
-
+// This is the entry point to the main gps workhorse.
+func (s *solver) Solve() (Solution, error) {
// Prime the queues with the root project
- err = s.selectRoot()
+ err := s.selectRoot()
if err != nil {
- // TODO this properly with errs, yar
- panic("couldn't select root, yikes")
+ // TODO(sdboyer) this properly with errs, yar
+ return nil, err
}
// Log initial step
@@ -256,7 +273,7 @@
return nil, err
}
- r := result{
+ r := solution{
att: s.attempts,
}
@@ -318,7 +335,7 @@
},
pl: bmi.pl,
})
- s.versions = append(s.versions, queue)
+ s.vqs = append(s.vqs, queue)
s.logSolve()
} else {
// We're just trying to add packages to an already-selected project.
@@ -340,7 +357,7 @@
pl: bmi.pl,
}
- s.logStart(bmi) // TODO different special start logger for this path
+ s.logStart(bmi) // TODO(sdboyer) different special start logger for this path
err := s.checkPackage(nawp)
if err != nil {
// Err means a failure somewhere down the line; try backtracking.
@@ -352,8 +369,8 @@
}
s.selectPackages(nawp)
// We don't add anything to the stack of version queues because the
- // backtracker knows not to popping the vqstack if it backtracks
- // across a package addition.
+ // backtracker knows not to pop the vqstack if it backtracks
+ // across a pure-package addition.
s.logSolve()
}
}
@@ -383,7 +400,7 @@
func (s *solver) selectRoot() error {
pa := atom{
id: ProjectIdentifier{
- LocalName: s.args.Name,
+ ProjectRoot: s.params.ImportRoot,
},
// This is a hack so that the root project doesn't have a nil version.
// It's sort of OK because the root never makes it out into the results.
@@ -410,28 +427,28 @@
}
// Push the root project onto the queue.
- // TODO maybe it'd just be better to skip this?
+ // TODO(sdboyer) maybe it'd just be better to skip this?
s.sel.pushSelection(a, true)
// If we're looking for root's deps, get it from opts and local root
// analysis, rather than having the sm do it
mdeps := append(s.rm.DependencyConstraints(), s.rm.TestDependencyConstraints()...)
- reach, err := s.b.computeRootReach()
- if err != nil {
- return err
- }
+
+ // Err is not possible at this point, as it could only come from
+ // listPackages(), which if we're here already succeeded for root
+ reach, _ := s.b.computeRootReach()
deps, err := s.intersectConstraintsWithImports(mdeps, reach)
if err != nil {
- // TODO this could well happen; handle it with a more graceful error
+ // TODO(sdboyer) this could well happen; handle it with a more graceful error
panic(fmt.Sprintf("shouldn't be possible %s", err))
}
for _, dep := range deps {
s.sel.pushDep(dependency{depender: pa, dep: dep})
// Add all to unselected queue
- s.names[dep.Ident.LocalName] = dep.Ident.netName()
- heap.Push(s.unsel, bimodalIdentifier{id: dep.Ident, pl: dep.pl})
+ s.names[dep.Ident.ProjectRoot] = dep.Ident.netName()
+ heap.Push(s.unsel, bimodalIdentifier{id: dep.Ident, pl: dep.pl, fromRoot: true})
}
return nil
@@ -440,7 +457,7 @@
func (s *solver) getImportsAndConstraintsOf(a atomWithPackages) ([]completeDep, error) {
var err error
- if s.rm.Name() == a.a.id.LocalName {
+ if s.params.ImportRoot == a.a.id.ProjectRoot {
panic("Should never need to recheck imports/constraints from root during solve")
}
@@ -456,22 +473,28 @@
return nil, err
}
- allex, err := ptree.ExternalReach(false, false, s.ig)
- if err != nil {
- return nil, err
- }
-
+ allex := ptree.ExternalReach(false, false, s.ig)
// Use a map to dedupe the unique external packages
exmap := make(map[string]struct{})
// Add the packages reached by the packages explicitly listed in the atom to
// the list
for _, pkg := range a.pl {
- if expkgs, exists := allex[pkg]; !exists {
- return nil, fmt.Errorf("package %s does not exist within project %s", pkg, a.a.id.errString())
- } else {
- for _, ex := range expkgs {
- exmap[ex] = struct{}{}
+ expkgs, exists := allex[pkg]
+ if !exists {
+ // missing package here *should* only happen if the target pkg was
+ // poisoned somehow - check the original ptree.
+ if perr, exists := ptree.Packages[pkg]; exists {
+ if perr.Err != nil {
+ return nil, fmt.Errorf("package %s has errors: %s", pkg, perr.Err)
+ }
+ return nil, fmt.Errorf("package %s depends on some other package within %s with errors", pkg, a.a.id.errString())
}
+ // Nope, it's actually not there. This shouldn't happen.
+ return nil, fmt.Errorf("package %s does not exist within project %s", pkg, a.a.id.errString())
+ }
+
+ for _, ex := range expkgs {
+ exmap[ex] = struct{}{}
}
}
@@ -483,7 +506,7 @@
}
deps := m.DependencyConstraints()
- // TODO add overrides here...if we impl the concept (which we should)
+ // TODO(sdboyer) add overrides here...if we impl the concept (which we should)
return s.intersectConstraintsWithImports(deps, reach)
}
@@ -492,22 +515,22 @@
// 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 []ProjectDep, reach []string) ([]completeDep, error) {
+func (s *solver) intersectConstraintsWithImports(deps []ProjectConstraint, reach []string) ([]completeDep, error) {
// Create a radix tree with all the projects we know from the manifest
- // TODO make this smarter once we allow non-root inputs as 'projects'
+ // TODO(sdboyer) make this smarter once we allow non-root inputs as 'projects'
xt := radix.New()
for _, dep := range deps {
- xt.Insert(string(dep.Ident.LocalName), dep)
+ xt.Insert(string(dep.Ident.ProjectRoot), dep)
}
// Step through the reached packages; if they have prefix matches in
// the trie, assume (mostly) it's a correct correspondence.
- dmap := make(map[ProjectName]completeDep)
+ dmap := make(map[ProjectRoot]completeDep)
for _, rp := range reach {
// If it's a stdlib package, skip it.
- // TODO this just hardcodes us to the packages in tip - should we
+ // TODO(sdboyer) this just hardcodes us to the packages in tip - should we
// have go version magic here, too?
- if _, exists := stdlib[rp]; exists {
+ if stdlib[rp] {
continue
}
@@ -529,14 +552,14 @@
// 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.(ProjectDep)
- if cdep, exists := dmap[dep.Ident.LocalName]; exists {
+ dep := idep.(ProjectConstraint)
+ if cdep, exists := dmap[dep.Ident.ProjectRoot]; exists {
cdep.pl = append(cdep.pl, rp)
- dmap[dep.Ident.LocalName] = cdep
+ dmap[dep.Ident.ProjectRoot] = cdep
} else {
- dmap[dep.Ident.LocalName] = completeDep{
- ProjectDep: dep,
- pl: []string{rp},
+ dmap[dep.Ident.ProjectRoot] = completeDep{
+ ProjectConstraint: dep,
+ pl: []string{rp},
}
}
continue
@@ -551,9 +574,9 @@
}
// Still no matches; make a new completeDep with an open constraint
- pd := ProjectDep{
+ pd := ProjectConstraint{
Ident: ProjectIdentifier{
- LocalName: ProjectName(root.Base),
+ ProjectRoot: ProjectRoot(root.Base),
NetworkName: root.Base,
},
Constraint: Any(),
@@ -563,9 +586,9 @@
// project get caught by the prefix search
xt.Insert(root.Base, pd)
// And also put the complete dep into the dmap
- dmap[ProjectName(root.Base)] = completeDep{
- ProjectDep: pd,
- pl: []string{rp},
+ dmap[ProjectRoot(root.Base)] = completeDep{
+ ProjectConstraint: pd,
+ pl: []string{rp},
}
}
@@ -583,8 +606,8 @@
func (s *solver) createVersionQueue(bmi bimodalIdentifier) (*versionQueue, error) {
id := bmi.id
// If on the root package, there's no queue to make
- if id.LocalName == s.rm.Name() {
- return newVersionQueue(id, nilpa, s.b)
+ if s.params.ImportRoot == id.ProjectRoot {
+ return newVersionQueue(id, nil, nil, s.b)
}
exists, err := s.b.repoExists(id)
@@ -598,13 +621,13 @@
}
if exists {
// Project exists only in vendor (and in some manifest somewhere)
- // TODO mark this for special handling, somehow?
+ // TODO(sdboyer) mark this for special handling, somehow?
} else {
return nil, newSolveError(fmt.Sprintf("Project '%s' could not be located.", id), cannotResolve)
}
}
- lockv := nilpa
+ var lockv Version
if len(s.rlm) > 0 {
lockv, err = s.getLockVersionIfValid(id)
if err != nil {
@@ -614,13 +637,84 @@
}
}
- q, err := newVersionQueue(id, lockv, s.b)
+ var prefv Version
+ if bmi.fromRoot {
+ // If this bmi came from the root, then we want to search through things
+ // with a dependency on it in order to see if any have a lock that might
+ // express a prefv
+ //
+ // TODO(sdboyer) nested loop; prime candidate for a cache somewhere
+ for _, dep := range s.sel.getDependenciesOn(bmi.id) {
+ // Skip the root, of course
+ if s.params.ImportRoot == dep.depender.id.ProjectRoot {
+ continue
+ }
+
+ _, l, err := s.b.getProjectInfo(dep.depender)
+ if err != nil || l == nil {
+ // err being non-nil really shouldn't be possible, but the lock
+ // being nil is quite likely
+ continue
+ }
+
+ for _, lp := range l.Projects() {
+ if lp.Ident().eq(bmi.id) {
+ prefv = lp.Version()
+ }
+ }
+ }
+
+ // OTHER APPROACH - WRONG, BUT MAYBE USEFUL FOR REFERENCE?
+ // If this bmi came from the root, then we want to search the unselected
+ // queue to see if anything *else* wants this ident, in which case we
+ // pick up that prefv
+ //for _, bmi2 := range s.unsel.sl {
+ //// Take the first thing from the queue that's for the same ident,
+ //// and has a non-nil prefv
+ //if bmi.id.eq(bmi2.id) {
+ //if bmi2.prefv != nil {
+ //prefv = bmi2.prefv
+ //}
+ //}
+ //}
+
+ } else {
+ // Otherwise, just use the preferred version expressed in the bmi
+ prefv = bmi.prefv
+ }
+
+ q, err := newVersionQueue(id, lockv, prefv, s.b)
if err != nil {
- // TODO this particular err case needs to be improved to be ONLY for cases
+ // TODO(sdboyer) this particular err case needs to be improved to be ONLY for cases
// where there's absolutely nothing findable about a given project name
return nil, err
}
+ // Hack in support for revisions.
+ //
+ // By design, revs aren't returned from ListVersion(). Thus, if the dep in
+ // the bmi was has a rev constraint, it is (almost) guaranteed to fail, even
+ // if that rev does exist in the repo. So, detect a rev and push it into the
+ // vq here, instead.
+ //
+ // Happily, the solver maintains the invariant that constraints on a given
+ // ident cannot be incompatible, so we know that if we find one rev, then
+ // any other deps will have to also be on that rev (or Any).
+ //
+ // TODO(sdboyer) while this does work, it bypasses the interface-implied guarantees
+ // of the version queue, and is therefore not a great strategy for API
+ // coherency. Folding this in to a formal interface would be better.
+ switch tc := s.sel.getConstraint(bmi.id).(type) {
+ case Revision:
+ // We know this is the only thing that could possibly match, so put it
+ // in at the front - if it isn't there already.
+ if q.pi[0] != tc {
+ // Existence of the revision is guaranteed by checkRevisionExists().
+ q.pi = append([]Version{tc}, q.pi...)
+ }
+ }
+
+ // Having assembled the queue, search it for a valid version.
return q, s.findValidVersion(q, bmi.pl)
}
@@ -632,7 +726,8 @@
// parameter.
func (s *solver) findValidVersion(q *versionQueue, pl []string) error {
if nil == q.current() {
- // TODO this case shouldn't be reachable, but panic here as a canary
+ // this case should not be reachable, but reflects improper solver state
+ // if it is, so panic immediately
panic("version queue is empty, should not happen")
}
@@ -681,24 +776,24 @@
//
// If any of these three conditions are true (or if the id cannot be found in
// the root lock), then no atom will be returned.
-func (s *solver) getLockVersionIfValid(id ProjectIdentifier) (atom, error) {
+func (s *solver) getLockVersionIfValid(id ProjectIdentifier) (Version, error) {
// If the project is specifically marked for changes, then don't look for a
// locked version.
- if _, explicit := s.chng[id.LocalName]; explicit || s.o.ChangeAll {
+ if _, explicit := s.chng[id.ProjectRoot]; explicit || s.params.ChangeAll {
// For projects with an upstream or cache repository, it's safe to
// ignore what's in the lock, because there's presumably more versions
// to be found and attempted in the repository. If it's only in vendor,
// though, then we have to try to use what's in the lock, because that's
// the only version we'll be able to get.
if exist, _ := s.b.repoExists(id); exist {
- return nilpa, nil
+ return nil, nil
}
// However, if a change was *expressly* requested for something that
// exists only in vendor, then that guarantees we don't have enough
// information to complete a solution. In that case, error out.
if explicit {
- return nilpa, &missingSourceFailure{
+ return nil, &missingSourceFailure{
goal: id,
prob: "Cannot upgrade %s, as no source repository could be found.",
}
@@ -707,7 +802,7 @@
lp, exists := s.rlm[id]
if !exists {
- return nilpa, nil
+ return nil, nil
}
constraint := s.sel.getConstraint(id)
@@ -739,37 +834,34 @@
if !found {
s.logSolve("%s in root lock, but current constraints disallow it", id.errString())
- return nilpa, nil
+ return nil, nil
}
}
s.logSolve("using root lock's version of %s", id.errString())
- return atom{
- id: id,
- v: v,
- }, nil
+ return v, nil
}
// backtrack works backwards from the current failed solution to find the next
// solution to try.
func (s *solver) backtrack() bool {
- if len(s.versions) == 0 {
+ if len(s.vqs) == 0 {
// nothing to backtrack to
return false
}
for {
for {
- if len(s.versions) == 0 {
+ if len(s.vqs) == 0 {
// no more versions, nowhere further to backtrack
return false
}
- if s.versions[len(s.versions)-1].failed {
+ if s.vqs[len(s.vqs)-1].failed {
break
}
- s.versions, s.versions[len(s.versions)-1] = s.versions[:len(s.versions)-1], nil
+ s.vqs, s.vqs[len(s.vqs)-1] = s.vqs[:len(s.vqs)-1], nil
// Pop selections off until we get to a project.
var proj bool
@@ -779,7 +871,7 @@
}
// Grab the last versionQueue off the list of queues
- q := s.versions[len(s.versions)-1]
+ q := s.vqs[len(s.vqs)-1]
// Walk back to the next project
var awp atomWithPackages
var proj bool
@@ -793,7 +885,7 @@
}
// Advance the queue past the current version, which we know is bad
- // TODO is it feasible to make available the failure reason here?
+ // TODO(sdboyer) is it feasible to make available the failure reason here?
if q.advance(nil) == nil && !q.isExhausted() {
// Search for another acceptable version of this failed dep in its queue
if s.findValidVersion(q, awp.pl) == nil {
@@ -817,11 +909,11 @@
// No solution found; continue backtracking after popping the queue
// we just inspected off the list
// GC-friendly pop pointer elem in slice
- s.versions, s.versions[len(s.versions)-1] = s.versions[:len(s.versions)-1], nil
+ s.vqs, s.vqs[len(s.vqs)-1] = s.vqs[:len(s.vqs)-1], nil
}
// Backtracking was successful if loop ended before running out of versions
- if len(s.versions) == 0 {
+ if len(s.vqs) == 0 {
return false
}
s.attempts++
@@ -862,16 +954,6 @@
return false
}
- rname := s.rm.Name()
- // *always* put root project first
- // TODO wait, it shouldn't be possible to have root in here...?
- if iname.LocalName == rname {
- return true
- }
- if jname.LocalName == rname {
- return false
- }
-
_, ilock := s.rlm[iname]
_, jlock := s.rlm[jname]
@@ -889,8 +971,6 @@
// isn't locked by the root. And, because being locked by root is the only
// way avoid that call when making a version queue, we know we're gonna have
// to pay that cost anyway.
- //
- // TODO ...at least, 'til we allow 'preferred' versions via non-root locks
// 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
@@ -916,14 +996,14 @@
}
func (s *solver) fail(id ProjectIdentifier) {
- // TODO does this need updating, now that we have non-project package
+ // TODO(sdboyer) does this need updating, now that we have non-project package
// selection?
// skip if the root project
- if s.rm.Name() != id.LocalName {
+ if s.params.ImportRoot != id.ProjectRoot {
// just look for the first (oldest) one; the backtracker will necessarily
// traverse through and pop off any earlier ones
- for _, vq := range s.versions {
+ for _, vq := range s.vqs {
if vq.id.eq(id) {
vq.failed = true
return
@@ -951,6 +1031,17 @@
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
@@ -965,11 +1056,18 @@
}
if len(newp) > 0 {
- heap.Push(s.unsel, bimodalIdentifier{id: dep.Ident, pl: newp})
+ 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.LocalName] = dep.Ident.netName()
+ s.names[dep.Ident.ProjectRoot] = dep.Ident.netName()
}
}
}
@@ -995,6 +1093,17 @@
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
@@ -1009,11 +1118,18 @@
}
if len(newp) > 0 {
- heap.Push(s.unsel, bimodalIdentifier{id: dep.Ident, pl: newp})
+ 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.LocalName] = dep.Ident.netName()
+ s.names[dep.Ident.ProjectRoot] = dep.Ident.netName()
}
}
}
@@ -1034,7 +1150,7 @@
// if no parents/importers, remove from unselected queue
if s.sel.depperCount(dep.Ident) == 0 {
- delete(s.names, dep.Ident.LocalName)
+ delete(s.names, dep.Ident.ProjectRoot)
s.unsel.remove(bimodalIdentifier{id: dep.Ident, pl: dep.pl})
}
}
@@ -1043,28 +1159,28 @@
}
func (s *solver) logStart(bmi bimodalIdentifier) {
- if !s.o.Trace {
+ if !s.params.Trace {
return
}
- prefix := strings.Repeat("| ", len(s.versions)+1)
- // TODO how...to list the packages in the limited space we have?
+ 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.o.Trace {
+ if !s.params.Trace {
return
}
- preflen := len(s.versions)
+ preflen := len(s.vqs)
var msg string
if len(args) == 0 {
// Generate message based on current solver state
- if len(s.versions) == 0 {
+ if len(s.vqs) == 0 {
msg = "✓ (root)"
} else {
- vq := s.versions[len(s.versions)-1]
+ vq := s.vqs[len(s.vqs)-1]
msg = fmt.Sprintf("✓ select %s at %s", vq.id.errString(), vq.current())
}
} else {
@@ -1076,10 +1192,10 @@
msg = tracePrefix(fmt.Sprintf(data, args[1:]), "| ", "| ")
case traceError:
// We got a special traceError, use its custom method
- msg = tracePrefix(data.traceString(), "| ", "x ")
+ msg = tracePrefix(data.traceString(), "| ", "✗ ")
case error:
// Regular error; still use the x leader but default Error() string
- msg = tracePrefix(data.Error(), "| ", "x ")
+ 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")
@@ -1107,9 +1223,6 @@
func pa2lp(pa atom, pkgs map[string]struct{}) LockedProject {
lp := LockedProject{
pi: pa.id.normalize(), // shouldn't be necessary, but normalize just in case
- // path is unnecessary duplicate information now, but if we ever allow
- // nesting as a conflict resolution mechanism, it will become valuable
- path: string(pa.id.LocalName),
}
switch v := pa.v.(type) {
@@ -1125,7 +1238,7 @@
}
for pkg := range pkgs {
- lp.pkgs = append(lp.pkgs, strings.TrimPrefix(pkg, string(pa.id.LocalName)+string(os.PathSeparator)))
+ lp.pkgs = append(lp.pkgs, strings.TrimPrefix(pkg, string(pa.id.ProjectRoot)+string(os.PathSeparator)))
}
sort.Strings(lp.pkgs)
diff --git a/vendor/github.com/sdboyer/gps/source_manager.go b/vendor/github.com/sdboyer/gps/source_manager.go
new file mode 100644
index 0000000..86627a1
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/source_manager.go
@@ -0,0 +1,297 @@
+package gps
+
+import (
+ "encoding/json"
+ "fmt"
+ "go/build"
+ "os"
+ "path"
+
+ "github.com/Masterminds/vcs"
+)
+
+// A SourceManager is responsible for retrieving, managing, and interrogating
+// source repositories. Its primary purpose is to serve the needs of a Solver,
+// but it is handy for other purposes, as well.
+//
+// gps's built-in SourceManager, accessible via NewSourceManager(), is
+// intended to be generic and sufficient for any purpose. It provides some
+// additional semantics around the methods defined here.
+type SourceManager interface {
+ // RepoExists checks if a repository exists, either upstream or in the
+ // SourceManager's central repository cache.
+ RepoExists(ProjectRoot) (bool, error)
+
+ // ListVersions retrieves a list of the available versions for a given
+ // repository name.
+ ListVersions(ProjectRoot) ([]Version, error)
+
+ // RevisionPresentIn indicates whether the provided Version is present in
+ // the given repository.
+ RevisionPresentIn(ProjectRoot, Revision) (bool, error)
+
+ // ListPackages retrieves a tree of the Go packages at or below the provided
+ // import path, at the provided version.
+ ListPackages(ProjectRoot, Version) (PackageTree, error)
+
+ // GetProjectInfo returns manifest and lock information for the provided
+ // import path. gps currently requires that projects be rooted at their
+ // repository root, which means that this ProjectRoot must also be a
+ // repository root.
+ GetProjectInfo(ProjectRoot, Version) (Manifest, Lock, error)
+
+ // ExportProject writes out the tree of the provided import path, at the
+ // provided version, to the provided directory.
+ ExportProject(ProjectRoot, Version, string) error
+
+ // Release lets go of any locks held by the SourceManager.
+ Release()
+}
+
+// A ProjectAnalyzer is responsible for analyzing a path for Manifest and Lock
+// information. Tools relying on gps must implement one.
+type ProjectAnalyzer interface {
+ GetInfo(string, ProjectRoot) (Manifest, Lock, error)
+}
+
+// SourceMgr is the default SourceManager for gps.
+//
+// There's no (planned) reason why it would need to be reimplemented by other
+// tools; control via dependency injection is intended to be sufficient.
+type SourceMgr struct {
+ cachedir string
+ pms map[ProjectRoot]*pmState
+ an ProjectAnalyzer
+ ctx build.Context
+ //pme map[ProjectRoot]error
+}
+
+var _ SourceManager = &SourceMgr{}
+
+// Holds a projectManager, caches of the managed project's data, and information
+// about the freshness of those caches
+type pmState struct {
+ pm *projectManager
+ cf *os.File // handle for the cache file
+ vcur bool // indicates that we've called ListVersions()
+}
+
+// NewSourceManager produces an instance of gps's built-in SourceManager. It
+// takes a cache directory (where local instances of upstream repositories are
+// stored), a vendor directory for the project currently being worked on, and a
+// force flag indicating whether to overwrite the global cache lock file (if
+// present).
+//
+// The returned SourceManager aggressively caches information wherever possible.
+// It is recommended that, if tools need to do preliminary, work involving
+// upstream repository analysis prior to invoking a solve run, that they create
+// this SourceManager as early as possible and use it to their ends. That way,
+// the solver can benefit from any caches that may have already been warmed.
+//
+// gps's SourceManager is intended to be threadsafe (if it's not, please
+// file a bug!). It should certainly be safe to reuse from one solving run to
+// the next; however, the fact that it takes a basedir as an argument makes it
+// much less useful for simultaneous use by separate solvers operating on
+// different root projects. This architecture may change in the future.
+func NewSourceManager(an ProjectAnalyzer, cachedir string, force bool) (*SourceMgr, error) {
+ if an == nil {
+ return nil, fmt.Errorf("a ProjectAnalyzer must be provided to the SourceManager")
+ }
+
+ err := os.MkdirAll(cachedir, 0777)
+ if err != nil {
+ return nil, err
+ }
+
+ glpath := path.Join(cachedir, "sm.lock")
+ _, err = os.Stat(glpath)
+ if err == nil && !force {
+ return nil, fmt.Errorf("cache lock file %s exists - another process crashed or is still running?", glpath)
+ }
+
+ _, err = os.OpenFile(glpath, os.O_CREATE|os.O_RDONLY, 0700) // is 0700 sane for this purpose?
+ if err != nil {
+ return nil, fmt.Errorf("failed to create global cache lock file at %s with err %s", glpath, err)
+ }
+
+ ctx := build.Default
+ // Replace GOPATH with our cache dir
+ ctx.GOPATH = cachedir
+
+ return &SourceMgr{
+ cachedir: cachedir,
+ pms: make(map[ProjectRoot]*pmState),
+ ctx: ctx,
+ an: an,
+ }, nil
+}
+
+// Release lets go of any locks held by the SourceManager.
+func (sm *SourceMgr) Release() {
+ os.Remove(path.Join(sm.cachedir, "sm.lock"))
+}
+
+// GetProjectInfo returns manifest and lock information for the provided import
+// path. gps currently requires that projects be rooted at their repository
+// root, which means that this ProjectRoot must also be a repository root.
+//
+// The work of producing the manifest and lock information is delegated to the
+// injected ProjectAnalyzer.
+func (sm *SourceMgr) GetProjectInfo(n ProjectRoot, v Version) (Manifest, Lock, error) {
+ pmc, err := sm.getProjectManager(n)
+ if err != nil {
+ return nil, nil, err
+ }
+
+ return pmc.pm.GetInfoAt(v)
+}
+
+// ListPackages retrieves a tree of the Go packages at or below the provided
+// import path, at the provided version.
+func (sm *SourceMgr) ListPackages(n ProjectRoot, v Version) (PackageTree, error) {
+ pmc, err := sm.getProjectManager(n)
+ if err != nil {
+ return PackageTree{}, err
+ }
+
+ return pmc.pm.ListPackages(v)
+}
+
+// ListVersions retrieves a list of the available versions for a given
+// repository name.
+//
+// The list is not sorted; while it may be returned in the order that the
+// underlying VCS reports version information, no guarantee is made. It is
+// expected that the caller either not care about order, or sort the result
+// themselves.
+//
+// This list is always retrieved from upstream; if upstream is not accessible
+// (network outage, access issues, or the resource actually went away), an error
+// will be returned.
+func (sm *SourceMgr) ListVersions(n ProjectRoot) ([]Version, error) {
+ pmc, err := sm.getProjectManager(n)
+ if err != nil {
+ // TODO(sdboyer) More-er proper-er errors
+ return nil, err
+ }
+
+ return pmc.pm.ListVersions()
+}
+
+// RevisionPresentIn indicates whether the provided Revision is present in the given
+// repository.
+func (sm *SourceMgr) RevisionPresentIn(n ProjectRoot, r Revision) (bool, error) {
+ pmc, err := sm.getProjectManager(n)
+ if err != nil {
+ // TODO(sdboyer) More-er proper-er errors
+ return false, err
+ }
+
+ return pmc.pm.RevisionPresentIn(r)
+}
+
+// RepoExists checks if a repository exists, either upstream or in the cache,
+// for the provided ProjectRoot.
+func (sm *SourceMgr) RepoExists(n ProjectRoot) (bool, error) {
+ pms, err := sm.getProjectManager(n)
+ if err != nil {
+ return false, err
+ }
+
+ return pms.pm.CheckExistence(existsInCache) || pms.pm.CheckExistence(existsUpstream), nil
+}
+
+// ExportProject writes out the tree of the provided import path, at the
+// provided version, to the provided directory.
+func (sm *SourceMgr) ExportProject(n ProjectRoot, v Version, to string) error {
+ pms, err := sm.getProjectManager(n)
+ if err != nil {
+ return err
+ }
+
+ return pms.pm.ExportVersionTo(v, to)
+}
+
+// getProjectManager gets the project manager for the given ProjectRoot.
+//
+// If no such manager yet exists, it attempts to create one.
+func (sm *SourceMgr) getProjectManager(n ProjectRoot) (*pmState, error) {
+ // Check pm cache and errcache first
+ if pm, exists := sm.pms[n]; exists {
+ return pm, nil
+ //} else if pme, errexists := sm.pme[name]; errexists {
+ //return nil, pme
+ }
+
+ repodir := path.Join(sm.cachedir, "src", string(n))
+ // TODO(sdboyer) be more robust about this
+ r, err := vcs.NewRepo("https://"+string(n), repodir)
+ if err != nil {
+ // TODO(sdboyer) be better
+ return nil, err
+ }
+ if !r.CheckLocal() {
+ // TODO(sdboyer) cloning the repo here puts it on a blocking, and possibly
+ // unnecessary path. defer it
+ err = r.Get()
+ if err != nil {
+ // TODO(sdboyer) be better
+ return nil, err
+ }
+ }
+
+ // Ensure cache dir exists
+ metadir := path.Join(sm.cachedir, "metadata", string(n))
+ err = os.MkdirAll(metadir, 0777)
+ if err != nil {
+ // TODO(sdboyer) be better
+ return nil, err
+ }
+
+ pms := &pmState{}
+ cpath := path.Join(metadir, "cache.json")
+ fi, err := os.Stat(cpath)
+ var dc *projectDataCache
+ if fi != nil {
+ pms.cf, err = os.OpenFile(cpath, os.O_RDWR, 0777)
+ if err != nil {
+ // TODO(sdboyer) be better
+ return nil, fmt.Errorf("Err on opening metadata cache file: %s", err)
+ }
+
+ err = json.NewDecoder(pms.cf).Decode(dc)
+ if err != nil {
+ // TODO(sdboyer) be better
+ return nil, fmt.Errorf("Err on JSON decoding metadata cache file: %s", err)
+ }
+ } else {
+ // TODO(sdboyer) commented this out for now, until we manage it correctly
+ //pms.cf, err = os.Create(cpath)
+ //if err != nil {
+ //// TODO(sdboyer) be better
+ //return nil, fmt.Errorf("Err on creating metadata cache file: %s", err)
+ //}
+
+ dc = &projectDataCache{
+ Infos: make(map[Revision]projectInfo),
+ Packages: make(map[Revision]PackageTree),
+ VMap: make(map[Version]Revision),
+ RMap: make(map[Revision][]Version),
+ }
+ }
+
+ pm := &projectManager{
+ n: n,
+ ctx: sm.ctx,
+ an: sm.an,
+ dc: dc,
+ crepo: &repo{
+ rpath: repodir,
+ r: r,
+ },
+ }
+
+ pms.pm = pm
+ sm.pms[n] = pms
+ return pms, nil
+}
diff --git a/vendor/github.com/sdboyer/gps/types.go b/vendor/github.com/sdboyer/gps/types.go
new file mode 100644
index 0000000..f720fa2
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/types.go
@@ -0,0 +1,195 @@
+package gps
+
+import (
+ "fmt"
+ "math/rand"
+ "strconv"
+)
+
+// ProjectRoot is the topmost import path in a tree of other import paths - the
+// root of the tree. In gps' current design, ProjectRoots have to correspond to
+// a repository root (mostly), but their real purpose is to identify the root
+// import path of a "project", logically encompassing all child packages.
+//
+// Projects are a crucial unit of operation in gps. Constraints are declared by
+// a project's manifest, and apply to all packages in a ProjectRoot's tree.
+// Solving itself mostly proceeds on a project-by-project basis.
+//
+// Aliasing string types is usually a bit of an anti-pattern. We do it here as a
+// means of clarifying API intent. This is important because Go's package
+// management domain has lots of different path-ish strings floating around:
+//
+// actual directories:
+// /home/sdboyer/go/src/github.com/sdboyer/gps/example
+// URLs:
+// https://github.com/sdboyer/gps
+// import paths:
+// github.com/sdboyer/gps/example
+// portions of import paths that refer to a package:
+// example
+// portions that could not possibly refer to anything sane:
+// github.com/sdboyer
+// portions that correspond to a repository root:
+// github.com/sdboyer/gps
+//
+// While not a panacea, defining ProjectRoot at least allows us to clearly
+// identify when one of these path-ish strings is *supposed* to have certain
+// semantics.
+type ProjectRoot string
+
+// A ProjectIdentifier is, more or less, the name of a dependency. It is related
+// to, but differs in two keys ways from, an import path.
+//
+// First, ProjectIdentifiers do not identify a single package. Rather, they
+// encompasses the whole tree of packages that exist at or below their
+// ProjectRoot. In gps' current design, this ProjectRoot must correspond to the
+// root of a repository, though this may not always be the case.
+//
+// Second, ProjectIdentifiers can optionally carry a NetworkName, which
+// identifies where the underlying source code can be located on the network.
+// These can be either a full URL, including protocol, or plain import paths.
+// So, these are all valid data for NetworkName:
+//
+// github.com/sdboyer/gps
+// github.com/fork/gps
+// git@github.com:sdboyer/gps
+// https://github.com/sdboyer/gps
+//
+// With plain import paths, network addresses are derived purely through an
+// algorithm. By having an explicit network name, it becomes possible to, for
+// example, transparently substitute a fork for an original upstream repository.
+//
+// Note that gps makes no guarantees about the actual import paths contained in
+// a repository aligning with ImportRoot. If tools, or their users, specify an
+// alternate NetworkName that contains a repository with incompatible internal
+// import paths, gps will fail. (gps does no import rewriting.)
+//
+// Also note that if different projects' manifests report a different
+// NetworkName for a given ImportRoot, it is a solve failure. Everyone has to
+// agree on where a given import path should be sourced from.
+//
+// If NetworkName is not explicitly set, gps will derive the network address from
+// the ImportRoot using a similar algorithm to that of the official go tooling.
+type ProjectIdentifier struct {
+ ProjectRoot ProjectRoot
+ NetworkName string
+}
+
+// A ProjectConstraint combines a ProjectIdentifier with a Constraint. It
+// indicates that, if packages contained in the ProjectIdentifier enter the
+// depgraph, they must do so at a version that is allowed by the Constraint.
+type ProjectConstraint struct {
+ Ident ProjectIdentifier
+ Constraint Constraint
+}
+
+func (i ProjectIdentifier) less(j ProjectIdentifier) bool {
+ if i.ProjectRoot < j.ProjectRoot {
+ return true
+ }
+ if j.ProjectRoot < i.ProjectRoot {
+ return false
+ }
+
+ return i.NetworkName < j.NetworkName
+}
+
+func (i ProjectIdentifier) eq(j ProjectIdentifier) bool {
+ if i.ProjectRoot != j.ProjectRoot {
+ return false
+ }
+ if i.NetworkName == j.NetworkName {
+ return true
+ }
+
+ if (i.NetworkName == "" && j.NetworkName == string(j.ProjectRoot)) ||
+ (j.NetworkName == "" && i.NetworkName == string(i.ProjectRoot)) {
+ return true
+ }
+
+ // TODO(sdboyer) attempt conversion to URL and compare base + path
+
+ return false
+}
+
+func (i ProjectIdentifier) netName() string {
+ if i.NetworkName == "" {
+ return string(i.ProjectRoot)
+ }
+ return i.NetworkName
+}
+
+func (i ProjectIdentifier) errString() string {
+ if i.NetworkName == "" || i.NetworkName == string(i.ProjectRoot) {
+ return string(i.ProjectRoot)
+ }
+ return fmt.Sprintf("%s (from %s)", i.ProjectRoot, i.NetworkName)
+}
+
+func (i ProjectIdentifier) normalize() ProjectIdentifier {
+ if i.NetworkName == "" {
+ i.NetworkName = string(i.ProjectRoot)
+ }
+
+ return i
+}
+
+// Package represents a Go package. It contains a subset of the information
+// go/build.Package does.
+type Package struct {
+ ImportPath, CommentPath string
+ Name string
+ Imports []string
+ TestImports []string
+}
+
+// bimodalIdentifiers are used to track work to be done in the unselected queue.
+// TODO(sdboyer) marker for root, to know to ignore prefv...or can we do unselected queue
+// sorting only?
+type bimodalIdentifier struct {
+ id ProjectIdentifier
+ // List of packages required within/under the ProjectIdentifier
+ pl []string
+ // prefv is used to indicate a 'preferred' version. This is expected to be
+ // derived from a dep's lock data, or else is empty.
+ prefv Version
+ // Indicates that the bmi came from the root project originally
+ fromRoot bool
+}
+
+type atom struct {
+ id ProjectIdentifier
+ v Version
+}
+
+// With a random revision and no name, collisions are...unlikely
+var nilpa = atom{
+ v: Revision(strconv.FormatInt(rand.Int63(), 36)),
+}
+
+type atomWithPackages struct {
+ a atom
+ pl []string
+}
+
+//type byImportPath []Package
+
+//func (s byImportPath) Len() int { return len(s) }
+//func (s byImportPath) Less(i, j int) bool { return s[i].ImportPath < s[j].ImportPath }
+//func (s byImportPath) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
+
+// completeDep (name hopefully to change) provides the whole picture of a
+// dependency - the root (repo and project, since currently we assume the two
+// are the same) name, a constraint, and the actual packages needed that are
+// under that root.
+type completeDep struct {
+ // The base ProjectDep
+ ProjectConstraint
+ // The specific packages required from the ProjectDep
+ pl []string
+}
+
+type dependency struct {
+ depender atom
+ dep completeDep
+}
diff --git a/vendor/github.com/sdboyer/vsolver/version.go b/vendor/github.com/sdboyer/gps/version.go
similarity index 98%
rename from vendor/github.com/sdboyer/vsolver/version.go
rename to vendor/github.com/sdboyer/gps/version.go
index bb30631..57d37ec 100644
--- a/vendor/github.com/sdboyer/vsolver/version.go
+++ b/vendor/github.com/sdboyer/gps/version.go
@@ -1,15 +1,15 @@
-package vsolver
+package gps
import "github.com/Masterminds/semver"
-// Version represents one of the different types of versions used by vsolver.
+// Version represents one of the different types of versions used by gps.
//
// Version composes Constraint, because all versions can be used as a constraint
// (where they allow one, and only one, version - themselves), but constraints
// are not necessarily discrete versions.
//
// Version is an interface, but it contains private methods, which restricts it
-// to vsolver's own internal implementations. We do this for the confluence of
+// to gps's own internal implementations. We do this for the confluence of
// two reasons: the implementation of Versions is complete (there is no case in
// which we'd need other types), and the implementation relies on type magic
// under the hood, which would be unsafe to do if other dynamic types could be
diff --git a/vendor/github.com/sdboyer/gps/version_queue.go b/vendor/github.com/sdboyer/gps/version_queue.go
new file mode 100644
index 0000000..e74a1da
--- /dev/null
+++ b/vendor/github.com/sdboyer/gps/version_queue.go
@@ -0,0 +1,142 @@
+package gps
+
+import (
+ "fmt"
+ "strings"
+)
+
+type failedVersion struct {
+ v Version
+ f error
+}
+
+type versionQueue struct {
+ id ProjectIdentifier
+ pi []Version
+ lockv, prefv Version
+ fails []failedVersion
+ b sourceBridge
+ failed bool
+ allLoaded bool
+}
+
+func newVersionQueue(id ProjectIdentifier, lockv, prefv Version, b sourceBridge) (*versionQueue, error) {
+ vq := &versionQueue{
+ id: id,
+ b: b,
+ }
+
+ // Lock goes in first, if present
+ if lockv != nil {
+ vq.lockv = lockv
+ vq.pi = append(vq.pi, lockv)
+ }
+
+ // Preferred version next
+ if prefv != nil {
+ vq.prefv = prefv
+ vq.pi = append(vq.pi, prefv)
+ }
+
+ if len(vq.pi) == 0 {
+ var err error
+ vq.pi, err = vq.b.listVersions(vq.id)
+ if err != nil {
+ // TODO(sdboyer) pushing this error this early entails that we
+ // unconditionally deep scan (e.g. vendor), as well as hitting the
+ // network.
+ return nil, err
+ }
+ vq.allLoaded = true
+ }
+
+ return vq, nil
+}
+
+func (vq *versionQueue) current() Version {
+ if len(vq.pi) > 0 {
+ return vq.pi[0]
+ }
+
+ return nil
+}
+
+// advance moves the versionQueue forward to the next available version,
+// recording the failure that eliminated the current version.
+func (vq *versionQueue) advance(fail error) (err error) {
+ // Nothing in the queue means...nothing in the queue, nicely enough
+ if len(vq.pi) == 0 {
+ return
+ }
+
+ // Record the fail reason and pop the queue
+ vq.fails = append(vq.fails, failedVersion{
+ v: vq.pi[0],
+ f: fail,
+ })
+ vq.pi = vq.pi[1:]
+
+ // *now*, if the queue is empty, ensure all versions have been loaded
+ if len(vq.pi) == 0 {
+ if vq.allLoaded {
+ // This branch gets hit when the queue is first fully exhausted,
+ // after having been populated by ListVersions() on a previous
+ // advance()
+ return
+ }
+
+ vq.allLoaded = true
+ vq.pi, err = vq.b.listVersions(vq.id)
+ if err != nil {
+ return err
+ }
+
+ // search for and remove locked and pref versions
+ //
+ // could use the version comparator for binary search here to avoid
+ // O(n) each time...if it matters
+ for k, pi := range vq.pi {
+ if pi == vq.lockv || pi == vq.prefv {
+ // GC-safe deletion for slice w/pointer elements
+ vq.pi, vq.pi[len(vq.pi)-1] = append(vq.pi[:k], vq.pi[k+1:]...), nil
+ //vq.pi = append(vq.pi[:k], vq.pi[k+1:]...)
+ }
+ }
+
+ if len(vq.pi) == 0 {
+ // If listing versions added nothing (new), then return now
+ return
+ }
+ }
+
+ // We're finally sure that there's something in the queue. Remove the
+ // failure marker, as the current version may have failed, but the next one
+ // hasn't yet
+ vq.failed = false
+
+ // If all have been loaded and the queue is empty, we're definitely out
+ // of things to try. Return empty, though, because vq semantics dictate
+ // that we don't explicitly indicate the end of the queue here.
+ return
+}
+
+// isExhausted indicates whether or not the queue has definitely been exhausted,
+// in which case it will return true.
+//
+// It may return false negatives - suggesting that there is more in the queue
+// when a subsequent call to current() will be empty. Plan accordingly.
+func (vq *versionQueue) isExhausted() bool {
+ if !vq.allLoaded {
+ return false
+ }
+ return len(vq.pi) == 0
+}
+
+func (vq *versionQueue) String() string {
+ var vs []string
+
+ for _, v := range vq.pi {
+ vs = append(vs, v.String())
+ }
+ return fmt.Sprintf("[%s]", strings.Join(vs, ", "))
+}
diff --git a/vendor/github.com/sdboyer/vsolver/version_test.go b/vendor/github.com/sdboyer/gps/version_test.go
similarity index 99%
rename from vendor/github.com/sdboyer/vsolver/version_test.go
rename to vendor/github.com/sdboyer/gps/version_test.go
index 738f850..f8b9b89 100644
--- a/vendor/github.com/sdboyer/vsolver/version_test.go
+++ b/vendor/github.com/sdboyer/gps/version_test.go
@@ -1,4 +1,4 @@
-package vsolver
+package gps
import (
"sort"
diff --git a/vendor/github.com/sdboyer/vsolver/README.md b/vendor/github.com/sdboyer/vsolver/README.md
deleted file mode 100644
index 6126f29..0000000
--- a/vendor/github.com/sdboyer/vsolver/README.md
+++ /dev/null
@@ -1,105 +0,0 @@
-# vsolver
-
-`vsolver` is a specialized [SAT
-solver](https://en.wikipedia.org/wiki/Boolean_satisfiability_problem),
-designed as an engine for Go package management. The initial plan is
-integration into [glide](https://github.com/Masterminds/glide), but
-`vsolver` could be used by any tool interested in [fully
-solving](www.mancoosi.org/edos/manager/) [the package management
-problem](https://medium.com/@sdboyer/so-you-want-to-write-a-package-manager-4ae9c17d9527).
-
-**NOTE - `vsolver` isn’t ready yet, but it’s getting close.**
-
-The implementation is derived from the solver used in Dart's
-[pub](https://github.com/dart-lang/pub/tree/master/lib/src/solver)
-package management tool.
-
-## Assumptions
-
-Package management is far too complex to be assumption-less. `vsolver`
-tries to keep its assumptions to the minimum, supporting as many
-situations as is possible while still maintaining a predictable,
-well-formed system.
-
-* Go 1.6, or 1.5 with `GO15VENDOREXPERIMENT = 1` set. `vendor`
- directories are a requirement.
-* You don't manually change what's under `vendor/`. That’s tooling’s
- job.
-* A **project** concept, where projects comprise the set of Go packages
- in a rooted tree on the filesystem. By happy (not) accident, that
- rooted tree is exactly the same set of packages covered by a `vendor/`
- directory.
-* A manifest-and-lock approach to tracking project manifest data. The
- solver takes manifest (and, optionally, lock)-type data as inputs, and
- produces lock-type data as its output. Tools decide how to actually
- store this data, but these should generally be at the root of the
- project tree.
-
-Manifests? Locks? Eeew. Yes, we also think it'd be swell if we didn't need
-metadata files. We love the idea of Go packages as standalone, self-describing
-code. Unfortunately, the wheels come off that idea as soon as versioning and
-cross-project/repository dependencies happen. [Universe alignment is
-hard](https://medium.com/@sdboyer/so-you-want-to-write-a-package-manager-4ae9c17d9527);
-trying to intermix version information directly with the code would only make
-matters worse.
-
-## Arguments
-
-Some folks are against using a solver in Go. Even the concept is repellent.
-These are some of the arguments that are raised:
-
-> "It seems complicated, and idiomatic Go things are simple!"
-
-Complaining about this is shooting the messenger.
-
-Selecting acceptable versions out of a big dependency graph is a [boolean
-satisfiability](https://en.wikipedia.org/wiki/Boolean_satisfiability_problem)
-(or SAT) problem: given all possible combinations of valid dependencies, we’re
-trying to find a set that satisfies all the mutual requirements. Obviously that
-requires version numbers lining up, but it can also (and `vsolver` will/does)
-enforce invariants like “no import cycles” and type compatibility between
-packages. All of those requirements must be rechecked *every time* we discovery
-and add a new project to the graph.
-
-SAT was one of the very first problems to be proven NP-complete. **OF COURSE
-IT’S COMPLICATED**. We didn’t make it that way. Truth is, though, solvers are
-an ideal way of tackling this kind of problem: it lets us walk the line between
-pretending like versions don’t exist (a la `go get`) and pretending like only
-one version of a dep could ever work, ever (most of the current community
-tools).
-
-> "(Tool X) uses a solver and I don't like that tool’s UX!"
-
-Sure, there are plenty of abstruse package managers relying on SAT
-solvers out there. But that doesn’t mean they ALL have to be confusing.
-`vsolver`’s algorithms are artisinally handcrafted with ❤️ for Go’s
-use case, and we are committed to making Go dependency management a
-grokkable process.
-
-## Features
-
-Yes, most people will probably find most of this list incomprehensible
-right now. We'll improve/add explanatory links as we go!
-
-* [x] [Passing bestiary of tests](https://github.com/sdboyer/vsolver/issues/1)
- brought over from dart
-* [x] Dependency constraints based on [SemVer](http://semver.org/),
- branches, and revisions. AKA, "all the ways you might depend on
- Go code now, but coherently organized."
-* [x] Define different network addresses for a given import path
-* [ ] Global project aliasing. This is a bit different than the previous.
-* [x] Bi-modal analysis (project-level and package-level)
-* [ ] Specific sub-package dependencies
-* [ ] Enforcing an acyclic project graph (mirroring the Go compiler's
- enforcement of an acyclic package import graph)
-* [ ] On-the-fly static analysis (e.g. for incompatibility assessment,
- type escaping)
-* [ ] Optional package duplication as a conflict resolution mechanism
-* [ ] Faaaast, enabled by aggressive caching of project metadata
-* [ ] Lock information parameterized by build tags (including, but not
- limited to, `GOOS`/`GOARCH`)
-* [ ] Non-repository root and nested manifest/lock pairs
-
-Note that these goals are not fixed - we may drop some as we continue
-working. Some are also probably out of scope for the solver itself,
-but still related to the solver's operation.
diff --git a/vendor/github.com/sdboyer/vsolver/_testdata/src/igmain/a.go b/vendor/github.com/sdboyer/vsolver/_testdata/src/igmain/a.go
deleted file mode 100644
index 921df11..0000000
--- a/vendor/github.com/sdboyer/vsolver/_testdata/src/igmain/a.go
+++ /dev/null
@@ -1,12 +0,0 @@
-package simple
-
-import (
- "sort"
-
- "github.com/sdboyer/vsolver"
-)
-
-var (
- _ = sort.Strings
- _ = vsolver.Solve
-)
diff --git a/vendor/github.com/sdboyer/vsolver/_testdata/src/igmaint/a.go b/vendor/github.com/sdboyer/vsolver/_testdata/src/igmaint/a.go
deleted file mode 100644
index 921df11..0000000
--- a/vendor/github.com/sdboyer/vsolver/_testdata/src/igmaint/a.go
+++ /dev/null
@@ -1,12 +0,0 @@
-package simple
-
-import (
- "sort"
-
- "github.com/sdboyer/vsolver"
-)
-
-var (
- _ = sort.Strings
- _ = vsolver.Solve
-)
diff --git a/vendor/github.com/sdboyer/vsolver/_testdata/src/m1p/a.go b/vendor/github.com/sdboyer/vsolver/_testdata/src/m1p/a.go
deleted file mode 100644
index cf8d759..0000000
--- a/vendor/github.com/sdboyer/vsolver/_testdata/src/m1p/a.go
+++ /dev/null
@@ -1,12 +0,0 @@
-package m1p
-
-import (
- "sort"
-
- "github.com/sdboyer/vsolver"
-)
-
-var (
- _ = sort.Strings
- _ = vsolver.Solve
-)
diff --git a/vendor/github.com/sdboyer/vsolver/_testdata/src/nest/a.go b/vendor/github.com/sdboyer/vsolver/_testdata/src/nest/a.go
deleted file mode 100644
index 921df11..0000000
--- a/vendor/github.com/sdboyer/vsolver/_testdata/src/nest/a.go
+++ /dev/null
@@ -1,12 +0,0 @@
-package simple
-
-import (
- "sort"
-
- "github.com/sdboyer/vsolver"
-)
-
-var (
- _ = sort.Strings
- _ = vsolver.Solve
-)
diff --git a/vendor/github.com/sdboyer/vsolver/_testdata/src/nest/m1p/a.go b/vendor/github.com/sdboyer/vsolver/_testdata/src/nest/m1p/a.go
deleted file mode 100644
index cf8d759..0000000
--- a/vendor/github.com/sdboyer/vsolver/_testdata/src/nest/m1p/a.go
+++ /dev/null
@@ -1,12 +0,0 @@
-package m1p
-
-import (
- "sort"
-
- "github.com/sdboyer/vsolver"
-)
-
-var (
- _ = sort.Strings
- _ = vsolver.Solve
-)
diff --git a/vendor/github.com/sdboyer/vsolver/_testdata/src/ren/m1p/a.go b/vendor/github.com/sdboyer/vsolver/_testdata/src/ren/m1p/a.go
deleted file mode 100644
index cf8d759..0000000
--- a/vendor/github.com/sdboyer/vsolver/_testdata/src/ren/m1p/a.go
+++ /dev/null
@@ -1,12 +0,0 @@
-package m1p
-
-import (
- "sort"
-
- "github.com/sdboyer/vsolver"
-)
-
-var (
- _ = sort.Strings
- _ = vsolver.Solve
-)
diff --git a/vendor/github.com/sdboyer/vsolver/_testdata/src/ren/simple/a.go b/vendor/github.com/sdboyer/vsolver/_testdata/src/ren/simple/a.go
deleted file mode 100644
index 921df11..0000000
--- a/vendor/github.com/sdboyer/vsolver/_testdata/src/ren/simple/a.go
+++ /dev/null
@@ -1,12 +0,0 @@
-package simple
-
-import (
- "sort"
-
- "github.com/sdboyer/vsolver"
-)
-
-var (
- _ = sort.Strings
- _ = vsolver.Solve
-)
diff --git a/vendor/github.com/sdboyer/vsolver/_testdata/src/simple/a.go b/vendor/github.com/sdboyer/vsolver/_testdata/src/simple/a.go
deleted file mode 100644
index 921df11..0000000
--- a/vendor/github.com/sdboyer/vsolver/_testdata/src/simple/a.go
+++ /dev/null
@@ -1,12 +0,0 @@
-package simple
-
-import (
- "sort"
-
- "github.com/sdboyer/vsolver"
-)
-
-var (
- _ = sort.Strings
- _ = vsolver.Solve
-)
diff --git a/vendor/github.com/sdboyer/vsolver/_testdata/src/simpleallt/a.go b/vendor/github.com/sdboyer/vsolver/_testdata/src/simpleallt/a.go
deleted file mode 100644
index 921df11..0000000
--- a/vendor/github.com/sdboyer/vsolver/_testdata/src/simpleallt/a.go
+++ /dev/null
@@ -1,12 +0,0 @@
-package simple
-
-import (
- "sort"
-
- "github.com/sdboyer/vsolver"
-)
-
-var (
- _ = sort.Strings
- _ = vsolver.Solve
-)
diff --git a/vendor/github.com/sdboyer/vsolver/_testdata/src/simplet/a.go b/vendor/github.com/sdboyer/vsolver/_testdata/src/simplet/a.go
deleted file mode 100644
index 921df11..0000000
--- a/vendor/github.com/sdboyer/vsolver/_testdata/src/simplet/a.go
+++ /dev/null
@@ -1,12 +0,0 @@
-package simple
-
-import (
- "sort"
-
- "github.com/sdboyer/vsolver"
-)
-
-var (
- _ = sort.Strings
- _ = vsolver.Solve
-)
diff --git a/vendor/github.com/sdboyer/vsolver/_testdata/src/simplext/a.go b/vendor/github.com/sdboyer/vsolver/_testdata/src/simplext/a.go
deleted file mode 100644
index 921df11..0000000
--- a/vendor/github.com/sdboyer/vsolver/_testdata/src/simplext/a.go
+++ /dev/null
@@ -1,12 +0,0 @@
-package simple
-
-import (
- "sort"
-
- "github.com/sdboyer/vsolver"
-)
-
-var (
- _ = sort.Strings
- _ = vsolver.Solve
-)
diff --git a/vendor/github.com/sdboyer/vsolver/_testdata/src/twopkgs/a.go b/vendor/github.com/sdboyer/vsolver/_testdata/src/twopkgs/a.go
deleted file mode 100644
index 921df11..0000000
--- a/vendor/github.com/sdboyer/vsolver/_testdata/src/twopkgs/a.go
+++ /dev/null
@@ -1,12 +0,0 @@
-package simple
-
-import (
- "sort"
-
- "github.com/sdboyer/vsolver"
-)
-
-var (
- _ = sort.Strings
- _ = vsolver.Solve
-)
diff --git a/vendor/github.com/sdboyer/vsolver/_testdata/src/varied/m1p/a.go b/vendor/github.com/sdboyer/vsolver/_testdata/src/varied/m1p/a.go
deleted file mode 100644
index 181620f..0000000
--- a/vendor/github.com/sdboyer/vsolver/_testdata/src/varied/m1p/a.go
+++ /dev/null
@@ -1,12 +0,0 @@
-package m1p
-
-import (
- "sort"
-
- "github.com/sdboyer/vsolver"
-)
-
-var (
- M = sort.Strings
- _ = vsolver.Solve
-)
diff --git a/vendor/github.com/sdboyer/vsolver/_testdata/src/varied/simple/simple.go b/vendor/github.com/sdboyer/vsolver/_testdata/src/varied/simple/simple.go
deleted file mode 100644
index ed4a9c0..0000000
--- a/vendor/github.com/sdboyer/vsolver/_testdata/src/varied/simple/simple.go
+++ /dev/null
@@ -1,12 +0,0 @@
-package simple
-
-import (
- "go/parser"
-
- "github.com/sdboyer/vsolver"
-)
-
-var (
- _ = parser.ParseFile
- S = vsolver.Prepare
-)
diff --git a/vendor/github.com/sdboyer/vsolver/analysis.go b/vendor/github.com/sdboyer/vsolver/analysis.go
deleted file mode 100644
index b91d2a5..0000000
--- a/vendor/github.com/sdboyer/vsolver/analysis.go
+++ /dev/null
@@ -1,760 +0,0 @@
-package vsolver
-
-import (
- "bytes"
- "fmt"
- "go/build"
- "io"
- "io/ioutil"
- "os"
- "path/filepath"
- "sort"
- "strings"
- "text/scanner"
-)
-
-var osList []string
-var archList []string
-var stdlib = make(map[string]struct{})
-
-const stdlibPkgs string = "archive archive/tar archive/zip bufio builtin bytes compress compress/bzip2 compress/flate compress/gzip compress/lzw compress/zlib container container/heap container/list container/ring context crypto crypto/aes crypto/cipher crypto/des crypto/dsa crypto/ecdsa crypto/elliptic crypto/hmac crypto/md5 crypto/rand crypto/rc4 crypto/rsa crypto/sha1 crypto/sha256 crypto/sha512 crypto/subtle crypto/tls crypto/x509 crypto/x509/pkix database database/sql database/sql/driver debug debug/dwarf debug/elf debug/gosym debug/macho debug/pe debug/plan9obj encoding encoding/ascii85 encoding/asn1 encoding/base32 encoding/base64 encoding/binary encoding/csv encoding/gob encoding/hex encoding/json encoding/pem encoding/xml errors expvar flag fmt go go/ast go/build go/constant go/doc go/format go/importer go/parser go/printer go/scanner go/token go/types hash hash/adler32 hash/crc32 hash/crc64 hash/fnv html html/template image image/color image/color/palette image/draw image/gif image/jpeg image/png index index/suffixarray io io/ioutil log log/syslog math math/big math/cmplx math/rand mime mime/multipart mime/quotedprintable net net/http net/http/cgi net/http/cookiejar net/http/fcgi net/http/httptest net/http/httputil net/http/pprof net/mail net/rpc net/rpc/jsonrpc net/smtp net/textproto net/url os os/exec os/signal os/user path path/filepath reflect regexp regexp/syntax runtime runtime/cgo runtime/debug runtime/msan runtime/pprof runtime/race runtime/trace sort strconv strings sync sync/atomic syscall testing testing/iotest testing/quick text text/scanner text/tabwriter text/template text/template/parse time unicode unicode/utf16 unicode/utf8 unsafe"
-
-func init() {
- // The supported systems are listed in
- // https://github.com/golang/go/blob/master/src/go/build/syslist.go
- // The lists are not exported so we need to duplicate them here.
- osListString := "android darwin dragonfly freebsd linux nacl netbsd openbsd plan9 solaris windows"
- osList = strings.Split(osListString, " ")
-
- archListString := "386 amd64 amd64p32 arm armbe arm64 arm64be ppc64 ppc64le mips mipsle mips64 mips64le mips64p32 mips64p32le ppc s390 s390x sparc sparc64"
- archList = strings.Split(archListString, " ")
-
- for _, pkg := range strings.Split(stdlibPkgs, " ") {
- stdlib[pkg] = struct{}{}
- }
-}
-
-// listPackages lists info for all packages at or below the provided fileRoot.
-//
-// Directories without any valid Go files are excluded. Directories with
-// multiple packages are excluded.
-//
-// The importRoot parameter is prepended to the relative path when determining
-// the import path for each package. The obvious case is for something typical,
-// like:
-//
-// fileRoot = "/home/user/go/src/github.com/foo/bar"
-// importRoot = "github.com/foo/bar"
-//
-// where the fileRoot and importRoot align. However, if you provide:
-//
-// fileRoot = "/home/user/workspace/path/to/repo"
-// importRoot = "github.com/foo/bar"
-//
-// then the root package at path/to/repo will be ascribed import path
-// "github.com/foo/bar", and its subpackage "baz" will be
-// "github.com/foo/bar/baz".
-//
-// A PackageTree is returned, which contains the ImportRoot and map of import path
-// to PackageOrErr - each path under the root that exists will have either a
-// Package, or an error describing why the directory is not a valid package.
-func listPackages(fileRoot, importRoot string) (PackageTree, error) {
- // Set up a build.ctx for parsing
- ctx := build.Default
- ctx.GOROOT = ""
- ctx.GOPATH = ""
- ctx.UseAllFiles = true
-
- ptree := PackageTree{
- ImportRoot: importRoot,
- Packages: make(map[string]PackageOrErr),
- }
-
- // mkfilter returns two funcs that can be injected into a
- // build.Context, letting us filter the results into an "in" and "out" set.
- mkfilter := func(files map[string]struct{}) (in, out func(dir string) (fi []os.FileInfo, err error)) {
- in = func(dir string) (fi []os.FileInfo, err error) {
- all, err := ioutil.ReadDir(dir)
- if err != nil {
- return nil, err
- }
-
- for _, f := range all {
- if _, exists := files[f.Name()]; exists {
- fi = append(fi, f)
- }
- }
- return fi, nil
- }
-
- out = func(dir string) (fi []os.FileInfo, err error) {
- all, err := ioutil.ReadDir(dir)
- if err != nil {
- return nil, err
- }
-
- for _, f := range all {
- if _, exists := files[f.Name()]; !exists {
- fi = append(fi, f)
- }
- }
- return fi, nil
- }
-
- return
- }
-
- // helper func to create a Package from a *build.Package
- happy := func(importPath string, p *build.Package) Package {
- // Happy path - simple parsing worked
- pkg := Package{
- ImportPath: importPath,
- CommentPath: p.ImportComment,
- Name: p.Name,
- Imports: p.Imports,
- TestImports: dedupeStrings(p.TestImports, p.XTestImports),
- }
-
- return pkg
- }
-
- err := filepath.Walk(fileRoot, func(path string, fi os.FileInfo, err error) error {
- if err != nil && err != filepath.SkipDir {
- return err
- }
- if !fi.IsDir() {
- return nil
- }
-
- // Skip a few types of dirs
- if !localSrcDir(fi) {
- return filepath.SkipDir
- }
-
- // Compute the import path. Run the result through ToSlash(), so that windows
- // paths are normalized to Unix separators, as import paths are expected
- // to be.
- ip := filepath.ToSlash(filepath.Join(importRoot, strings.TrimPrefix(path, fileRoot)))
-
- // Find all the imports, across all os/arch combos
- p, err := ctx.ImportDir(path, analysisImportMode())
- var pkg Package
- if err == nil {
- pkg = happy(ip, p)
- } else {
- switch terr := err.(type) {
- case *build.NoGoError:
- ptree.Packages[ip] = PackageOrErr{
- Err: err,
- }
- return nil
- case *build.MultiplePackageError:
- // Set this up preemptively, so we can easily just return out if
- // something goes wrong. Otherwise, it'll get transparently
- // overwritten later.
- ptree.Packages[ip] = PackageOrErr{
- Err: err,
- }
-
- // For now, we're punting entirely on dealing with os/arch
- // combinations. That will be a more significant refactor.
- //
- // However, there is one case we want to allow here - a single
- // file, with "+build ignore", that's a main package. (Ignore is
- // just a convention, but for now it's good enough to just check
- // that.) This is a fairly common way to make a more
- // sophisticated build system than a Makefile allows, so we want
- // to support that case. So, transparently lump the deps
- // together.
- mains := make(map[string]struct{})
- for k, pkgname := range terr.Packages {
- if pkgname == "main" {
- tags, err2 := readFileBuildTags(filepath.Join(path, terr.Files[k]))
- if err2 != nil {
- return nil
- }
-
- var hasignore bool
- for _, t := range tags {
- if t == "ignore" {
- hasignore = true
- break
- }
- }
- if !hasignore {
- // No ignore tag found - bail out
- return nil
- }
- mains[terr.Files[k]] = struct{}{}
- }
- }
- // Make filtering funcs that will let us look only at the main
- // files, and exclude the main files; inf and outf, respectively
- inf, outf := mkfilter(mains)
-
- // outf first; if there's another err there, we bail out with a
- // return
- ctx.ReadDir = outf
- po, err2 := ctx.ImportDir(path, analysisImportMode())
- if err2 != nil {
- return nil
- }
- ctx.ReadDir = inf
- pi, err2 := ctx.ImportDir(path, analysisImportMode())
- if err2 != nil {
- return nil
- }
- ctx.ReadDir = nil
-
- // Use the other files as baseline, they're the main stuff
- pkg = happy(ip, po)
- mpkg := happy(ip, pi)
- pkg.Imports = dedupeStrings(pkg.Imports, mpkg.Imports)
- pkg.TestImports = dedupeStrings(pkg.TestImports, mpkg.TestImports)
- default:
- return err
- }
- }
-
- ptree.Packages[ip] = PackageOrErr{
- P: pkg,
- }
-
- return nil
- })
-
- if err != nil {
- return PackageTree{}, err
- }
-
- return ptree, nil
-}
-
-type wm struct {
- ex map[string]struct{}
- in map[string]struct{}
-}
-
-// wmToReach takes an externalReach()-style workmap and transitively walks all
-// internal imports until they reach an external path or terminate, then
-// translates the results into a slice of external imports for each internal
-// pkg.
-//
-// The basedir string, with a trailing slash ensured, will be stripped from the
-// keys of the returned map.
-func wmToReach(workmap map[string]wm, basedir string) (rm map[string][]string, err error) {
- // Just brute-force through the workmap, repeating until we make no
- // progress, either because no packages have any unresolved internal
- // packages left (in which case we're done), or because some packages can't
- // find something in the 'in' list (which shouldn't be possible)
- //
- // This implementation is hilariously inefficient in pure computational
- // complexity terms - worst case is some flavor of polynomial, versus O(n)
- // for the filesystem scan done in externalReach(). However, the coefficient
- // for filesystem access is so much larger than for memory twiddling that it
- // would probably take an absurdly large and snaky project to ever have that
- // worst-case polynomial growth supercede (or even become comparable to) the
- // linear side.
- //
- // But, if that day comes, we can improve this algorithm.
- rm = make(map[string][]string)
- var complete bool
- for !complete {
- var progress bool
- complete = true
-
- for pkg, w := range workmap {
- if len(w.in) == 0 {
- continue
- }
- complete = false
- // Each pass should always empty the original in list, but there
- // could be more in lists inherited from the other package
- // (transitive internal deps)
- for in := range w.in {
- if w2, exists := workmap[in]; !exists {
- return nil, fmt.Errorf("Should be impossible: %s depends on %s, but %s not in workmap", pkg, in, in)
- } else {
- progress = true
- delete(w.in, in)
-
- for i := range w2.ex {
- w.ex[i] = struct{}{}
- }
- for i := range w2.in {
- w.in[i] = struct{}{}
- }
- }
- }
- }
-
- if !complete && !progress {
- // Can't conceive of a way that we'd hit this, but this guards
- // against infinite loop
- panic("unreachable")
- }
- }
-
- // finally, transform to slice for return
- rm = make(map[string][]string)
- // ensure we have a version of the basedir w/trailing slash, for stripping
- rt := strings.TrimSuffix(basedir, string(os.PathSeparator)) + string(os.PathSeparator)
-
- for pkg, w := range workmap {
- if len(w.ex) == 0 {
- rm[strings.TrimPrefix(pkg, rt)] = nil
- continue
- }
-
- edeps := make([]string, len(w.ex))
- k := 0
- for opkg := range w.ex {
- edeps[k] = opkg
- k++
- }
-
- sort.Strings(edeps)
- rm[strings.TrimPrefix(pkg, rt)] = edeps
- }
-
- return rm, nil
-}
-
-func localSrcDir(fi os.FileInfo) bool {
- // Ignore _foo and .foo, and testdata
- name := fi.Name()
- if strings.HasPrefix(name, ".") || strings.HasPrefix(name, "_") || name == "testdata" {
- return false
- }
-
- // Ignore dirs that are expressly intended for non-project source
- switch name {
- case "vendor", "Godeps":
- return false
- default:
- return true
- }
-}
-
-func readBuildTags(p string) ([]string, error) {
- _, err := os.Stat(p)
- if err != nil {
- return []string{}, err
- }
-
- d, err := os.Open(p)
- if err != nil {
- return []string{}, err
- }
-
- objects, err := d.Readdir(-1)
- if err != nil {
- return []string{}, err
- }
-
- var tags []string
- for _, obj := range objects {
-
- // only process Go files
- if strings.HasSuffix(obj.Name(), ".go") {
- fp := filepath.Join(p, obj.Name())
-
- co, err := readGoContents(fp)
- if err != nil {
- return []string{}, err
- }
-
- // Only look at places where we had a code comment.
- if len(co) > 0 {
- t := findTags(co)
- for _, tg := range t {
- found := false
- for _, tt := range tags {
- if tt == tg {
- found = true
- }
- }
- if !found {
- tags = append(tags, tg)
- }
- }
- }
- }
- }
-
- return tags, nil
-}
-
-func readFileBuildTags(fp string) ([]string, error) {
- co, err := readGoContents(fp)
- if err != nil {
- return []string{}, err
- }
-
- var tags []string
- // Only look at places where we had a code comment.
- if len(co) > 0 {
- t := findTags(co)
- for _, tg := range t {
- found := false
- for _, tt := range tags {
- if tt == tg {
- found = true
- }
- }
- if !found {
- tags = append(tags, tg)
- }
- }
- }
-
- return tags, nil
-}
-
-// Read contents of a Go file up to the package declaration. This can be used
-// to find the the build tags.
-func readGoContents(fp string) ([]byte, error) {
- f, err := os.Open(fp)
- defer f.Close()
- if err != nil {
- return []byte{}, err
- }
-
- var s scanner.Scanner
- s.Init(f)
- var tok rune
- var pos scanner.Position
- for tok != scanner.EOF {
- tok = s.Scan()
-
- // Getting the token text will skip comments by default.
- tt := s.TokenText()
- // build tags will not be after the package declaration.
- if tt == "package" {
- pos = s.Position
- break
- }
- }
-
- var buf bytes.Buffer
- f.Seek(0, 0)
- _, err = io.CopyN(&buf, f, int64(pos.Offset))
- if err != nil {
- return []byte{}, err
- }
-
- return buf.Bytes(), nil
-}
-
-// From a byte slice of a Go file find the tags.
-func findTags(co []byte) []string {
- p := co
- var tgs []string
- for len(p) > 0 {
- line := p
- if i := bytes.IndexByte(line, '\n'); i >= 0 {
- line, p = line[:i], p[i+1:]
- } else {
- p = p[len(p):]
- }
- line = bytes.TrimSpace(line)
- // Only look at comment lines that are well formed in the Go style
- if bytes.HasPrefix(line, []byte("//")) {
- line = bytes.TrimSpace(line[len([]byte("//")):])
- if len(line) > 0 && line[0] == '+' {
- f := strings.Fields(string(line))
-
- // We've found a +build tag line.
- if f[0] == "+build" {
- for _, tg := range f[1:] {
- tgs = append(tgs, tg)
- }
- }
- }
- }
- }
-
- return tgs
-}
-
-// Get an OS value that's not the one passed in.
-func getOsValue(n string) string {
- for _, o := range osList {
- if o != n {
- return o
- }
- }
-
- return n
-}
-
-func isSupportedOs(n string) bool {
- for _, o := range osList {
- if o == n {
- return true
- }
- }
-
- return false
-}
-
-// Get an Arch value that's not the one passed in.
-func getArchValue(n string) string {
- for _, o := range archList {
- if o != n {
- return o
- }
- }
-
- return n
-}
-
-func isSupportedArch(n string) bool {
- for _, o := range archList {
- if o == n {
- return true
- }
- }
-
- return false
-}
-
-func ensureTrailingSlash(s string) string {
- return strings.TrimSuffix(s, string(os.PathSeparator)) + string(os.PathSeparator)
-}
-
-// helper func to merge, dedupe, and sort strings
-func dedupeStrings(s1, s2 []string) (r []string) {
- dedupe := make(map[string]bool)
-
- if len(s1) > 0 && len(s2) > 0 {
- for _, i := range s1 {
- dedupe[i] = true
- }
- for _, i := range s2 {
- dedupe[i] = true
- }
-
- for i := range dedupe {
- r = append(r, i)
- }
- // And then re-sort them
- sort.Strings(r)
- } else if len(s1) > 0 {
- r = s1
- } else if len(s2) > 0 {
- r = s2
- }
-
- return
-}
-
-// A PackageTree represents the results of recursively parsing a tree of
-// packages, starting at the ImportRoot. The results of parsing the files in the
-// directory identified by each import path - a Package or an error - are stored
-// in the Packages map, keyed by that import path.
-type PackageTree struct {
- ImportRoot string
- Packages map[string]PackageOrErr
-}
-
-// PackageOrErr stores the results of attempting to parse a single directory for
-// Go source code.
-type PackageOrErr struct {
- P Package
- Err error
-}
-
-// ExternalReach looks through a PackageTree and computes the list of external
-// packages (not logical children of PackageTree.ImportRoot) that are
-// transitively imported by the internal packages in the tree.
-//
-// main indicates whether (true) or not (false) to include main packages in the
-// analysis. main packages should generally be excluded when analyzing the
-// non-root dependency, as they inherently can't be imported.
-//
-// tests indicates whether (true) or not (false) to include imports from test
-// files in packages when computing the reach map.
-//
-// ignore is a map of import paths that, if encountered, should be excluded from
-// analysis. This exclusion applies to both internal and external packages. If
-// an external import path is ignored, it is simply omitted from the results.
-//
-// If an internal path is ignored, then it is excluded from all transitive
-// dependency chains and does not appear as a key in the final map. That is, if
-// you ignore A/foo, then the external package list for all internal packages
-// that import A/foo will not include external packages were only reachable
-// through A/foo.
-//
-// Visually, this means that, given a PackageTree with root A and packages at A,
-// A/foo, and A/bar, and the following import chain:
-//
-// A -> A/foo -> A/bar -> B/baz
-//
-// If you ignore A/foo, then the returned map would be:
-//
-// map[string][]string{
-// "A": []string{},
-// "A/bar": []string{"B/baz"},
-// }
-//
-// It is safe to pass a nil map if there are no packages to ignore.
-func (t PackageTree) ExternalReach(main, tests bool, ignore map[string]bool) (map[string][]string, error) {
- var someerrs bool
-
- if ignore == nil {
- ignore = make(map[string]bool)
- }
-
- // world's simplest adjacency list
- workmap := make(map[string]wm)
-
- var imps []string
- for ip, perr := range t.Packages {
- if perr.Err != nil {
- someerrs = true
- continue
- }
- p := perr.P
- // Skip main packages, unless param says otherwise
- if p.Name == "main" && !main {
- continue
- }
- // Skip ignored packages
- if ignore[ip] {
- continue
- }
-
- imps = imps[:0]
- imps = p.Imports
- if tests {
- imps = dedupeStrings(imps, p.TestImports)
- }
-
- w := wm{
- ex: make(map[string]struct{}),
- in: make(map[string]struct{}),
- }
-
- for _, imp := range imps {
- if ignore[imp] {
- continue
- }
-
- if !checkPrefixSlash(filepath.Clean(imp), t.ImportRoot) {
- w.ex[imp] = struct{}{}
- } else {
- if w2, seen := workmap[imp]; seen {
- for i := range w2.ex {
- w.ex[i] = struct{}{}
- }
- for i := range w2.in {
- w.in[i] = struct{}{}
- }
- } else {
- w.in[imp] = struct{}{}
- }
- }
- }
-
- workmap[ip] = w
- }
-
- if len(workmap) == 0 {
- if someerrs {
- // TODO proper errs
- return nil, fmt.Errorf("no packages without errors in %s", t.ImportRoot)
- }
- return nil, nil
- }
-
- //return wmToReach(workmap, t.ImportRoot)
- return wmToReach(workmap, "") // TODO this passes tests, but doesn't seem right
-}
-
-// ListExternalImports computes a sorted, deduplicated list of all the external
-// packages that are imported by all packages in the PackageTree.
-//
-// "External" is defined as anything not prefixed, after path cleaning, by the
-// PackageTree.ImportRoot. This includes stdlib.
-//
-// If an internal path is ignored, all of the external packages that it uniquely
-// imports are omitted. Note, however, that no internal transitivity checks are
-// made here - every non-ignored package in the tree is considered
-// independently. That means, given a PackageTree with root A and packages at A,
-// A/foo, and A/bar, and the following import chain:
-//
-// A -> A/foo -> A/bar -> B/baz
-//
-// If you ignore A or A/foo, A/bar will still be visited, and B/baz will be
-// returned, because this method visits ALL packages in the tree, not only those reachable
-// from the root (or any other) packages. If your use case requires interrogating
-// external imports with respect to only specific package entry points, you need
-// ExternalReach() instead.
-//
-// It is safe to pass a nil map if there are no packages to ignore.
-func (t PackageTree) ListExternalImports(main, tests bool, ignore map[string]bool) ([]string, error) {
- var someerrs bool
- exm := make(map[string]struct{})
-
- if ignore == nil {
- ignore = make(map[string]bool)
- }
-
- var imps []string
- for ip, perr := range t.Packages {
- if perr.Err != nil {
- someerrs = true
- continue
- }
-
- p := perr.P
- // Skip main packages, unless param says otherwise
- if p.Name == "main" && !main {
- continue
- }
- // Skip ignored packages
- if ignore[ip] {
- continue
- }
-
- imps = imps[:0]
- imps = p.Imports
- if tests {
- imps = dedupeStrings(imps, p.TestImports)
- }
-
- for _, imp := range imps {
- if !checkPrefixSlash(filepath.Clean(imp), t.ImportRoot) && !ignore[imp] {
- exm[imp] = struct{}{}
- }
- }
- }
-
- if len(exm) == 0 {
- if someerrs {
- // TODO proper errs
- return nil, fmt.Errorf("No packages without errors in %s", t.ImportRoot)
- }
- return nil, nil
- }
-
- ex := make([]string, len(exm))
- k := 0
- for p := range exm {
- ex[k] = p
- k++
- }
-
- sort.Strings(ex)
- return ex, nil
-}
-
-// checkPrefixSlash checks to see if the prefix is a prefix of the string as-is,
-// and that it is either equal OR the prefix + / is still a prefix.
-func checkPrefixSlash(s, prefix string) bool {
- if !strings.HasPrefix(s, prefix) {
- return false
- }
- return s == prefix || strings.HasPrefix(s, ensureTrailingSlash(prefix))
-}
diff --git a/vendor/github.com/sdboyer/vsolver/hash_test.go b/vendor/github.com/sdboyer/vsolver/hash_test.go
deleted file mode 100644
index 4bbb7d2..0000000
--- a/vendor/github.com/sdboyer/vsolver/hash_test.go
+++ /dev/null
@@ -1,45 +0,0 @@
-package vsolver
-
-import (
- "bytes"
- "crypto/sha256"
- "testing"
-)
-
-func TestHashInputs(t *testing.T) {
- fix := basicFixtures[2]
-
- args := SolveArgs{
- Root: string(fix.ds[0].Name()),
- Name: fix.ds[0].Name(),
- Manifest: fix.ds[0],
- Ignore: []string{"foo", "bar"},
- }
-
- // prep a fixture-overridden solver
- si, err := Prepare(args, SolveOpts{}, newdepspecSM(fix.ds, nil))
- s := si.(*solver)
- if err != nil {
- t.Fatalf("Could not prepare solver due to err: %s", err)
- }
-
- fixb := &depspecBridge{
- s.b.(*bridge),
- }
- s.b = fixb
-
- dig, err := s.HashInputs()
- if err != nil {
- t.Fatalf("HashInputs returned unexpected err: %s", err)
- }
-
- h := sha256.New()
- for _, v := range []string{"a", "a", "1.0.0", "b", "b", "1.0.0", stdlibPkgs, "root", "", "root", "a", "b", "bar", "foo"} {
- h.Write([]byte(v))
- }
- correct := h.Sum(nil)
-
- if !bytes.Equal(dig, correct) {
- t.Errorf("Hashes are not equal")
- }
-}
diff --git a/vendor/github.com/sdboyer/vsolver/manifest.go b/vendor/github.com/sdboyer/vsolver/manifest.go
deleted file mode 100644
index 51dac26..0000000
--- a/vendor/github.com/sdboyer/vsolver/manifest.go
+++ /dev/null
@@ -1,86 +0,0 @@
-package vsolver
-
-// Manifest represents the data from a manifest file (or however the
-// implementing tool chooses to store it) at a particular version that is
-// relevant to the satisfiability solving process. That means constraints on
-// dependencies, both for normal dependencies and for tests.
-//
-// Finding a solution that satisfies the constraints expressed by all of these
-// dependencies (and those from all other projects, transitively), is what the
-// solver does.
-//
-// Note that vsolver does perform static analysis on all projects' codebases;
-// if dependencies it finds through that analysis are missing from what the
-// Manifest lists, it is considered an error that will eliminate that version
-// from consideration in the solving algorithm.
-type Manifest interface {
- Name() ProjectName
- DependencyConstraints() []ProjectDep
- TestDependencyConstraints() []ProjectDep
-}
-
-// SimpleManifest is a helper for tools to enumerate manifest data. It's
-// generally intended for ephemeral manifests, such as those Analyzers create on
-// the fly for projects with no manifest metadata, or metadata through a foreign
-// tool's idioms.
-type SimpleManifest struct {
- N ProjectName
- Deps []ProjectDep
- TestDeps []ProjectDep
-}
-
-var _ Manifest = SimpleManifest{}
-
-// Name returns the name of the project described by the manifest.
-func (m SimpleManifest) Name() ProjectName {
- return m.N
-}
-
-// GetDependencies returns the project's dependencies.
-func (m SimpleManifest) DependencyConstraints() []ProjectDep {
- return m.Deps
-}
-
-// GetDependencies returns the project's test dependencies.
-func (m SimpleManifest) TestDependencyConstraints() []ProjectDep {
- return m.TestDeps
-}
-
-// prepManifest ensures a manifest is prepared and safe for use by the solver.
-// This entails two things:
-//
-// * Ensuring that all ProjectIdentifiers are normalized (otherwise matching
-// can get screwy and the queues go out of alignment)
-// * Defensively ensuring that no outside routine can modify the manifest while
-// the solver is in-flight.
-//
-// This is achieved by copying the manifest's data into a new SimpleManifest.
-func prepManifest(m Manifest, n ProjectName) Manifest {
- if m == nil {
- // Only use the provided ProjectName if making an empty manifest;
- // otherwise, we trust the input manifest.
- return SimpleManifest{
- N: n,
- }
- }
-
- deps := m.DependencyConstraints()
- ddeps := m.TestDependencyConstraints()
-
- rm := SimpleManifest{
- N: m.Name(),
- Deps: make([]ProjectDep, len(deps)),
- TestDeps: make([]ProjectDep, len(ddeps)),
- }
-
- for k, d := range deps {
- d.Ident = d.Ident.normalize()
- rm.Deps[k] = d
- }
- for k, d := range ddeps {
- d.Ident = d.Ident.normalize()
- rm.TestDeps[k] = d
- }
-
- return rm
-}
diff --git a/vendor/github.com/sdboyer/vsolver/solve_basic_test.go b/vendor/github.com/sdboyer/vsolver/solve_basic_test.go
deleted file mode 100644
index 910cd05..0000000
--- a/vendor/github.com/sdboyer/vsolver/solve_basic_test.go
+++ /dev/null
@@ -1,1279 +0,0 @@
-package vsolver
-
-import (
- "fmt"
- "regexp"
- "strings"
-
- "github.com/Masterminds/semver"
-)
-
-var regfrom = regexp.MustCompile(`^(\w*) from (\w*) ([0-9\.]*)`)
-
-// nsvSplit splits an "info" string on " " into the pair of name and
-// version/constraint, and returns each individually.
-//
-// This is for narrow use - panics if there are less than two resulting items in
-// the slice.
-func nsvSplit(info string) (id ProjectIdentifier, version string) {
- if strings.Contains(info, " from ") {
- parts := regfrom.FindStringSubmatch(info)
- info = parts[1] + " " + parts[3]
- id.NetworkName = parts[2]
- }
-
- s := strings.SplitN(info, " ", 2)
- if len(s) < 2 {
- panic(fmt.Sprintf("Malformed name/version info string '%s'", info))
- }
-
- id.LocalName, version = ProjectName(s[0]), s[1]
- if id.NetworkName == "" {
- id.NetworkName = string(id.LocalName)
- }
- return
-}
-
-// nsvrSplit splits an "info" string on " " into the triplet of name,
-// version/constraint, and revision, and returns each individually.
-//
-// It will work fine if only name and version/constraint are provided.
-//
-// This is for narrow use - panics if there are less than two resulting items in
-// the slice.
-func nsvrSplit(info string) (id ProjectIdentifier, version string, revision Revision) {
- if strings.Contains(info, " from ") {
- parts := regfrom.FindStringSubmatch(info)
- info = parts[1] + " " + parts[3]
- id.NetworkName = parts[2]
- }
-
- s := strings.SplitN(info, " ", 3)
- if len(s) < 2 {
- panic(fmt.Sprintf("Malformed name/version info string '%s'", info))
- }
-
- id.LocalName, version = ProjectName(s[0]), s[1]
- if id.NetworkName == "" {
- id.NetworkName = string(id.LocalName)
- }
-
- if len(s) == 3 {
- revision = Revision(s[2])
- }
- return
-}
-
-// mksvpa - "make semver project atom"
-//
-// Splits the input string on a space, and uses the first two elements as the
-// project name and constraint body, respectively.
-func mksvpa(info string) atom {
- id, ver, rev := nsvrSplit(info)
-
- _, err := semver.NewVersion(ver)
- if err != nil {
- // don't want to allow bad test data at this level, so just panic
- panic(fmt.Sprintf("Error when converting '%s' into semver: %s", ver, err))
- }
-
- var v Version
- v = NewVersion(ver)
- if rev != "" {
- v = v.(UnpairedVersion).Is(rev)
- }
-
- return atom{
- id: id,
- v: v,
- }
-}
-
-// mkc - "make constraint"
-func mkc(body string) Constraint {
- c, err := NewSemverConstraint(body)
- if err != nil {
- // don't want bad test data at this level, so just panic
- panic(fmt.Sprintf("Error when converting '%s' into semver constraint: %s", body, err))
- }
-
- return c
-}
-
-// mksvd - "make semver dependency"
-//
-// Splits the input string on a space, and uses the first two elements as the
-// project name and constraint body, respectively.
-func mksvd(info string) ProjectDep {
- id, v := nsvSplit(info)
-
- return ProjectDep{
- Ident: id,
- Constraint: mkc(v),
- }
-}
-
-type depspec struct {
- n ProjectName
- v Version
- deps []ProjectDep
- devdeps []ProjectDep
- pkgs []tpkg
-}
-
-// dsv - "depspec semver" (make a semver depspec)
-//
-// Wraps up all the other semver-making-helper funcs to create a depspec with
-// both semver versions and constraints.
-//
-// As it assembles from the other shortcut methods, it'll panic if anything's
-// malformed.
-//
-// First string is broken out into the name/semver of the main package.
-func dsv(pi string, deps ...string) depspec {
- pa := mksvpa(pi)
- if string(pa.id.LocalName) != pa.id.NetworkName {
- panic("alternate source on self makes no sense")
- }
-
- ds := depspec{
- n: pa.id.LocalName,
- v: pa.v,
- }
-
- for _, dep := range deps {
- var sl *[]ProjectDep
- if strings.HasPrefix(dep, "(dev) ") {
- dep = strings.TrimPrefix(dep, "(dev) ")
- sl = &ds.devdeps
- } else {
- sl = &ds.deps
- }
-
- *sl = append(*sl, mksvd(dep))
- }
-
- return ds
-}
-
-// mklock makes a fixLock, suitable to act as a lock file
-func mklock(pairs ...string) fixLock {
- l := make(fixLock, 0)
- for _, s := range pairs {
- pa := mksvpa(s)
- l = append(l, NewLockedProject(pa.id.LocalName, pa.v, pa.id.netName(), "", nil))
- }
-
- return l
-}
-
-// mkrevlock makes a fixLock, suitable to act as a lock file, with only a name
-// and a rev
-func mkrevlock(pairs ...string) fixLock {
- l := make(fixLock, 0)
- for _, s := range pairs {
- pa := mksvpa(s)
- l = append(l, NewLockedProject(pa.id.LocalName, pa.v.(PairedVersion).Underlying(), pa.id.netName(), "", nil))
- }
-
- return l
-}
-
-// mkresults makes a result set
-func mkresults(pairs ...string) map[string]Version {
- m := make(map[string]Version)
- for _, pair := range pairs {
- name, ver, rev := nsvrSplit(pair)
-
- var v Version
- v = NewVersion(ver)
- if rev != "" {
- v = v.(UnpairedVersion).Is(rev)
- }
-
- m[string(name.LocalName)] = v
- }
-
- return m
-}
-
-// computeBasicReachMap takes a depspec and computes a reach map which is
-// identical to the explicit depgraph.
-//
-// Using a reachMap here is overkill for what the basic fixtures actually need,
-// but we use it anyway for congruence with the more general cases.
-func computeBasicReachMap(ds []depspec) reachMap {
- rm := make(reachMap)
-
- for k, d := range ds {
- n := string(d.n)
- lm := map[string][]string{
- n: nil,
- }
- v := d.v
- if k == 0 {
- // Put the root in with a nil rev, to accommodate the solver
- v = nil
- }
- rm[pident{n: d.n, v: v}] = lm
-
- for _, dep := range d.deps {
- lm[n] = append(lm[n], string(dep.Ident.LocalName))
- }
-
- // first is root
- if k == 0 {
- for _, dep := range d.devdeps {
- lm[n] = append(lm[n], string(dep.Ident.LocalName))
- }
- }
- }
-
- return rm
-}
-
-type pident struct {
- n ProjectName
- v Version
-}
-
-type specfix interface {
- name() string
- specs() []depspec
- maxTries() int
- expectErrs() []string
- result() map[string]Version
-}
-
-type basicFixture struct {
- // name of this fixture datum
- n string
- // depspecs. always treat first as root
- ds []depspec
- // results; map of name/version pairs
- r map[string]Version
- // max attempts the solver should need to find solution. 0 means no limit
- maxAttempts int
- // Use downgrade instead of default upgrade sorter
- downgrade bool
- // lock file simulator, if one's to be used at all
- l fixLock
- // projects expected to have errors, if any
- errp []string
- // request up/downgrade to all projects
- changeall bool
-}
-
-func (f basicFixture) name() string {
- return f.n
-}
-
-func (f basicFixture) specs() []depspec {
- return f.ds
-}
-
-func (f basicFixture) maxTries() int {
- return f.maxAttempts
-}
-
-func (f basicFixture) expectErrs() []string {
- return f.errp
-}
-
-func (f basicFixture) result() map[string]Version {
- return f.r
-}
-
-var basicFixtures = []basicFixture{
- // basic fixtures
- {
- n: "no dependencies",
- ds: []depspec{
- dsv("root 0.0.0"),
- },
- r: mkresults(),
- },
- {
- n: "simple dependency tree",
- ds: []depspec{
- dsv("root 0.0.0", "a 1.0.0", "b 1.0.0"),
- dsv("a 1.0.0", "aa 1.0.0", "ab 1.0.0"),
- dsv("aa 1.0.0"),
- dsv("ab 1.0.0"),
- dsv("b 1.0.0", "ba 1.0.0", "bb 1.0.0"),
- dsv("ba 1.0.0"),
- dsv("bb 1.0.0"),
- },
- r: mkresults(
- "a 1.0.0",
- "aa 1.0.0",
- "ab 1.0.0",
- "b 1.0.0",
- "ba 1.0.0",
- "bb 1.0.0",
- ),
- },
- {
- n: "shared dependency with overlapping constraints",
- ds: []depspec{
- dsv("root 0.0.0", "a 1.0.0", "b 1.0.0"),
- dsv("a 1.0.0", "shared >=2.0.0, <4.0.0"),
- dsv("b 1.0.0", "shared >=3.0.0, <5.0.0"),
- dsv("shared 2.0.0"),
- dsv("shared 3.0.0"),
- dsv("shared 3.6.9"),
- dsv("shared 4.0.0"),
- dsv("shared 5.0.0"),
- },
- r: mkresults(
- "a 1.0.0",
- "b 1.0.0",
- "shared 3.6.9",
- ),
- },
- {
- n: "downgrade on overlapping constraints",
- ds: []depspec{
- dsv("root 0.0.0", "a 1.0.0", "b 1.0.0"),
- dsv("a 1.0.0", "shared >=2.0.0, <=4.0.0"),
- dsv("b 1.0.0", "shared >=3.0.0, <5.0.0"),
- dsv("shared 2.0.0"),
- dsv("shared 3.0.0"),
- dsv("shared 3.6.9"),
- dsv("shared 4.0.0"),
- dsv("shared 5.0.0"),
- },
- r: mkresults(
- "a 1.0.0",
- "b 1.0.0",
- "shared 3.0.0",
- ),
- downgrade: true,
- },
- {
- n: "shared dependency where dependent version in turn affects other dependencies",
- ds: []depspec{
- dsv("root 0.0.0", "foo <=1.0.2", "bar 1.0.0"),
- dsv("foo 1.0.0"),
- dsv("foo 1.0.1", "bang 1.0.0"),
- dsv("foo 1.0.2", "whoop 1.0.0"),
- dsv("foo 1.0.3", "zoop 1.0.0"),
- dsv("bar 1.0.0", "foo <=1.0.1"),
- dsv("bang 1.0.0"),
- dsv("whoop 1.0.0"),
- dsv("zoop 1.0.0"),
- },
- r: mkresults(
- "foo 1.0.1",
- "bar 1.0.0",
- "bang 1.0.0",
- ),
- },
- {
- n: "removed dependency",
- ds: []depspec{
- dsv("root 1.0.0", "foo 1.0.0", "bar *"),
- dsv("foo 1.0.0"),
- dsv("foo 2.0.0"),
- dsv("bar 1.0.0"),
- dsv("bar 2.0.0", "baz 1.0.0"),
- dsv("baz 1.0.0", "foo 2.0.0"),
- },
- r: mkresults(
- "foo 1.0.0",
- "bar 1.0.0",
- ),
- maxAttempts: 2,
- },
- {
- n: "with mismatched net addrs",
- ds: []depspec{
- dsv("root 1.0.0", "foo 1.0.0", "bar 1.0.0"),
- dsv("foo 1.0.0", "bar from baz 1.0.0"),
- dsv("bar 1.0.0"),
- },
- // TODO ugh; do real error comparison instead of shitty abstraction
- errp: []string{"foo", "foo", "root"},
- },
- // fixtures with locks
- {
- n: "with compatible locked dependency",
- ds: []depspec{
- dsv("root 0.0.0", "foo *"),
- dsv("foo 1.0.0", "bar 1.0.0"),
- dsv("foo 1.0.1", "bar 1.0.1"),
- dsv("foo 1.0.2", "bar 1.0.2"),
- dsv("bar 1.0.0"),
- dsv("bar 1.0.1"),
- dsv("bar 1.0.2"),
- },
- l: mklock(
- "foo 1.0.1",
- ),
- r: mkresults(
- "foo 1.0.1",
- "bar 1.0.1",
- ),
- },
- {
- n: "upgrade through lock",
- ds: []depspec{
- dsv("root 0.0.0", "foo *"),
- dsv("foo 1.0.0", "bar 1.0.0"),
- dsv("foo 1.0.1", "bar 1.0.1"),
- dsv("foo 1.0.2", "bar 1.0.2"),
- dsv("bar 1.0.0"),
- dsv("bar 1.0.1"),
- dsv("bar 1.0.2"),
- },
- l: mklock(
- "foo 1.0.1",
- ),
- r: mkresults(
- "foo 1.0.2",
- "bar 1.0.2",
- ),
- changeall: true,
- },
- {
- n: "downgrade through lock",
- ds: []depspec{
- dsv("root 0.0.0", "foo *"),
- dsv("foo 1.0.0", "bar 1.0.0"),
- dsv("foo 1.0.1", "bar 1.0.1"),
- dsv("foo 1.0.2", "bar 1.0.2"),
- dsv("bar 1.0.0"),
- dsv("bar 1.0.1"),
- dsv("bar 1.0.2"),
- },
- l: mklock(
- "foo 1.0.1",
- ),
- r: mkresults(
- "foo 1.0.0",
- "bar 1.0.0",
- ),
- changeall: true,
- downgrade: true,
- },
- {
- n: "with incompatible locked dependency",
- ds: []depspec{
- dsv("root 0.0.0", "foo >1.0.1"),
- dsv("foo 1.0.0", "bar 1.0.0"),
- dsv("foo 1.0.1", "bar 1.0.1"),
- dsv("foo 1.0.2", "bar 1.0.2"),
- dsv("bar 1.0.0"),
- dsv("bar 1.0.1"),
- dsv("bar 1.0.2"),
- },
- l: mklock(
- "foo 1.0.1",
- ),
- r: mkresults(
- "foo 1.0.2",
- "bar 1.0.2",
- ),
- },
- {
- n: "with unrelated locked dependency",
- ds: []depspec{
- dsv("root 0.0.0", "foo *"),
- dsv("foo 1.0.0", "bar 1.0.0"),
- dsv("foo 1.0.1", "bar 1.0.1"),
- dsv("foo 1.0.2", "bar 1.0.2"),
- dsv("bar 1.0.0"),
- dsv("bar 1.0.1"),
- dsv("bar 1.0.2"),
- dsv("baz 1.0.0 bazrev"),
- },
- l: mklock(
- "baz 1.0.0 bazrev",
- ),
- r: mkresults(
- "foo 1.0.2",
- "bar 1.0.2",
- ),
- },
- {
- n: "unlocks dependencies if necessary to ensure that a new dependency is satisfied",
- ds: []depspec{
- dsv("root 0.0.0", "foo *", "newdep *"),
- dsv("foo 1.0.0 foorev", "bar <2.0.0"),
- dsv("bar 1.0.0 barrev", "baz <2.0.0"),
- dsv("baz 1.0.0 bazrev", "qux <2.0.0"),
- dsv("qux 1.0.0 quxrev"),
- dsv("foo 2.0.0", "bar <3.0.0"),
- dsv("bar 2.0.0", "baz <3.0.0"),
- dsv("baz 2.0.0", "qux <3.0.0"),
- dsv("qux 2.0.0"),
- dsv("newdep 2.0.0", "baz >=1.5.0"),
- },
- l: mklock(
- "foo 1.0.0 foorev",
- "bar 1.0.0 barrev",
- "baz 1.0.0 bazrev",
- "qux 1.0.0 quxrev",
- ),
- r: mkresults(
- "foo 2.0.0",
- "bar 2.0.0",
- "baz 2.0.0",
- "qux 1.0.0 quxrev",
- "newdep 2.0.0",
- ),
- maxAttempts: 4,
- },
- {
- n: "locked atoms are matched on both local and net name",
- ds: []depspec{
- dsv("root 0.0.0", "foo *"),
- dsv("foo 1.0.0 foorev"),
- dsv("foo 2.0.0 foorev2"),
- },
- l: mklock(
- "foo from baz 1.0.0 foorev",
- ),
- r: mkresults(
- "foo 2.0.0 foorev2",
- ),
- },
- {
- n: "pairs bare revs in lock with versions",
- ds: []depspec{
- dsv("root 0.0.0", "foo ~1.0.1"),
- dsv("foo 1.0.0", "bar 1.0.0"),
- dsv("foo 1.0.1 foorev", "bar 1.0.1"),
- dsv("foo 1.0.2", "bar 1.0.2"),
- dsv("bar 1.0.0"),
- dsv("bar 1.0.1"),
- dsv("bar 1.0.2"),
- },
- l: mkrevlock(
- "foo 1.0.1 foorev", // mkrevlock drops the 1.0.1
- ),
- r: mkresults(
- "foo 1.0.1 foorev",
- "bar 1.0.1",
- ),
- },
- {
- n: "pairs bare revs in lock with all versions",
- ds: []depspec{
- dsv("root 0.0.0", "foo ~1.0.1"),
- dsv("foo 1.0.0", "bar 1.0.0"),
- dsv("foo 1.0.1 foorev", "bar 1.0.1"),
- dsv("foo 1.0.2 foorev", "bar 1.0.2"),
- dsv("bar 1.0.0"),
- dsv("bar 1.0.1"),
- dsv("bar 1.0.2"),
- },
- l: mkrevlock(
- "foo 1.0.1 foorev", // mkrevlock drops the 1.0.1
- ),
- r: mkresults(
- "foo 1.0.2 foorev",
- "bar 1.0.1",
- ),
- },
- {
- n: "does not pair bare revs in manifest with unpaired lock version",
- ds: []depspec{
- dsv("root 0.0.0", "foo ~1.0.1"),
- dsv("foo 1.0.0", "bar 1.0.0"),
- dsv("foo 1.0.1 foorev", "bar 1.0.1"),
- dsv("foo 1.0.2", "bar 1.0.2"),
- dsv("bar 1.0.0"),
- dsv("bar 1.0.1"),
- dsv("bar 1.0.2"),
- },
- l: mkrevlock(
- "foo 1.0.1 foorev", // mkrevlock drops the 1.0.1
- ),
- r: mkresults(
- "foo 1.0.1 foorev",
- "bar 1.0.1",
- ),
- },
- {
- n: "includes root package's dev dependencies",
- ds: []depspec{
- dsv("root 1.0.0", "(dev) foo 1.0.0", "(dev) bar 1.0.0"),
- dsv("foo 1.0.0"),
- dsv("bar 1.0.0"),
- },
- r: mkresults(
- "foo 1.0.0",
- "bar 1.0.0",
- ),
- },
- {
- n: "includes dev dependency's transitive dependencies",
- ds: []depspec{
- dsv("root 1.0.0", "(dev) foo 1.0.0"),
- dsv("foo 1.0.0", "bar 1.0.0"),
- dsv("bar 1.0.0"),
- },
- r: mkresults(
- "foo 1.0.0",
- "bar 1.0.0",
- ),
- },
- {
- n: "ignores transitive dependency's dev dependencies",
- ds: []depspec{
- dsv("root 1.0.0", "(dev) foo 1.0.0"),
- dsv("foo 1.0.0", "(dev) bar 1.0.0"),
- dsv("bar 1.0.0"),
- },
- r: mkresults(
- "foo 1.0.0",
- ),
- },
- {
- n: "no version that matches requirement",
- ds: []depspec{
- dsv("root 0.0.0", "foo >=1.0.0, <2.0.0"),
- dsv("foo 2.0.0"),
- dsv("foo 2.1.3"),
- },
- errp: []string{"foo", "root"},
- },
- {
- n: "no version that matches combined constraint",
- ds: []depspec{
- dsv("root 0.0.0", "foo 1.0.0", "bar 1.0.0"),
- dsv("foo 1.0.0", "shared >=2.0.0, <3.0.0"),
- dsv("bar 1.0.0", "shared >=2.9.0, <4.0.0"),
- dsv("shared 2.5.0"),
- dsv("shared 3.5.0"),
- },
- errp: []string{"shared", "foo", "bar"},
- },
- {
- n: "disjoint constraints",
- ds: []depspec{
- dsv("root 0.0.0", "foo 1.0.0", "bar 1.0.0"),
- dsv("foo 1.0.0", "shared <=2.0.0"),
- dsv("bar 1.0.0", "shared >3.0.0"),
- dsv("shared 2.0.0"),
- dsv("shared 4.0.0"),
- },
- //errp: []string{"shared", "foo", "bar"}, // dart's has this...
- errp: []string{"foo", "bar"},
- },
- {
- n: "no valid solution",
- ds: []depspec{
- dsv("root 0.0.0", "a *", "b *"),
- dsv("a 1.0.0", "b 1.0.0"),
- dsv("a 2.0.0", "b 2.0.0"),
- dsv("b 1.0.0", "a 2.0.0"),
- dsv("b 2.0.0", "a 1.0.0"),
- },
- errp: []string{"b", "a"},
- maxAttempts: 2,
- },
- {
- n: "no version that matches while backtracking",
- ds: []depspec{
- dsv("root 0.0.0", "a *", "b >1.0.0"),
- dsv("a 1.0.0"),
- dsv("b 1.0.0"),
- },
- errp: []string{"b", "root"},
- },
- {
- // The latest versions of a and b disagree on c. An older version of either
- // will resolve the problem. This test validates that b, which is farther
- // in the dependency graph from myapp is downgraded first.
- n: "rolls back leaf versions first",
- ds: []depspec{
- dsv("root 0.0.0", "a *"),
- dsv("a 1.0.0", "b *"),
- dsv("a 2.0.0", "b *", "c 2.0.0"),
- dsv("b 1.0.0"),
- dsv("b 2.0.0", "c 1.0.0"),
- dsv("c 1.0.0"),
- dsv("c 2.0.0"),
- },
- r: mkresults(
- "a 2.0.0",
- "b 1.0.0",
- "c 2.0.0",
- ),
- maxAttempts: 2,
- },
- {
- // Only one version of baz, so foo and bar will have to downgrade until they
- // reach it.
- n: "simple transitive",
- ds: []depspec{
- dsv("root 0.0.0", "foo *"),
- dsv("foo 1.0.0", "bar 1.0.0"),
- dsv("foo 2.0.0", "bar 2.0.0"),
- dsv("foo 3.0.0", "bar 3.0.0"),
- dsv("bar 1.0.0", "baz *"),
- dsv("bar 2.0.0", "baz 2.0.0"),
- dsv("bar 3.0.0", "baz 3.0.0"),
- dsv("baz 1.0.0"),
- },
- r: mkresults(
- "foo 1.0.0",
- "bar 1.0.0",
- "baz 1.0.0",
- ),
- maxAttempts: 3,
- },
- {
- // Ensures the solver doesn"t exhaustively search all versions of b when
- // it's a-2.0.0 whose dependency on c-2.0.0-nonexistent led to the
- // problem. We make sure b has more versions than a so that the solver
- // tries a first since it sorts sibling dependencies by number of
- // versions.
- n: "simple transitive",
- ds: []depspec{
- dsv("root 0.0.0", "a *", "b *"),
- dsv("a 1.0.0", "c 1.0.0"),
- dsv("a 2.0.0", "c 2.0.0"),
- dsv("b 1.0.0"),
- dsv("b 2.0.0"),
- dsv("b 3.0.0"),
- dsv("c 1.0.0"),
- },
- r: mkresults(
- "a 1.0.0",
- "b 3.0.0",
- "c 1.0.0",
- ),
- maxAttempts: 2,
- },
- {
- // Dependencies are ordered so that packages with fewer versions are
- // tried first. Here, there are two valid solutions (either a or b must
- // be downgraded once). The chosen one depends on which dep is traversed
- // first. Since b has fewer versions, it will be traversed first, which
- // means a will come later. Since later selections are revised first, a
- // gets downgraded.
- n: "traverse into package with fewer versions first",
- ds: []depspec{
- dsv("root 0.0.0", "a *", "b *"),
- dsv("a 1.0.0", "c *"),
- dsv("a 2.0.0", "c *"),
- dsv("a 3.0.0", "c *"),
- dsv("a 4.0.0", "c *"),
- dsv("a 5.0.0", "c 1.0.0"),
- dsv("b 1.0.0", "c *"),
- dsv("b 2.0.0", "c *"),
- dsv("b 3.0.0", "c *"),
- dsv("b 4.0.0", "c 2.0.0"),
- dsv("c 1.0.0"),
- dsv("c 2.0.0"),
- },
- r: mkresults(
- "a 4.0.0",
- "b 4.0.0",
- "c 2.0.0",
- ),
- maxAttempts: 2,
- },
- {
- // This is similar to the preceding fixture. When getting the number of
- // versions of a package to determine which to traverse first, versions
- // that are disallowed by the root package"s constraints should not be
- // considered. Here, foo has more versions of bar in total (4), but
- // fewer that meet myapp"s constraints (only 2). There is no solution,
- // but we will do less backtracking if foo is tested first.
- n: "traverse into package with fewer versions first",
- ds: []depspec{
- dsv("root 0.0.0", "foo *", "bar *"),
- dsv("foo 1.0.0", "none 2.0.0"),
- dsv("foo 2.0.0", "none 2.0.0"),
- dsv("foo 3.0.0", "none 2.0.0"),
- dsv("foo 4.0.0", "none 2.0.0"),
- dsv("bar 1.0.0"),
- dsv("bar 2.0.0"),
- dsv("bar 3.0.0"),
- dsv("none 1.0.0"),
- },
- errp: []string{"none", "foo"},
- maxAttempts: 2,
- },
- {
- // If there"s a disjoint constraint on a package, then selecting other
- // versions of it is a waste of time: no possible versions can match. We
- // need to jump past it to the most recent package that affected the
- // constraint.
- n: "backjump past failed package on disjoint constraint",
- ds: []depspec{
- dsv("root 0.0.0", "a *", "foo *"),
- dsv("a 1.0.0", "foo *"),
- dsv("a 2.0.0", "foo <1.0.0"),
- dsv("foo 2.0.0"),
- dsv("foo 2.0.1"),
- dsv("foo 2.0.2"),
- dsv("foo 2.0.3"),
- dsv("foo 2.0.4"),
- dsv("none 1.0.0"),
- },
- r: mkresults(
- "a 1.0.0",
- "foo 2.0.4",
- ),
- maxAttempts: 2,
- },
- // TODO add fixture that tests proper handling of loops via aliases (where
- // a project that wouldn't be a loop is aliased to a project that is a loop)
-}
-
-func init() {
- // This sets up a hundred versions of foo and bar, 0.0.0 through 9.9.0. Each
- // version of foo depends on a baz with the same major version. Each version
- // of bar depends on a baz with the same minor version. There is only one
- // version of baz, 0.0.0, so only older versions of foo and bar will
- // satisfy it.
- fix := basicFixture{
- n: "complex backtrack",
- ds: []depspec{
- dsv("root 0.0.0", "foo *", "bar *"),
- dsv("baz 0.0.0"),
- },
- r: mkresults(
- "foo 0.9.0",
- "bar 9.0.0",
- "baz 0.0.0",
- ),
- maxAttempts: 10,
- }
-
- for i := 0; i < 10; i++ {
- for j := 0; j < 10; j++ {
- fix.ds = append(fix.ds, dsv(fmt.Sprintf("foo %v.%v.0", i, j), fmt.Sprintf("baz %v.0.0", i)))
- fix.ds = append(fix.ds, dsv(fmt.Sprintf("bar %v.%v.0", i, j), fmt.Sprintf("baz 0.%v.0", j)))
- }
- }
-
- basicFixtures = append(basicFixtures, fix)
-}
-
-// reachMaps contain externalReach()-type data for a given depspec fixture's
-// universe of proejcts, packages, and versions.
-type reachMap map[pident]map[string][]string
-
-type depspecSourceManager struct {
- specs []depspec
- rm reachMap
- ig map[string]bool
-}
-
-type fixSM interface {
- SourceManager
- rootSpec() depspec
- allSpecs() []depspec
- ignore() map[string]bool
-}
-
-var _ fixSM = &depspecSourceManager{}
-
-func newdepspecSM(ds []depspec, ignore []string) *depspecSourceManager {
- ig := make(map[string]bool)
- if len(ignore) > 0 {
- for _, pkg := range ignore {
- ig[pkg] = true
- }
- }
-
- return &depspecSourceManager{
- specs: ds,
- rm: computeBasicReachMap(ds),
- ig: ig,
- }
-}
-
-func (sm *depspecSourceManager) GetProjectInfo(n ProjectName, v Version) (Manifest, Lock, error) {
- for _, ds := range sm.specs {
- if n == ds.n && v.Matches(ds.v) {
- return ds, dummyLock{}, nil
- }
- }
-
- // TODO proper solver-type errors
- return nil, nil, fmt.Errorf("Project '%s' at version '%s' could not be found", n, v)
-}
-
-func (sm *depspecSourceManager) ExternalReach(n ProjectName, v Version) (map[string][]string, error) {
- id := pident{n: n, v: v}
- if m, exists := sm.rm[id]; exists {
- return m, nil
- }
- return nil, fmt.Errorf("No reach data for %s at version %s", n, v)
-}
-
-func (sm *depspecSourceManager) ListExternal(n ProjectName, v Version) ([]string, error) {
- // This should only be called for the root
- id := pident{n: n, v: v}
- if r, exists := sm.rm[id]; exists {
- return r[string(n)], nil
- }
- return nil, fmt.Errorf("No reach data for %s at version %s", n, v)
-}
-
-func (sm *depspecSourceManager) ListPackages(n ProjectName, v Version) (PackageTree, error) {
- id := pident{n: n, v: v}
- if r, exists := sm.rm[id]; exists {
- ptree := PackageTree{
- ImportRoot: string(n),
- Packages: map[string]PackageOrErr{
- string(n): PackageOrErr{
- P: Package{
- ImportPath: string(n),
- Name: string(n),
- Imports: r[string(n)],
- },
- },
- },
- }
- return ptree, nil
- }
-
- return PackageTree{}, fmt.Errorf("Project %s at version %s could not be found", n, v)
-}
-
-func (sm *depspecSourceManager) ListVersions(name ProjectName) (pi []Version, err error) {
- for _, ds := range sm.specs {
- if name == ds.n {
- pi = append(pi, ds.v)
- }
- }
-
- if len(pi) == 0 {
- err = fmt.Errorf("Project '%s' could not be found", name)
- }
-
- return
-}
-
-func (sm *depspecSourceManager) RepoExists(name ProjectName) (bool, error) {
- for _, ds := range sm.specs {
- if name == ds.n {
- return true, nil
- }
- }
-
- return false, nil
-}
-
-func (sm *depspecSourceManager) VendorCodeExists(name ProjectName) (bool, error) {
- return false, nil
-}
-
-func (sm *depspecSourceManager) Release() {}
-
-func (sm *depspecSourceManager) ExportProject(n ProjectName, v Version, to string) error {
- return fmt.Errorf("dummy sm doesn't support exporting")
-}
-
-func (sm *depspecSourceManager) rootSpec() depspec {
- return sm.specs[0]
-}
-
-func (sm *depspecSourceManager) allSpecs() []depspec {
- return sm.specs
-}
-
-func (sm *depspecSourceManager) ignore() map[string]bool {
- return sm.ig
-}
-
-type depspecBridge struct {
- *bridge
-}
-
-// override computeRootReach() on bridge to read directly out of the depspecs
-func (b *depspecBridge) computeRootReach() ([]string, error) {
- // This only gets called for the root project, so grab that one off the test
- // source manager
- dsm := b.sm.(fixSM)
- root := dsm.rootSpec()
-
- ptree, err := dsm.ListPackages(root.n, nil)
- if err != nil {
- return nil, err
- }
-
- return ptree.ListExternalImports(true, true, dsm.ignore())
-}
-
-// override verifyRoot() on bridge to prevent any filesystem interaction
-func (b *depspecBridge) verifyRoot(path string) error {
- root := b.sm.(fixSM).rootSpec()
- if string(root.n) != path {
- return fmt.Errorf("Expected only root project %q to computeRootReach(), got %q", root.n, path)
- }
-
- return nil
-}
-
-func (b *depspecBridge) listPackages(id ProjectIdentifier, v Version) (PackageTree, error) {
- return b.sm.(fixSM).ListPackages(b.key(id), v)
-}
-
-// override deduceRemoteRepo on bridge to make all our pkg/project mappings work
-// as expected
-func (b *depspecBridge) deduceRemoteRepo(path string) (*remoteRepo, error) {
- for _, ds := range b.sm.(fixSM).allSpecs() {
- n := string(ds.n)
- if path == n || strings.HasPrefix(path, n+"/") {
- return &remoteRepo{
- Base: n,
- RelPkg: strings.TrimPrefix(path, n+"/"),
- }, nil
- }
- }
- return nil, fmt.Errorf("Could not find %s, or any parent, in list of known fixtures", path)
-}
-
-// enforce interfaces
-var _ Manifest = depspec{}
-var _ Lock = dummyLock{}
-var _ Lock = fixLock{}
-
-// impl Spec interface
-func (ds depspec) DependencyConstraints() []ProjectDep {
- return ds.deps
-}
-
-// impl Spec interface
-func (ds depspec) TestDependencyConstraints() []ProjectDep {
- return ds.devdeps
-}
-
-// impl Spec interface
-func (ds depspec) Name() ProjectName {
- return ds.n
-}
-
-type fixLock []LockedProject
-
-func (fixLock) SolverVersion() string {
- return "-1"
-}
-
-// impl Lock interface
-func (fixLock) InputHash() []byte {
- return []byte("fooooorooooofooorooofoo")
-}
-
-// impl Lock interface
-func (l fixLock) Projects() []LockedProject {
- return l
-}
-
-type dummyLock struct{}
-
-// impl Lock interface
-func (_ dummyLock) SolverVersion() string {
- return "-1"
-}
-
-// impl Lock interface
-func (_ dummyLock) InputHash() []byte {
- return []byte("fooooorooooofooorooofoo")
-}
-
-// impl Lock interface
-func (_ dummyLock) Projects() []LockedProject {
- return nil
-}
-
-// We've borrowed this bestiary from pub's tests:
-// https://github.com/dart-lang/pub/blob/master/test/version_solver_test.dart
-
-// TODO finish converting all of these
-
-/*
-func basicGraph() {
- testResolve("circular dependency", {
- "myapp 1.0.0": {
- "foo": "1.0.0"
- },
- "foo 1.0.0": {
- "bar": "1.0.0"
- },
- "bar 1.0.0": {
- "foo": "1.0.0"
- }
- }, result: {
- "myapp from root": "1.0.0",
- "foo": "1.0.0",
- "bar": "1.0.0"
- });
-
-}
-
-func withLockFile() {
-
-}
-
-func rootDependency() {
- testResolve("with root source", {
- "myapp 1.0.0": {
- "foo": "1.0.0"
- },
- "foo 1.0.0": {
- "myapp from root": ">=1.0.0"
- }
- }, result: {
- "myapp from root": "1.0.0",
- "foo": "1.0.0"
- });
-
- testResolve("with different source", {
- "myapp 1.0.0": {
- "foo": "1.0.0"
- },
- "foo 1.0.0": {
- "myapp": ">=1.0.0"
- }
- }, result: {
- "myapp from root": "1.0.0",
- "foo": "1.0.0"
- });
-
- testResolve("with wrong version", {
- "myapp 1.0.0": {
- "foo": "1.0.0"
- },
- "foo 1.0.0": {
- "myapp": "<1.0.0"
- }
- }, error: couldNotSolve);
-}
-
-func unsolvable() {
-
- testResolve("mismatched descriptions", {
- "myapp 0.0.0": {
- "foo": "1.0.0",
- "bar": "1.0.0"
- },
- "foo 1.0.0": {
- "shared-x": "1.0.0"
- },
- "bar 1.0.0": {
- "shared-y": "1.0.0"
- },
- "shared-x 1.0.0": {},
- "shared-y 1.0.0": {}
- }, error: descriptionMismatch("shared", "foo", "bar"));
-
- testResolve("mismatched sources", {
- "myapp 0.0.0": {
- "foo": "1.0.0",
- "bar": "1.0.0"
- },
- "foo 1.0.0": {
- "shared": "1.0.0"
- },
- "bar 1.0.0": {
- "shared from mock2": "1.0.0"
- },
- "shared 1.0.0": {},
- "shared 1.0.0 from mock2": {}
- }, error: sourceMismatch("shared", "foo", "bar"));
-
-
-
- // This is a regression test for #18300.
- testResolve("...", {
- "myapp 0.0.0": {
- "angular": "any",
- "collection": "any"
- },
- "analyzer 0.12.2": {},
- "angular 0.10.0": {
- "di": ">=0.0.32 <0.1.0",
- "collection": ">=0.9.1 <1.0.0"
- },
- "angular 0.9.11": {
- "di": ">=0.0.32 <0.1.0",
- "collection": ">=0.9.1 <1.0.0"
- },
- "angular 0.9.10": {
- "di": ">=0.0.32 <0.1.0",
- "collection": ">=0.9.1 <1.0.0"
- },
- "collection 0.9.0": {},
- "collection 0.9.1": {},
- "di 0.0.37": {"analyzer": ">=0.13.0 <0.14.0"},
- "di 0.0.36": {"analyzer": ">=0.13.0 <0.14.0"}
- }, error: noVersion(["analyzer", "di"]), maxTries: 2);
-}
-
-func badSource() {
- testResolve("fail if the root package has a bad source in dep", {
- "myapp 0.0.0": {
- "foo from bad": "any"
- },
- }, error: unknownSource("myapp", "foo", "bad"));
-
- testResolve("fail if the root package has a bad source in dev dep", {
- "myapp 0.0.0": {
- "(dev) foo from bad": "any"
- },
- }, error: unknownSource("myapp", "foo", "bad"));
-
- testResolve("fail if all versions have bad source in dep", {
- "myapp 0.0.0": {
- "foo": "any"
- },
- "foo 1.0.0": {
- "bar from bad": "any"
- },
- "foo 1.0.1": {
- "baz from bad": "any"
- },
- "foo 1.0.3": {
- "bang from bad": "any"
- },
- }, error: unknownSource("foo", "bar", "bad"), maxTries: 3);
-
- testResolve("ignore versions with bad source in dep", {
- "myapp 1.0.0": {
- "foo": "any"
- },
- "foo 1.0.0": {
- "bar": "any"
- },
- "foo 1.0.1": {
- "bar from bad": "any"
- },
- "foo 1.0.3": {
- "bar from bad": "any"
- },
- "bar 1.0.0": {}
- }, result: {
- "myapp from root": "1.0.0",
- "foo": "1.0.0",
- "bar": "1.0.0"
- }, maxTries: 3);
-}
-
-func backtracking() {
- testResolve("circular dependency on older version", {
- "myapp 0.0.0": {
- "a": ">=1.0.0"
- },
- "a 1.0.0": {},
- "a 2.0.0": {
- "b": "1.0.0"
- },
- "b 1.0.0": {
- "a": "1.0.0"
- }
- }, result: {
- "myapp from root": "0.0.0",
- "a": "1.0.0"
- }, maxTries: 2);
-}
-*/
diff --git a/vendor/github.com/sdboyer/vsolver/solve_test.go b/vendor/github.com/sdboyer/vsolver/solve_test.go
deleted file mode 100644
index 5c54683..0000000
--- a/vendor/github.com/sdboyer/vsolver/solve_test.go
+++ /dev/null
@@ -1,388 +0,0 @@
-package vsolver
-
-import (
- "flag"
- "fmt"
- "io/ioutil"
- "log"
- "os"
- "reflect"
- "sort"
- "strings"
- "testing"
-)
-
-var fixtorun string
-
-// TODO regression test ensuring that locks with only revs for projects don't cause errors
-func init() {
- flag.StringVar(&fixtorun, "vsolver.fix", "", "A single fixture to run in TestBasicSolves")
-}
-
-var stderrlog = log.New(os.Stderr, "", 0)
-
-func fixSolve(args SolveArgs, o SolveOpts, sm SourceManager) (Result, error) {
- if testing.Verbose() {
- o.Trace = true
- o.TraceLogger = stderrlog
- }
-
- si, err := Prepare(args, o, sm)
- s := si.(*solver)
- if err != nil {
- return nil, err
- }
-
- fixb := &depspecBridge{
- s.b.(*bridge),
- }
- s.b = fixb
-
- return s.Solve()
-}
-
-// Test all the basic table fixtures.
-//
-// Or, just the one named in the fix arg.
-func TestBasicSolves(t *testing.T) {
- for _, fix := range basicFixtures {
- if fixtorun == "" || fixtorun == fix.n {
- solveBasicsAndCheck(fix, t)
- if testing.Verbose() {
- // insert a line break between tests
- stderrlog.Println("")
- }
- }
- }
-}
-
-func solveBasicsAndCheck(fix basicFixture, t *testing.T) (res Result, err error) {
- if testing.Verbose() {
- stderrlog.Printf("[[fixture %q]]", fix.n)
- }
- sm := newdepspecSM(fix.ds, nil)
-
- args := SolveArgs{
- Root: string(fix.ds[0].Name()),
- Name: ProjectName(fix.ds[0].Name()),
- Manifest: fix.ds[0],
- Lock: dummyLock{},
- }
-
- o := SolveOpts{
- Downgrade: fix.downgrade,
- ChangeAll: fix.changeall,
- }
-
- if fix.l != nil {
- args.Lock = fix.l
- }
-
- res, err = fixSolve(args, o, sm)
-
- return fixtureSolveSimpleChecks(fix, res, err, t)
-}
-
-// Test all the bimodal table fixtures.
-//
-// Or, just the one named in the fix arg.
-func TestBimodalSolves(t *testing.T) {
- if fixtorun != "" {
- if fix, exists := bimodalFixtures[fixtorun]; exists {
- solveBimodalAndCheck(fix, t)
- }
- } else {
- // sort them by their keys so we get stable output
- var names []string
- for n := range bimodalFixtures {
- names = append(names, n)
- }
-
- sort.Strings(names)
- for _, n := range names {
- solveBimodalAndCheck(bimodalFixtures[n], t)
- if testing.Verbose() {
- // insert a line break between tests
- stderrlog.Println("")
- }
- }
- }
-}
-
-func solveBimodalAndCheck(fix bimodalFixture, t *testing.T) (res Result, err error) {
- if testing.Verbose() {
- stderrlog.Printf("[[fixture %q]]", fix.n)
- }
- sm := newbmSM(fix.ds, fix.ignore)
-
- args := SolveArgs{
- Root: string(fix.ds[0].Name()),
- Name: ProjectName(fix.ds[0].Name()),
- Manifest: fix.ds[0],
- Lock: dummyLock{},
- Ignore: fix.ignore,
- }
-
- o := SolveOpts{
- Downgrade: fix.downgrade,
- ChangeAll: fix.changeall,
- }
-
- if fix.l != nil {
- args.Lock = fix.l
- }
-
- res, err = fixSolve(args, o, sm)
-
- return fixtureSolveSimpleChecks(fix, res, err, t)
-}
-
-func fixtureSolveSimpleChecks(fix specfix, res Result, err error, t *testing.T) (Result, error) {
- if err != nil {
- errp := fix.expectErrs()
- if len(errp) == 0 {
- t.Errorf("(fixture: %q) Solver failed; error was type %T, text: %q", fix.name(), err, err)
- return res, err
- }
-
- switch fail := err.(type) {
- case *badOptsFailure:
- t.Errorf("(fixture: %q) Unexpected bad opts failure solve error: %s", fix.name(), err)
- case *noVersionError:
- if errp[0] != string(fail.pn.LocalName) { // TODO identifierify
- t.Errorf("(fixture: %q) Expected failure on project %s, but was on project %s", fix.name(), fail.pn.LocalName, errp[0])
- }
-
- 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 round these out
- panic(fmt.Sprintf("unhandled solve failure type: %s", err))
- }
- } else if len(fix.expectErrs()) > 0 {
- t.Errorf("(fixture: %q) Solver succeeded, but expected failure", fix.name())
- } else {
- r := res.(result)
- if fix.maxTries() > 0 && r.Attempts() > fix.maxTries() {
- t.Errorf("(fixture: %q) Solver completed in %v attempts, but expected %v or fewer", fix.name(), r.att, fix.maxTries())
- }
-
- // Dump result projects into a map for easier interrogation
- rp := make(map[string]Version)
- for _, p := range r.p {
- pa := p.toAtom()
- rp[string(pa.id.LocalName)] = pa.v
- }
-
- fixlen, rlen := len(fix.result()), len(rp)
- if fixlen != rlen {
- // Different length, so they definitely disagree
- t.Errorf("(fixture: %q) Solver reported %v package results, result expected %v", fix.name(), rlen, fixlen)
- }
-
- // Whether or not len is same, still have to verify that results agree
- // Walk through fixture/expected results first
- for p, v := range fix.result() {
- if av, exists := rp[p]; !exists {
- t.Errorf("(fixture: %q) Project %q expected but missing from results", fix.name(), p)
- } else {
- // delete result from map so we skip it on the reverse pass
- delete(rp, p)
- if v != av {
- t.Errorf("(fixture: %q) Expected version %q of project %q, but actual version was %q", fix.name(), v, p, av)
- }
- }
- }
-
- // Now walk through remaining actual results
- for p, v := range rp {
- if fv, exists := fix.result()[p]; !exists {
- t.Errorf("(fixture: %q) Unexpected project %q present in results", fix.name(), p)
- } else if v != fv {
- t.Errorf("(fixture: %q) Got version %q of project %q, but expected version was %q", fix.name(), v, p, fv)
- }
- }
- }
-
- return res, err
-}
-
-// This tests that, when a root lock is underspecified (has only a version) we
-// don't allow a match on that version from a rev in the manifest. We may allow
-// this in the future, but disallow it for now because going from an immutable
-// requirement to a mutable lock automagically is a bad direction that could
-// produce weird side effects.
-func TestRootLockNoVersionPairMatching(t *testing.T) {
- fix := basicFixture{
- n: "does not pair bare revs in manifest with unpaired lock version",
- ds: []depspec{
- dsv("root 0.0.0", "foo *"), // foo's constraint rewritten below to foorev
- dsv("foo 1.0.0", "bar 1.0.0"),
- dsv("foo 1.0.1 foorev", "bar 1.0.1"),
- dsv("foo 1.0.2 foorev", "bar 1.0.2"),
- dsv("bar 1.0.0"),
- dsv("bar 1.0.1"),
- dsv("bar 1.0.2"),
- },
- l: mklock(
- "foo 1.0.1",
- ),
- r: mkresults(
- "foo 1.0.2 foorev",
- "bar 1.0.1",
- ),
- }
-
- pd := fix.ds[0].deps[0]
- pd.Constraint = Revision("foorev")
- fix.ds[0].deps[0] = pd
-
- sm := newdepspecSM(fix.ds, nil)
-
- l2 := make(fixLock, 1)
- copy(l2, fix.l)
- l2[0].v = nil
-
- args := SolveArgs{
- Root: string(fix.ds[0].Name()),
- Name: ProjectName(fix.ds[0].Name()),
- Manifest: fix.ds[0],
- Lock: l2,
- }
-
- res, err := fixSolve(args, SolveOpts{}, sm)
-
- fixtureSolveSimpleChecks(fix, res, err, t)
-}
-
-func getFailureCausingProjects(err error) (projs []string) {
- switch e := err.(type) {
- case *noVersionError:
- projs = append(projs, string(e.pn.LocalName)) // TODO identifierify
- case *disjointConstraintFailure:
- for _, f := range e.failsib {
- projs = append(projs, string(f.depender.id.LocalName))
- }
- case *versionNotAllowedFailure:
- for _, f := range e.failparent {
- projs = append(projs, string(f.depender.id.LocalName))
- }
- 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.LocalName))
- for _, c := range e.sel {
- projs = append(projs, string(c.depender.id.LocalName))
- }
- case *checkeeHasProblemPackagesFailure:
- projs = append(projs, string(e.goal.id.LocalName))
- for _, errdep := range e.failpkg {
- for _, atom := range errdep.deppers {
- projs = append(projs, string(atom.id.LocalName))
- }
- }
- case *depHasProblemPackagesFailure:
- projs = append(projs, string(e.goal.depender.id.LocalName), string(e.goal.dep.Ident.LocalName))
- default:
- panic("unknown failtype")
- }
-
- return
-}
-
-func TestBadSolveOpts(t *testing.T) {
- sm := newdepspecSM(basicFixtures[0].ds, nil)
-
- o := SolveOpts{}
- args := SolveArgs{}
- _, err := Prepare(args, o, sm)
- if err == nil {
- t.Errorf("Should have errored on missing manifest")
- }
-
- m, _, _ := sm.GetProjectInfo(basicFixtures[0].ds[0].n, basicFixtures[0].ds[0].v)
- args.Manifest = m
- _, err = Prepare(args, o, sm)
- if err == nil {
- t.Errorf("Should have errored on empty root")
- }
-
- args.Root = "root"
- _, err = Prepare(args, o, sm)
- if err == nil {
- t.Errorf("Should have errored on empty name")
- }
-
- args.Name = "root"
- _, err = Prepare(args, o, sm)
- if err != nil {
- t.Errorf("Basic conditions satisfied, solve should have gone through, err was %s", err)
- }
-
- o.Trace = true
- _, err = Prepare(args, o, sm)
- if err == nil {
- t.Errorf("Should have errored on trace with no logger")
- }
-
- o.TraceLogger = log.New(ioutil.Discard, "", 0)
- _, err = Prepare(args, o, sm)
- if err != nil {
- t.Errorf("Basic conditions re-satisfied, solve should have gone through, err was %s", err)
- }
-}
-
-func TestIgnoreDedupe(t *testing.T) {
- fix := basicFixtures[0]
-
- ig := []string{"foo", "foo", "bar"}
- args := SolveArgs{
- Root: string(fix.ds[0].Name()),
- Name: ProjectName(fix.ds[0].Name()),
- Manifest: fix.ds[0],
- Ignore: ig,
- }
-
- s, _ := Prepare(args, SolveOpts{}, newdepspecSM(basicFixtures[0].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 %s", ts.ig)
- }
-}
diff --git a/vendor/github.com/sdboyer/vsolver/source_manager.go b/vendor/github.com/sdboyer/vsolver/source_manager.go
deleted file mode 100644
index 3100b37..0000000
--- a/vendor/github.com/sdboyer/vsolver/source_manager.go
+++ /dev/null
@@ -1,307 +0,0 @@
-package vsolver
-
-import (
- "encoding/json"
- "fmt"
- "go/build"
- "os"
- "path"
-
- "github.com/Masterminds/vcs"
-)
-
-// A SourceManager is responsible for retrieving, managing, and interrogating
-// source repositories. Its primary purpose is to serve the needs of a Solver,
-// but it is handy for other purposes, as well.
-//
-// vsolver's built-in SourceManager, accessible via NewSourceManager(), is
-// intended to be generic and sufficient for any purpose. It provides some
-// additional semantics around the methods defined here.
-type SourceManager interface {
- // RepoExists checks if a repository exists, either upstream or in the
- // SourceManager's central repository cache.
- RepoExists(ProjectName) (bool, error)
-
- // VendorCodeExists checks if a code tree exists within the stored vendor
- // directory for the the provided import path name.
- VendorCodeExists(ProjectName) (bool, error)
-
- // ListVersions retrieves a list of the available versions for a given
- // repository name.
- ListVersions(ProjectName) ([]Version, error)
-
- // ListPackages retrieves a tree of the Go packages at or below the provided
- // import path, at the provided version.
- ListPackages(ProjectName, Version) (PackageTree, error)
-
- // GetProjectInfo returns manifest and lock information for the provided
- // import path. vsolver currently requires that projects be rooted at their
- // repository root, which means that this ProjectName must also be a
- // repository root.
- GetProjectInfo(ProjectName, Version) (Manifest, Lock, error)
-
- // ExportProject writes out the tree of the provided import path, at the
- // provided version, to the provided directory.
- ExportProject(ProjectName, Version, string) error
-
- // Release lets go of any locks held by the SourceManager.
- Release()
-}
-
-// A ProjectAnalyzer is responsible for analyzing a path for Manifest and Lock
-// information. Tools relying on vsolver must implement one.
-type ProjectAnalyzer interface {
- GetInfo(build.Context, ProjectName) (Manifest, Lock, error)
-}
-
-// ExistenceError is a specialized error type that, in addition to the standard
-// error interface, also indicates the amount of searching for a project's
-// existence that has been performed, and what level of existence has been
-// ascertained.
-//
-// ExistenceErrors should *only* be returned if the (lack of) existence of a
-// project was the underling cause of the error.
-//type ExistenceError interface {
-//error
-//Existence() (search ProjectExistence, found ProjectExistence)
-//}
-
-// sourceManager is the default SourceManager for vsolver.
-//
-// There's no (planned) reason why it would need to be reimplemented by other
-// tools; control via dependency injection is intended to be sufficient.
-type sourceManager struct {
- cachedir, basedir string
- pms map[ProjectName]*pmState
- an ProjectAnalyzer
- ctx build.Context
- //pme map[ProjectName]error
-}
-
-// 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 vsolver's built-in SourceManager. It
-// takes a cache directory (where local instances of upstream repositories are
-// stored), a base directory for the project currently being worked on, and a
-// force flag indicating whether to overwrite the global cache lock file (if
-// present).
-//
-// The returned SourceManager aggressively caches
-// information wherever possible. It is recommended that, if tools need to do preliminary,
-// work involving upstream repository analysis prior to invoking a solve run,
-// that they create this SourceManager as early as possible and use it to their
-// ends. That way, the solver can benefit from any caches that may have already
-// been warmed.
-//
-// vsolver's SourceManager is intended to be threadsafe (if it's not, please
-// file a bug!). It should certainly be safe to reuse from one solving run to
-// the next; however, the fact that it takes a basedir as an argument makes it
-// much less useful for simultaneous use by separate solvers operating on
-// different root projects. This architecture may change in the future.
-func NewSourceManager(an ProjectAnalyzer, cachedir, basedir string, force bool) (SourceManager, error) {
- if an == nil {
- return nil, fmt.Errorf("A ProjectAnalyzer must be provided to the SourceManager.")
- }
-
- err := os.MkdirAll(cachedir, 0777)
- if err != nil {
- return nil, err
- }
-
- glpath := path.Join(cachedir, "sm.lock")
- _, err = os.Stat(glpath)
- if err == nil && !force {
- return nil, fmt.Errorf("Another process has locked the cachedir, or crashed without cleaning itself properly. Pass force=true to override.")
- }
-
- _, err = os.OpenFile(glpath, os.O_CREATE|os.O_RDONLY, 0700) // is 0700 sane for this purpose?
- if err != nil {
- return nil, fmt.Errorf("Failed to create global cache lock file at %s with err %s", glpath, err)
- }
-
- ctx := build.Default
- // Replace GOPATH with our cache dir
- ctx.GOPATH = cachedir
-
- return &sourceManager{
- cachedir: cachedir,
- pms: make(map[ProjectName]*pmState),
- ctx: ctx,
- an: an,
- }, nil
-}
-
-// Release lets go of any locks held by the SourceManager.
-//
-// This will also call Flush(), which will write any relevant caches to disk.
-func (sm *sourceManager) Release() {
- os.Remove(path.Join(sm.cachedir, "sm.lock"))
-}
-
-// GetProjectInfo returns manifest and lock information for the provided import
-// path. vsolver currently requires that projects be rooted at their repository
-// root, which means that this ProjectName must also be a repository root.
-//
-// The work of producing the manifest and lock information is delegated to the
-// injected ProjectAnalyzer.
-func (sm *sourceManager) GetProjectInfo(n ProjectName, v Version) (Manifest, Lock, error) {
- pmc, err := sm.getProjectManager(n)
- if err != nil {
- return nil, nil, err
- }
-
- return pmc.pm.GetInfoAt(v)
-}
-
-// ListPackages retrieves a tree of the Go packages at or below the provided
-// import path, at the provided version.
-func (sm *sourceManager) ListPackages(n ProjectName, v Version) (PackageTree, error) {
- pmc, err := sm.getProjectManager(n)
- if err != nil {
- return PackageTree{}, err
- }
-
- return pmc.pm.ListPackages(v)
-}
-
-// ListVersions retrieves a list of the available versions for a given
-// repository name.
-//
-// The list is not sorted; while it may be retuend in the order that the
-// underlying VCS reports version information, no guarantee is made. It is
-// expected that the caller either not care about order, or sort the result
-// themselves.
-//
-// This list is always retrieved from upstream; if upstream is not accessible
-// (network outage, access issues, or the resource actually went away), an error
-// will be returned.
-func (sm *sourceManager) ListVersions(n ProjectName) ([]Version, error) {
- pmc, err := sm.getProjectManager(n)
- if err != nil {
- // TODO More-er proper-er errors
- return nil, err
- }
-
- return pmc.pm.ListVersions()
-}
-
-// VendorCodeExists checks if a code tree exists within the stored vendor
-// directory for the the provided import path name.
-func (sm *sourceManager) VendorCodeExists(n ProjectName) (bool, error) {
- pms, err := sm.getProjectManager(n)
- if err != nil {
- return false, err
- }
-
- return pms.pm.CheckExistence(existsInVendorRoot), nil
-}
-
-func (sm *sourceManager) RepoExists(n ProjectName) (bool, error) {
- pms, err := sm.getProjectManager(n)
- if err != nil {
- return false, err
- }
-
- return pms.pm.CheckExistence(existsInCache) || pms.pm.CheckExistence(existsUpstream), nil
-}
-
-// ExportProject writes out the tree of the provided import path, at the
-// provided version, to the provided directory.
-func (sm *sourceManager) ExportProject(n ProjectName, v Version, to string) error {
- pms, err := sm.getProjectManager(n)
- if err != nil {
- return err
- }
-
- return pms.pm.ExportVersionTo(v, to)
-}
-
-// getProjectManager gets the project manager for the given ProjectName.
-//
-// If no such manager yet exists, it attempts to create one.
-func (sm *sourceManager) getProjectManager(n ProjectName) (*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 be more robust about this
- r, err := vcs.NewRepo("https://"+string(n), repodir)
- if err != nil {
- // TODO be better
- return nil, err
- }
- if !r.CheckLocal() {
- // TODO cloning the repo here puts it on a blocking, and possibly
- // unnecessary path. defer it
- err = r.Get()
- if err != nil {
- // TODO be better
- return nil, err
- }
- }
-
- // Ensure cache dir exists
- metadir := path.Join(sm.cachedir, "metadata", string(n))
- err = os.MkdirAll(metadir, 0777)
- if err != nil {
- // TODO be better
- return nil, err
- }
-
- pms := &pmState{}
- cpath := path.Join(metadir, "cache.json")
- fi, err := os.Stat(cpath)
- var dc *projectDataCache
- if fi != nil {
- pms.cf, err = os.OpenFile(cpath, os.O_RDWR, 0777)
- if err != nil {
- // TODO be better
- return nil, fmt.Errorf("Err on opening metadata cache file: %s", err)
- }
-
- err = json.NewDecoder(pms.cf).Decode(dc)
- if err != nil {
- // TODO be better
- return nil, fmt.Errorf("Err on JSON decoding metadata cache file: %s", err)
- }
- } else {
- // TODO commented this out for now, until we manage it correctly
- //pms.cf, err = os.Create(cpath)
- //if err != nil {
- //// TODO be better
- //return nil, fmt.Errorf("Err on creating metadata cache file: %s", err)
- //}
-
- dc = &projectDataCache{
- Infos: make(map[Revision]projectInfo),
- VMap: make(map[Version]Revision),
- RMap: make(map[Revision][]Version),
- }
- }
-
- pm := &projectManager{
- n: n,
- ctx: sm.ctx,
- vendordir: sm.basedir + "/vendor",
- an: sm.an,
- dc: dc,
- crepo: &repo{
- rpath: repodir,
- r: r,
- },
- }
-
- pms.pm = pm
- sm.pms[n] = pms
- return pms, nil
-}
diff --git a/vendor/github.com/sdboyer/vsolver/types.go b/vendor/github.com/sdboyer/vsolver/types.go
deleted file mode 100644
index 0cb54e7..0000000
--- a/vendor/github.com/sdboyer/vsolver/types.go
+++ /dev/null
@@ -1,111 +0,0 @@
-package vsolver
-
-import "fmt"
-
-type ProjectIdentifier struct {
- LocalName ProjectName
- NetworkName string
-}
-
-func (i ProjectIdentifier) less(j ProjectIdentifier) bool {
- if i.LocalName < j.LocalName {
- return true
- }
- if j.LocalName < i.LocalName {
- return false
- }
-
- return i.NetworkName < j.NetworkName
-}
-
-func (i ProjectIdentifier) eq(j ProjectIdentifier) bool {
- if i.LocalName != j.LocalName {
- return false
- }
- if i.NetworkName == j.NetworkName {
- return true
- }
-
- if (i.NetworkName == "" && j.NetworkName == string(j.LocalName)) ||
- (j.NetworkName == "" && i.NetworkName == string(i.LocalName)) {
- return true
- }
-
- return false
-}
-
-func (i ProjectIdentifier) netName() string {
- if i.NetworkName == "" {
- return string(i.LocalName)
- }
- return i.NetworkName
-}
-
-func (i ProjectIdentifier) errString() string {
- if i.NetworkName == "" || i.NetworkName == string(i.LocalName) {
- return string(i.LocalName)
- }
- return fmt.Sprintf("%s (from %s)", i.LocalName, i.NetworkName)
-}
-
-func (i ProjectIdentifier) normalize() ProjectIdentifier {
- if i.NetworkName == "" {
- i.NetworkName = string(i.LocalName)
- }
-
- return i
-}
-
-// bimodalIdentifiers are used to track work to be done in the unselected queue.
-type bimodalIdentifier struct {
- id ProjectIdentifier
- pl []string
-}
-
-type ProjectName string
-
-type atom struct {
- id ProjectIdentifier
- v Version
-}
-
-type atomWithPackages struct {
- a atom
- pl []string
-}
-
-type ProjectDep struct {
- Ident ProjectIdentifier
- Constraint Constraint
-}
-
-// Package represents a Go package. It contains a subset of the information
-// go/build.Package does.
-type Package struct {
- ImportPath, CommentPath string
- Name string
- Imports []string
- TestImports []string
-}
-
-type byImportPath []Package
-
-func (s byImportPath) Len() int { return len(s) }
-func (s byImportPath) Less(i, j int) bool { return s[i].ImportPath < s[j].ImportPath }
-func (s byImportPath) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
-
-// completeDep (name hopefully to change) provides the whole picture of a
-// dependency - the root (repo and project, since currently we assume the two
-// are the same) name, a constraint, and the actual packages needed that are
-// under that root.
-type completeDep struct {
- // The base ProjectDep
- ProjectDep
- // The specific packages required from the ProjectDep
- pl []string
-}
-
-type dependency struct {
- depender atom
- dep completeDep
-}
diff --git a/vendor/github.com/sdboyer/vsolver/version_queue.go b/vendor/github.com/sdboyer/vsolver/version_queue.go
deleted file mode 100644
index 22e7b0c..0000000
--- a/vendor/github.com/sdboyer/vsolver/version_queue.go
+++ /dev/null
@@ -1,117 +0,0 @@
-package vsolver
-
-import (
- "fmt"
- "strings"
-)
-
-type failedVersion struct {
- v Version
- f error
-}
-
-type versionQueue struct {
- id ProjectIdentifier
- pi []Version
- fails []failedVersion
- sm sourceBridge
- failed bool
- hasLock, allLoaded bool
-}
-
-func newVersionQueue(id ProjectIdentifier, lockv atom, sm sourceBridge) (*versionQueue, error) {
- vq := &versionQueue{
- id: id,
- sm: sm,
- }
-
- if lockv != nilpa {
- vq.hasLock = true
- vq.pi = append(vq.pi, lockv.v)
- } else {
- var err error
- vq.pi, err = vq.sm.listVersions(vq.id)
- if err != nil {
- // TODO pushing this error this early entails that we
- // unconditionally deep scan (e.g. vendor), as well as hitting the
- // network.
- return nil, err
- }
- vq.allLoaded = true
- }
-
- return vq, nil
-}
-
-func (vq *versionQueue) current() Version {
- if len(vq.pi) > 0 {
- return vq.pi[0]
- }
-
- return nil
-}
-
-func (vq *versionQueue) advance(fail error) (err error) {
- // The current version may have failed, but the next one hasn't
- vq.failed = false
-
- if len(vq.pi) == 0 {
- return
- }
-
- vq.fails = append(vq.fails, failedVersion{
- v: vq.pi[0],
- f: fail,
- })
- if vq.allLoaded {
- vq.pi = vq.pi[1:]
- return
- }
-
- vq.allLoaded = true
- // Can only get here if no lock was initially provided, so we know we
- // should have that
- lockv := vq.pi[0]
-
- vq.pi, err = vq.sm.listVersions(vq.id)
- if err != nil {
- return
- }
-
- // search for and remove locked version
- // TODO should be able to avoid O(n) here each time...if it matters
- for k, pi := range vq.pi {
- if pi == lockv {
- // GC-safe deletion for slice w/pointer elements
- //vq.pi, vq.pi[len(vq.pi)-1] = append(vq.pi[:k], vq.pi[k+1:]...), nil
- vq.pi = append(vq.pi[:k], vq.pi[k+1:]...)
- }
- }
-
- // normal end of queue. we don't error; it's left to the caller to infer an
- // empty queue w/a subsequent call to current(), which will return an empty
- // item.
- // TODO this approach kinda...sucks
- return
-}
-
-// isExhausted indicates whether or not the queue has definitely been exhausted,
-// in which case it will return true.
-//
-// It may return false negatives - suggesting that there is more in the queue
-// when a subsequent call to current() will be empty. Plan accordingly.
-func (vq *versionQueue) isExhausted() bool {
- if !vq.allLoaded {
- return false
- }
- return len(vq.pi) == 0
-}
-
-func (vq *versionQueue) String() string {
- var vs []string
-
- for _, v := range vq.pi {
- vs = append(vs, v.String())
- }
- return fmt.Sprintf("[%s]", strings.Join(vs, ", "))
-}
