Initial commit based on gb c057f8ce
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..abe0e88
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 constabulary
+Copyright (c) 2015 Filippo Valsorda
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..993b22d
--- /dev/null
+++ b/README.md
@@ -0,0 +1,63 @@
+# gvt, the go vendoring tool
+
+`gvt` is a simple Go vendoring tool made for the GO15VENDOREXPERIMENT. It's based entirely on [gb-vendor](https://github.com/constabulary/gb).
+
+You run `gvt fetch` when you would run `go get`. gvt downloads dependencies to `./vendor/`. With `GO15VENDOREXPERIMENT=1` set the compiler will find and use those packages without need to do import path rewriting. `gvt` works recursively as you would expect, and lets you update vendored dependencies. It also writes a manifest to `./vendor/manifest`.
+
+Packages whose dependencies are vendored with gvt are `go build`-able and `go get`-able by Go 1.5 with `GO15VENDOREXPERIMENT=1` set.
+
+## Installation
+
+```
+go get -u github.com/FiloSottile/gvt
+```
+
+## Usage
+
+```
+$ gvt fetch github.com/fatih/color
+2015/09/05 02:38:06 fetching recursive dependency github.com/mattn/go-isatty
+2015/09/05 02:38:07 fetching recursive dependency github.com/shiena/ansicolor
+
+$ tree -d
+.
+└── vendor
+ └── github.com
+ ├── fatih
+ │ └── color
+ ├── mattn
+ │ └── go-isatty
+ └── shiena
+ └── ansicolor
+ └── ansicolor
+
+9 directories
+
+$ cat > main.go
+package main
+import "github.com/fatih/color"
+func main() {
+ color.Red("Hello, world!")
+}
+
+$ export GO15VENDOREXPERIMENT=1
+
+$ go build .
+
+$ ./hello
+Hello, world!
+
+$ gvt update github.com/fatih/color
+```
+
+[Full usage on godoc.](https://godoc.org/github.com/FiloSottile/gvt)
+
+## Why
+
+There are many Go vendoring tools, but they all have some subset of the following problems
+
+ * no GO15VENDOREXPERIMENT support: old tools are based on import path rewriting or GOPATH overrides
+ * requirement to run on clients: some require the user to install the tool and run it after cloning, which breaks `go get`
+ * **no real fetching support**: tools like Godep just copy source from your GOPATH, instead of pulling it from the Internet
+ * prominent metadata files: there's no need for the manifest to be in your repository root, or in its own empty folder
+ * entire different build stack: gb-vendor is awesome but it requires you to build your project with gb
diff --git a/alldocs.go b/alldocs.go
new file mode 100644
index 0000000..32da424
--- /dev/null
+++ b/alldocs.go
@@ -0,0 +1,92 @@
+// DO NOT EDIT THIS FILE.
+//go:generate gvt help documentation
+
+/*
+gvt, a tool to manage your vendored dependencies.
+
+Usage:
+ gvt command [arguments]
+
+The commands are:
+
+ fetch fetch a remote dependency
+ update update a local dependency
+ list lists dependencies, one per line
+ delete delete a local dependency
+
+Use "gvt help [command]" for more information about a command.
+
+
+## Fetch a remote dependency
+
+Usage:
+ gvt fetch [-branch branch | -revision rev | -tag tag] [-precaire] [-no-recurse] importpath
+
+fetch vendors an upstream import path.
+
+The import path may include a url scheme. This may be useful when fetching dependencies
+from private repositories that cannot be probed.
+
+Flags:
+ -branch branch
+ fetch from the name branch. If not supplied the default upstream
+ branch will be used.
+ -no-recurse
+ do not fetch recursively.
+ -tag tag
+ fetch the specified tag. If not supplied the default upstream
+ branch will be used.
+ -revision rev
+ fetch the specific revision from the branch (if supplied). If no
+ revision supplied, the latest available will be supplied.
+ -precaire
+ allow the use of insecure protocols.
+
+## Update a local dependency
+
+Usage:
+ gvt update [-all] import
+
+update will replaces the source with the latest available from the head of the master branch.
+
+Updating from one copy of a dependency to another comes with several restrictions.
+The first is you can only update to the head of the branch your dependency was vendored from, switching branches is not supported.
+The second restriction is if you have used -tag or -revision while vendoring a dependency, your dependency is "headless"
+(to borrow a term from git) and cannot be updated.
+
+To update across branches, or from one tag/revision to another, you must first use delete to remove the dependency, then
+fetch [-tag | -revision | -branch ] [-precaire] to replace it.
+
+Flags:
+ -all
+ will update all dependencies in the manifest, otherwise only the dependency supplied.
+ -precaire
+ allow the use of insecure protocols.
+
+## Lists dependencies, one per line
+
+Usage:
+ gvt list [-f format]
+
+list formats the contents of the manifest file.
+
+The output
+
+Flags:
+ -f
+ controls the template used for printing each manifest entry. If not supplied
+ the default value is "{{.Importpath}}\t{{.Repository}}{{.Path}}\t{{.Branch}}\t{{.Revision}}"
+
+## Delete a local dependency
+
+Usage:
+ gvt delete [-all] importpath
+
+delete removes a dependency from the vendor directory and the manifest
+
+Flags:
+ -all
+ remove all dependencies
+
+*/
+package main
diff --git a/delete.go b/delete.go
new file mode 100644
index 0000000..9a0476c
--- /dev/null
+++ b/delete.go
@@ -0,0 +1,70 @@
+package main
+
+import (
+ "flag"
+ "fmt"
+ "path/filepath"
+
+ "github.com/FiloSottile/gvt/gbvendor"
+)
+
+var (
+ deleteAll bool // delete all dependencies
+)
+
+func addDeleteFlags(fs *flag.FlagSet) {
+ fs.BoolVar(&deleteAll, "all", false, "delete all dependencies")
+}
+
+var cmdDelete = &Command{
+ Name: "delete",
+ UsageLine: "delete [-all] importpath",
+ Short: "delete a local dependency",
+ Long: `delete removes a dependency from the vendor directory and the manifest
+
+Flags:
+ -all
+ remove all dependencies
+
+`,
+ Run: func(args []string) error {
+ if len(args) != 1 && !deleteAll {
+ return fmt.Errorf("delete: import path or --all flag is missing")
+ } else if len(args) == 1 && deleteAll {
+ return fmt.Errorf("delete: you cannot specify path and --all flag at once")
+ }
+
+ m, err := vendor.ReadManifest(manifestFile())
+ if err != nil {
+ return fmt.Errorf("could not load manifest: %v", err)
+ }
+
+ var dependencies []vendor.Dependency
+ if deleteAll {
+ dependencies = make([]vendor.Dependency, len(m.Dependencies))
+ copy(dependencies, m.Dependencies)
+ } else {
+ p := args[0]
+ dependency, err := m.GetDependencyForImportpath(p)
+ if err != nil {
+ return fmt.Errorf("could not get dependency: %v", err)
+ }
+ dependencies = append(dependencies, dependency)
+ }
+
+ for _, d := range dependencies {
+ path := d.Importpath
+
+ if err := m.RemoveDependency(d); err != nil {
+ return fmt.Errorf("dependency could not be deleted: %v", err)
+ }
+
+ if err := vendor.RemoveAll(filepath.Join(vendorDir(), filepath.FromSlash(path))); err != nil {
+ // TODO(dfc) need to apply vendor.cleanpath here to remove indermediate directories.
+ return fmt.Errorf("dependency could not be deleted: %v", err)
+ }
+ }
+ return vendor.WriteManifest(manifestFile(), m)
+ },
+ AddFlags: addDeleteFlags,
+}
diff --git a/fetch.go b/fetch.go
new file mode 100644
index 0000000..831d620
--- /dev/null
+++ b/fetch.go
@@ -0,0 +1,285 @@
+package main
+
+import (
+ "flag"
+ "fmt"
+ "log"
+ "net/url"
+ "path/filepath"
+ "runtime"
+ "sort"
+
+ "go/build"
+
+ "github.com/FiloSottile/gvt/gbvendor"
+)
+
+var (
+ branch string
+ revision string // revision (commit)
+ tag string
+ noRecurse bool
+ insecure bool // Allow the use of insecure protocols
+
+ recurse bool // should we fetch recursively
+)
+
+func addFetchFlags(fs *flag.FlagSet) {
+ fs.StringVar(&branch, "branch", "", "branch of the package")
+ fs.StringVar(&revision, "revision", "", "revision of the package")
+ fs.StringVar(&tag, "tag", "", "tag of the package")
+ fs.BoolVar(&noRecurse, "no-recurse", false, "do not fetch recursively")
+ fs.BoolVar(&insecure, "precaire", false, "allow the use of insecure protocols")
+}
+
+var cmdFetch = &Command{
+ Name: "fetch",
+ UsageLine: "fetch [-branch branch | -revision rev | -tag tag] [-precaire] [-no-recurse] importpath",
+ Short: "fetch a remote dependency",
+ Long: `fetch vendors an upstream import path.
+
+The import path may include a url scheme. This may be useful when fetching dependencies
+from private repositories that cannot be probed.
+
+Flags:
+ -branch branch
+ fetch from the name branch. If not supplied the default upstream
+ branch will be used.
+ -no-recurse
+ do not fetch recursively.
+ -tag tag
+ fetch the specified tag. If not supplied the default upstream
+ branch will be used.
+ -revision rev
+ fetch the specific revision from the branch (if supplied). If no
+ revision supplied, the latest available will be supplied.
+ -precaire
+ allow the use of insecure protocols.
+
+`,
+ Run: func(args []string) error {
+ switch len(args) {
+ case 0:
+ return fmt.Errorf("fetch: import path missing")
+ case 1:
+ path := args[0]
+ recurse = !noRecurse
+ return fetch(path, recurse)
+ default:
+ return fmt.Errorf("more than one import path supplied")
+ }
+ },
+ AddFlags: addFetchFlags,
+}
+
+func fetch(path string, recurse bool) error {
+ m, err := vendor.ReadManifest(manifestFile())
+ if err != nil {
+ return fmt.Errorf("could not load manifest: %v", err)
+ }
+
+ repo, extra, err := vendor.DeduceRemoteRepo(path, insecure)
+ if err != nil {
+ return err
+ }
+
+ // strip of any scheme portion from the path, it is already
+ // encoded in the repo.
+ path = stripscheme(path)
+
+ if m.HasImportpath(path) {
+ return fmt.Errorf("%s is already vendored", path)
+ }
+
+ var wc vendor.WorkingCopy
+
+ // if we are not recursing, then always fetch the HEAD of the master
+ if recurse {
+ wc, err = repo.Checkout(branch, tag, revision)
+ } else {
+ wc, err = repo.Checkout("", "", "")
+ }
+
+ if err != nil {
+ return err
+ }
+
+ rev, err := wc.Revision()
+ if err != nil {
+ return err
+ }
+
+ branch, err := wc.Branch()
+ if err != nil {
+ return err
+ }
+
+ dep := vendor.Dependency{
+ Importpath: path,
+ Repository: repo.URL(),
+ Revision: rev,
+ Branch: branch,
+ Path: extra,
+ }
+
+ if err := m.AddDependency(dep); err != nil {
+ return err
+ }
+
+ dst := filepath.Join(vendorDir(), dep.Importpath)
+ src := filepath.Join(wc.Dir(), dep.Path)
+
+ if err := vendor.Copypath(dst, src); err != nil {
+ return err
+ }
+
+ if err := vendor.WriteManifest(manifestFile(), m); err != nil {
+ return err
+ }
+
+ if err := wc.Destroy(); err != nil {
+ return err
+ }
+
+ if !recurse {
+ return nil
+ }
+
+ for done := false; !done; {
+
+ paths := []struct {
+ Root, Prefix string
+ }{
+ {filepath.Join(runtime.GOROOT(), "src"), ""},
+ }
+ m, err := vendor.ReadManifest(manifestFile())
+ if err != nil {
+ return err
+ }
+ for _, d := range m.Dependencies {
+ paths = append(paths, struct{ Root, Prefix string }{filepath.Join(vendorDir(), filepath.FromSlash(d.Importpath)), filepath.FromSlash(d.Importpath)})
+ }
+
+ dsm, err := vendor.LoadPaths(paths...)
+ if err != nil {
+ return err
+ }
+
+ is, ok := dsm[filepath.Join(vendorDir(), path)]
+ if !ok {
+ return fmt.Errorf("unable to locate depset for %q", path)
+ }
+
+ missing := findMissing(pkgs(is.Pkgs), dsm)
+ switch len(missing) {
+ case 0:
+ done = true
+ default:
+
+ // sort keys in ascending order, so the shortest missing import path
+ // with be fetched first.
+ keys := keys(missing)
+ sort.Strings(keys)
+ pkg := keys[0]
+ log.Printf("fetching recursive dependency %s", pkg)
+ if err := fetch(pkg, false); err != nil {
+ return err
+ }
+ }
+ }
+
+ return nil
+}
+
+func keys(m map[string]bool) []string {
+ var s []string
+ for k := range m {
+ s = append(s, k)
+ }
+ return s
+}
+
+func pkgs(m map[string]*vendor.Pkg) []*vendor.Pkg {
+ var p []*vendor.Pkg
+ for _, v := range m {
+ p = append(p, v)
+ }
+ return p
+}
+
+func findMissing(pkgs []*vendor.Pkg, dsm map[string]*vendor.Depset) map[string]bool {
+ missing := make(map[string]bool)
+ imports := make(map[string]*vendor.Pkg)
+ for _, s := range dsm {
+ for _, p := range s.Pkgs {
+ imports[p.ImportPath] = p
+ }
+ }
+
+ // make fake C package for cgo
+ imports["C"] = &vendor.Pkg{
+ Depset: nil, // probably a bad idea
+ Package: &build.Package{
+ Name: "C",
+ },
+ }
+ stk := make(map[string]bool)
+ push := func(v string) {
+ if stk[v] {
+ panic(fmt.Sprintln("import loop:", v, stk))
+ }
+ stk[v] = true
+ }
+ pop := func(v string) {
+ if !stk[v] {
+ panic(fmt.Sprintln("impossible pop:", v, stk))
+ }
+ delete(stk, v)
+ }
+
+ // checked records import paths who's dependencies are all present
+ checked := make(map[string]bool)
+
+ var fn func(string)
+ fn = func(importpath string) {
+ p, ok := imports[importpath]
+ if !ok {
+ missing[importpath] = true
+ return
+ }
+
+ // have we already walked this arm, if so, skip it
+ if checked[importpath] {
+ return
+ }
+
+ sz := len(missing)
+ push(importpath)
+ for _, i := range p.Imports {
+ if i == importpath {
+ continue
+ }
+ fn(i)
+ }
+
+ // if the size of the missing map has not changed
+ // this entire subtree is complete, mark it as such
+ if len(missing) == sz {
+ checked[importpath] = true
+ }
+ pop(importpath)
+ }
+ for _, pkg := range pkgs {
+ fn(pkg.ImportPath)
+ }
+ return missing
+}
+
+// stripscheme removes any scheme components from url like paths.
+func stripscheme(path string) string {
+ u, err := url.Parse(path)
+ if err != nil {
+ panic(err)
+ }
+ return u.Host + u.Path
+}
diff --git a/gbvendor/_testdata/copyfile/a/rick b/gbvendor/_testdata/copyfile/a/rick
new file mode 120000
index 0000000..0db35ec
--- /dev/null
+++ b/gbvendor/_testdata/copyfile/a/rick
@@ -0,0 +1 @@
+/never/going/to/give/you/up
\ No newline at end of file
diff --git a/gbvendor/_testdata/src/github.com/foo/bar/main.go b/gbvendor/_testdata/src/github.com/foo/bar/main.go
new file mode 100644
index 0000000..399afdd
--- /dev/null
+++ b/gbvendor/_testdata/src/github.com/foo/bar/main.go
@@ -0,0 +1,17 @@
+package main
+
+import (
+ "fmt"
+
+ "github.com/quux/flobble"
+ // "bitbucket.org/fwoop/ftang" // commented out, this is deliberate
+ moo "github.com/lypo/moopo"
+)
+
+import "github.com/hoo/wuu"
+
+func main() {
+ fmt.Println(flobble.Q)
+ fmt.Prinln(moo.Q)
+ fmt.Println(wuu.Q)
+}
diff --git a/gbvendor/_testdata/vendor/src/bitbucket.org/fwoop/ftang/kthulu.go b/gbvendor/_testdata/vendor/src/bitbucket.org/fwoop/ftang/kthulu.go
new file mode 100644
index 0000000..baa83bb
--- /dev/null
+++ b/gbvendor/_testdata/vendor/src/bitbucket.org/fwoop/ftang/kthulu.go
@@ -0,0 +1,3 @@
+package ftang
+
+const CAT = "ack!"
diff --git a/gbvendor/_testdata/vendor/src/github.com/hoo/wuu/goo.go b/gbvendor/_testdata/vendor/src/github.com/hoo/wuu/goo.go
new file mode 100644
index 0000000..fd4d087
--- /dev/null
+++ b/gbvendor/_testdata/vendor/src/github.com/hoo/wuu/goo.go
@@ -0,0 +1,3 @@
+package wuu
+
+const Q = "hey"
diff --git a/gbvendor/_testdata/vendor/src/github.com/lypo/moopo/tropo.go b/gbvendor/_testdata/vendor/src/github.com/lypo/moopo/tropo.go
new file mode 100644
index 0000000..834ab54
--- /dev/null
+++ b/gbvendor/_testdata/vendor/src/github.com/lypo/moopo/tropo.go
@@ -0,0 +1,3 @@
+package moopo
+
+const Q = "hi"
diff --git a/gbvendor/_testdata/vendor/src/github.com/quux/flobble/wobble.go b/gbvendor/_testdata/vendor/src/github.com/quux/flobble/wobble.go
new file mode 100644
index 0000000..fa9e631
--- /dev/null
+++ b/gbvendor/_testdata/vendor/src/github.com/quux/flobble/wobble.go
@@ -0,0 +1,3 @@
+package flobble
+
+const Q = "hello"
diff --git a/gbvendor/copy.go b/gbvendor/copy.go
new file mode 100644
index 0000000..1d2f599
--- /dev/null
+++ b/gbvendor/copy.go
@@ -0,0 +1,69 @@
+package vendor
+
+import (
+ "fmt"
+ "io"
+ "os"
+ "path/filepath"
+ "strings"
+)
+
+const debugCopypath = true
+const debugCopyfile = false
+
+// Copypath copies the contents of src to dst, excluding any file or
+// directory that starts with a period.
+func Copypath(dst string, src string) error {
+ err := filepath.Walk(src, func(path string, info os.FileInfo, err error) error {
+ if err != nil {
+ return err
+ }
+
+ if strings.HasPrefix(filepath.Base(path), ".") {
+ if info.IsDir() {
+ return filepath.SkipDir
+ }
+ return nil
+ }
+
+ if info.IsDir() {
+ return nil
+ }
+
+ if info.Mode()&os.ModeSymlink != 0 {
+ if debugCopypath {
+ fmt.Printf("skipping symlink: %v\n", path)
+ }
+ return nil
+ }
+
+ dst := filepath.Join(dst, path[len(src):])
+ return copyfile(dst, path)
+ })
+ if err != nil {
+ // if there was an error during copying, remove the partial copy.
+ RemoveAll(dst)
+ }
+ return err
+}
+
+func copyfile(dst, src string) error {
+ err := mkdir(filepath.Dir(dst))
+ if err != nil {
+ return fmt.Errorf("copyfile: mkdirall: %v", err)
+ }
+ r, err := os.Open(src)
+ if err != nil {
+ return fmt.Errorf("copyfile: open(%q): %v", src, err)
+ }
+ defer r.Close()
+ w, err := os.Create(dst)
+ if err != nil {
+ return fmt.Errorf("copyfile: create(%q): %v", dst, err)
+ }
+ if debugCopyfile {
+ fmt.Printf("copyfile(dst: %v, src: %v)\n", dst, src)
+ }
+ _, err = io.Copy(w, r)
+ return err
+}
diff --git a/gbvendor/copy_test.go b/gbvendor/copy_test.go
new file mode 100644
index 0000000..297d198
--- /dev/null
+++ b/gbvendor/copy_test.go
@@ -0,0 +1,19 @@
+package vendor
+
+import (
+ "path/filepath"
+ "runtime"
+ "testing"
+)
+
+func TestCopypathSkipsSymlinks(t *testing.T) {
+ if runtime.GOOS == "windows" {
+ t.Skip("no symlinks on windows y'all")
+ }
+ dst := mktemp(t)
+ defer RemoveAll(dst)
+ src := filepath.Join("_testdata", "copyfile", "a")
+ if err := Copypath(dst, src); err != nil {
+ t.Fatalf("copypath(%s, %s): %v", dst, src, err)
+ }
+}
diff --git a/gbvendor/depset.go b/gbvendor/depset.go
new file mode 100644
index 0000000..b4c40d8
--- /dev/null
+++ b/gbvendor/depset.go
@@ -0,0 +1,114 @@
+package vendor
+
+import (
+ "fmt"
+ "go/build"
+ "os"
+ "path/filepath"
+ "strings"
+)
+
+// Pkg describes a Go package.
+type Pkg struct {
+ *Depset
+ *build.Package
+}
+
+// Depset describes a set of related Go packages.
+type Depset struct {
+ Root string
+ Prefix string
+ Pkgs map[string]*Pkg
+}
+
+// LoadPaths returns a map of paths to Depsets.
+func LoadPaths(paths ...struct{ Root, Prefix string }) (map[string]*Depset, error) {
+ m := make(map[string]*Depset)
+ for _, p := range paths {
+ set, err := LoadTree(p.Root, p.Prefix)
+ if err != nil {
+ return nil, err
+ }
+ m[set.Root] = set
+ }
+ return m, nil
+}
+
+// LoadTree parses a tree of source files into a map of *pkgs.
+func LoadTree(root string, prefix string) (*Depset, error) {
+ d := Depset{
+ Root: root,
+ Prefix: prefix,
+ Pkgs: make(map[string]*Pkg),
+ }
+ fn := func(dir string, fi os.FileInfo) error {
+ importpath := filepath.Join(prefix, dir[len(root)+1:])
+
+ // if we're at the root of a tree, skip it
+ if importpath == "" {
+ return nil
+ }
+
+ p, err := loadPackage(&d, dir)
+ if err != nil {
+ if _, ok := err.(*build.NoGoError); ok {
+ return nil
+ }
+ return fmt.Errorf("loadPackage(%q, %q): %v", dir, importpath, err)
+ }
+ p.ImportPath = filepath.ToSlash(importpath)
+ if p != nil {
+ d.Pkgs[p.ImportPath] = p
+ }
+ return nil
+ }
+
+ // handle root of the tree
+ fi, err := os.Stat(root)
+ if err != nil {
+ return nil, err
+ }
+ if err := fn(root+string(filepath.Separator), fi); err != nil {
+ return nil, err
+ }
+
+ // walk sub directories
+ err = eachDir(root, fn)
+ return &d, err
+}
+
+func loadPackage(d *Depset, dir string) (*Pkg, error) {
+ p := Pkg{
+ Depset: d,
+ }
+ var err error
+
+ // expolit local import logic
+ p.Package, err = build.ImportDir(dir, build.ImportComment)
+ return &p, err
+}
+
+func eachDir(dir string, fn func(string, os.FileInfo) error) error {
+ f, err := os.Open(dir)
+ if err != nil {
+ return err
+ }
+ defer f.Close()
+ files, err := f.Readdir(-1)
+ for _, fi := range files {
+ if !fi.IsDir() {
+ continue
+ }
+ if strings.HasPrefix(fi.Name(), "_") || strings.HasPrefix(fi.Name(), ".") || fi.Name() == "testdata" {
+ continue
+ }
+ path := filepath.Join(dir, fi.Name())
+ if err := fn(path, fi); err != nil {
+ return err
+ }
+ if err := eachDir(path, fn); err != nil {
+ return err
+ }
+ }
+ return nil
+}
diff --git a/gbvendor/discovery.go b/gbvendor/discovery.go
new file mode 100644
index 0000000..f504200
--- /dev/null
+++ b/gbvendor/discovery.go
@@ -0,0 +1,80 @@
+// Copyright 2012 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package vendor
+
+import (
+ "encoding/xml"
+ "fmt"
+ "io"
+ "strings"
+)
+
+// charsetReader returns a reader for the given charset. Currently
+// it only supports UTF-8 and ASCII. Otherwise, it returns a meaningful
+// error which is printed by go get, so the user can find why the package
+// wasn't downloaded if the encoding is not supported. Note that, in
+// order to reduce potential errors, ASCII is treated as UTF-8 (i.e. characters
+// greater than 0x7f are not rejected).
+func charsetReader(charset string, input io.Reader) (io.Reader, error) {
+ switch strings.ToLower(charset) {
+ case "ascii":
+ return input, nil
+ default:
+ return nil, fmt.Errorf("can't decode XML document using charset %q", charset)
+ }
+}
+
+type metaImport struct {
+ Prefix, VCS, RepoRoot string
+}
+
+// parseMetaGoImports returns meta imports from the HTML in r.
+// Parsing ends at the end of the <head> section or the beginning of the <body>.
+func parseMetaGoImports(r io.Reader) (imports []metaImport, err error) {
+ d := xml.NewDecoder(r)
+ d.CharsetReader = charsetReader
+ d.Strict = false
+ var t xml.Token
+ for {
+ t, err = d.Token()
+ if err != nil {
+ if err == io.EOF {
+ err = nil
+ }
+ return
+ }
+ if e, ok := t.(xml.StartElement); ok && strings.EqualFold(e.Name.Local, "body") {
+ return
+ }
+ if e, ok := t.(xml.EndElement); ok && strings.EqualFold(e.Name.Local, "head") {
+ return
+ }
+ e, ok := t.(xml.StartElement)
+ if !ok || !strings.EqualFold(e.Name.Local, "meta") {
+ continue
+ }
+ if attrValue(e.Attr, "name") != "go-import" {
+ continue
+ }
+ if f := strings.Fields(attrValue(e.Attr, "content")); len(f) == 3 {
+ imports = append(imports, metaImport{
+ Prefix: f[0],
+ VCS: f[1],
+ RepoRoot: f[2],
+ })
+ }
+ }
+}
+
+// attrValue returns the attribute value for the case-insensitive key
+// `name', or the empty string if nothing is found.
+func attrValue(attrs []xml.Attr, name string) string {
+ for _, a := range attrs {
+ if strings.EqualFold(a.Name.Local, name) {
+ return a.Value
+ }
+ }
+ return ""
+}
diff --git a/gbvendor/imports.go b/gbvendor/imports.go
new file mode 100644
index 0000000..93223cc
--- /dev/null
+++ b/gbvendor/imports.go
@@ -0,0 +1,110 @@
+package vendor
+
+import (
+ "fmt"
+ "go/parser"
+ "go/token"
+ "io"
+ "net/http"
+ "os"
+ "path/filepath"
+ "strings"
+
+ "github.com/constabulary/gb"
+)
+
+// ParseImports parses Go packages from a specific root returning a set of import paths.
+func ParseImports(root string) (map[string]bool, error) {
+ pkgs := make(map[string]bool)
+
+ var walkFn = func(path string, info os.FileInfo, err error) error {
+ if info.IsDir() {
+ name := info.Name()
+ if strings.HasPrefix(name, ".") || strings.HasPrefix(name, "_") || name == "testdata" {
+ return filepath.SkipDir
+ }
+ return nil
+ }
+ if filepath.Ext(path) != ".go" { // Parse only go source files
+ return nil
+ }
+
+ fs := token.NewFileSet()
+ f, err := parser.ParseFile(fs, path, nil, parser.ImportsOnly)
+ if err != nil {
+ return err
+ }
+
+ for _, s := range f.Imports {
+ p := strings.Replace(s.Path.Value, "\"", "", -1)
+ if !contains(stdlib, p) {
+ pkgs[p] = true
+ }
+ }
+ return nil
+ }
+
+ err := filepath.Walk(root, walkFn)
+ return pkgs, err
+}
+
+// FetchMetadata fetchs the remote metadata for path.
+func FetchMetadata(path string, insecure bool) (io.ReadCloser, error) {
+ schemes := []string{"https", "http"}
+ for _, s := range schemes {
+ if r, err := fetchMetadata(s, path, insecure); err == nil {
+ return r, nil
+ }
+ }
+ return nil, fmt.Errorf("unable to determine remote metadata protocol")
+}
+
+func fetchMetadata(scheme, path string, insecure bool) (io.ReadCloser, error) {
+ url := fmt.Sprintf("%s://%s?go-get=1", scheme, path)
+ switch scheme {
+ case "https":
+ resp, err := http.Get(url)
+ if err == nil {
+ return resp.Body, nil
+ }
+ case "http":
+ if !insecure {
+ gb.Infof("skipping insecure protocol: %v", url)
+ } else {
+ resp, err := http.Get(url)
+ if err == nil {
+ return resp.Body, nil
+ }
+ }
+ }
+
+ return nil, fmt.Errorf("unknown remote protocol scheme: %q", scheme)
+}
+
+// ParseMetadata fetchs and decodes remote metadata for path.
+func ParseMetadata(path string, insecure bool) (string, string, string, error) {
+ rc, err := FetchMetadata(path, insecure)
+ if err != nil {
+ return "", "", "", err
+ }
+ defer rc.Close()
+
+ imports, err := parseMetaGoImports(rc)
+ if err != nil {
+ return "", "", "", err
+ }
+ match := -1
+ for i, im := range imports {
+ if !strings.HasPrefix(path, im.Prefix) {
+ continue
+ }
+ if match != -1 {
+ return "", "", "", fmt.Errorf("multiple meta tags match import path %q", path)
+ }
+ match = i
+ }
+ if match == -1 {
+ return "", "", "", fmt.Errorf("go-import metadata not found")
+ }
+ return imports[match].Prefix, imports[match].VCS, imports[match].RepoRoot, nil
+}
diff --git a/gbvendor/imports_test.go b/gbvendor/imports_test.go
new file mode 100644
index 0000000..2794292
--- /dev/null
+++ b/gbvendor/imports_test.go
@@ -0,0 +1,134 @@
+package vendor
+
+import (
+ "bytes"
+ "fmt"
+ "io"
+ "os"
+ "path/filepath"
+ "reflect"
+ "testing"
+)
+
+func TestParseImports(t *testing.T) {
+ root := filepath.Join(getwd(t), "_testdata", "src")
+
+ got, err := ParseImports(root)
+ if err != nil {
+ t.Fatalf("ParseImports(%q): %v", root, err)
+ }
+
+ want := set("github.com/quux/flobble", "github.com/lypo/moopo", "github.com/hoo/wuu")
+ if !reflect.DeepEqual(got, want) {
+ t.Fatalf("ParseImports(%q): want: %v, got %v", root, want, got)
+ }
+}
+
+func TestFetchMetadata(t *testing.T) {
+ if testing.Short() {
+ t.Skipf("skipping network tests in -short mode")
+ }
+ tests := []struct {
+ path string
+ want string
+ insecure bool
+ }{{
+ path: "golang.org/x/tools/cmd/godoc",
+ want: `<!DOCTYPE html>
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
+<meta name="go-import" content="golang.org/x/tools git https://go.googlesource.com/tools">
+<meta name="go-source" content="golang.org/x/tools https://github.com/golang/tools/ https://github.com/golang/tools/tree/master{/dir} https://github.com/golang/tools/blob/master{/dir}/{file}#L{line}">
+<meta http-equiv="refresh" content="0; url=https://godoc.org/golang.org/x/tools/cmd/godoc">
+</head>
+<body>
+Nothing to see here; <a href="https://godoc.org/golang.org/x/tools/cmd/godoc">move along</a>.
+</body>
+</html>
+`,
+ }, {
+ path: "gopkg.in/check.v1",
+ want: `
+<html>
+<head>
+<meta name="go-import" content="gopkg.in/check.v1 git https://gopkg.in/check.v1">
+<meta name="go-source" content="gopkg.in/check.v1 _ https://github.com/go-check/check/tree/v1{/dir} https://github.com/go-check/check/blob/v1{/dir}/{file}#L{line}">
+</head>
+<body>
+go get gopkg.in/check.v1
+</body>
+</html>
+`,
+ }}
+
+ for _, tt := range tests {
+ r, err := FetchMetadata(tt.path, tt.insecure)
+ if err != nil {
+ t.Error(err)
+ continue
+ }
+ var buf bytes.Buffer
+ if _, err := io.Copy(&buf, r); err != nil {
+ t.Error(err)
+ r.Close()
+ continue
+ }
+ r.Close()
+ got := buf.String()
+ if got != tt.want {
+ t.Errorf("FetchMetadata(%q): want %q, got %q", tt.path, tt.want, got)
+ }
+ }
+}
+
+func TestParseMetadata(t *testing.T) {
+ if testing.Short() {
+ t.Skipf("skipping network tests in -short mode")
+ }
+ tests := []struct {
+ path string
+ importpath string
+ vcs string
+ reporoot string
+ insecure bool
+ err error
+ }{{
+ path: "golang.org/x/tools/cmd/godoc",
+ importpath: "golang.org/x/tools",
+ vcs: "git",
+ reporoot: "https://go.googlesource.com/tools",
+ }, {
+ path: "gopkg.in/check.v1",
+ importpath: "gopkg.in/check.v1",
+ vcs: "git",
+ reporoot: "https://gopkg.in/check.v1",
+ }, {
+ path: "gopkg.in/mgo.v2/bson",
+ importpath: "gopkg.in/mgo.v2",
+ vcs: "git",
+ reporoot: "https://gopkg.in/mgo.v2",
+ }, {
+ path: "speter.net/go/exp",
+ err: fmt.Errorf("go-import metadata not found"),
+ }}
+
+ for _, tt := range tests {
+ importpath, vcs, reporoot, err := ParseMetadata(tt.path, tt.insecure)
+ if !reflect.DeepEqual(err, tt.err) {
+ t.Error(err)
+ continue
+ }
+ if importpath != tt.importpath || vcs != tt.vcs || reporoot != tt.reporoot {
+ t.Errorf("ParseMetadata(%q): want %s %s %s, got %s %s %s ", tt.path, tt.importpath, tt.vcs, tt.reporoot, importpath, vcs, reporoot)
+ }
+ }
+}
+
+func getwd(t *testing.T) string {
+ cwd, err := os.Getwd()
+ if err != nil {
+ t.Fatal(err)
+ }
+ return cwd
+}
diff --git a/gbvendor/manifest.go b/gbvendor/manifest.go
new file mode 100644
index 0000000..f4d973e
--- /dev/null
+++ b/gbvendor/manifest.go
@@ -0,0 +1,149 @@
+package vendor
+
+import (
+ "bytes"
+ "encoding/json"
+ "fmt"
+ "io"
+ "os"
+ "reflect"
+ "sort"
+)
+
+// gb-vendor manifest support
+
+// Manifest describes the layout of $PROJECT/vendor/manifest.
+type Manifest struct {
+ // Manifest version. Current manifest version is 0.
+ Version int `json:"version"`
+
+ // Depenencies is a list of vendored dependencies.
+ Dependencies []Dependency `json:"dependencies"`
+}
+
+// AddDependency adds a Dependency to the current Manifest.
+// If the dependency exists already then it returns and error.
+func (m *Manifest) AddDependency(dep Dependency) error {
+ if m.HasImportpath(dep.Importpath) {
+ return fmt.Errorf("already registered")
+ }
+ m.Dependencies = append(m.Dependencies, dep)
+ return nil
+}
+
+// RemoveDependency removes a Dependency from the current Manifest.
+// If the dependency does not exist then it returns an error.
+func (m *Manifest) RemoveDependency(dep Dependency) error {
+ for i, d := range m.Dependencies {
+ if reflect.DeepEqual(d, dep) {
+ m.Dependencies = append(m.Dependencies[:i], m.Dependencies[i+1:]...)
+ return nil
+ }
+ }
+ return fmt.Errorf("dependency does not exist")
+}
+
+// HasImportpath reports whether the Manifest contains the import path.
+func (m *Manifest) HasImportpath(path string) bool {
+ _, err := m.GetDependencyForImportpath(path)
+ return err == nil
+}
+
+// GetDependencyForRepository return a dependency for specified URL
+// If the dependency does not exist it returns an error
+func (m *Manifest) GetDependencyForImportpath(path string) (Dependency, error) {
+ for _, d := range m.Dependencies {
+ if d.Importpath == path {
+ return d, nil
+ }
+ }
+ return Dependency{}, fmt.Errorf("dependency for %s does not exist", path)
+}
+
+// Dependency describes one vendored import path of code
+// A Dependency is an Importpath sources from a Respository
+// at Revision from Path.
+type Dependency struct {
+ // Importpath is name by which this dependency is known.
+ Importpath string `json:"importpath"`
+
+ // Repository is the remote DVCS location that this
+ // dependency was fetched from.
+ Repository string `json:"repository"`
+
+ // Revision is the revision that describes the dependency's
+ // remote revision.
+ Revision string `json:"revision"`
+
+ // Branch is the branch the Revision was located on.
+ // Can be blank if not needed.
+ Branch string `json:"branch"`
+
+ // Path is the path inside the Repository where the
+ // dependency was fetched from.
+ Path string `json:"path,omitempty"`
+}
+
+// WriteManifest writes a Manifest to the path. If the manifest does
+// not exist, it is created. If it does exist, it will be overwritten.
+// If the manifest file is empty (0 dependencies) it will be deleted.
+// The dependencies will be ordered by import path to reduce churn when making
+// changes.
+// TODO(dfc) write to temporary file and move atomically to avoid
+// destroying a working vendorfile.
+func WriteManifest(path string, m *Manifest) error {
+ if len(m.Dependencies) == 0 {
+ err := os.Remove(path)
+ if !os.IsNotExist(err) {
+ return err
+ }
+ return nil
+ }
+
+ f, err := os.Create(path)
+ if err != nil {
+ return err
+ }
+ if err := writeManifest(f, m); err != nil {
+ f.Close()
+ return err
+ }
+ return f.Close()
+}
+
+func writeManifest(w io.Writer, m *Manifest) error {
+ sort.Sort(byImportpath(m.Dependencies))
+ buf, err := json.MarshalIndent(m, "", "\t")
+ if err != nil {
+ return err
+ }
+ _, err = io.Copy(w, bytes.NewReader(buf))
+ return err
+}
+
+// ReadManifest reads a Manifest from path. If the Manifest is not
+// found, a blank Manifest will be returned.
+func ReadManifest(path string) (*Manifest, error) {
+ f, err := os.Open(path)
+ if err != nil {
+ if os.IsNotExist(err) {
+ return new(Manifest), nil
+ }
+ return nil, err
+ }
+ defer f.Close()
+ return readManifest(f)
+}
+
+func readManifest(r io.Reader) (*Manifest, error) {
+ var m Manifest
+ d := json.NewDecoder(r)
+ err := d.Decode(&m)
+ return &m, err
+}
+
+type byImportpath []Dependency
+
+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] }
diff --git a/gbvendor/manifest_test.go b/gbvendor/manifest_test.go
new file mode 100644
index 0000000..479f588
--- /dev/null
+++ b/gbvendor/manifest_test.go
@@ -0,0 +1,104 @@
+package vendor
+
+import (
+ "bytes"
+ "os"
+ "path/filepath"
+ "testing"
+)
+
+func mktemp(t *testing.T) string {
+ s, err := mktmp()
+ if err != nil {
+ t.Fatal(err)
+ }
+ return s
+}
+
+func assertNotExists(t *testing.T, path string) {
+ _, err := os.Stat(path)
+ if err == nil || !os.IsNotExist(err) {
+ t.Fatalf("expected %q to be not found, got %v", path, err)
+ }
+}
+
+func assertExists(t *testing.T, path string) {
+ _, err := os.Stat(path)
+ if err != nil {
+ t.Fatalf("expected %q to be found, got %v", path, err)
+ }
+}
+
+func TestManifest(t *testing.T) {
+ root := mktemp(t)
+ defer RemoveAll(root)
+
+ mf := filepath.Join(root, "vendor")
+
+ // check that reading an non existant manifest
+ // does not return an error
+ m, err := ReadManifest(mf)
+ if err != nil {
+ t.Fatalf("reading a non existant manifest should not fail: %v", err)
+ }
+
+ // check that no manifest file was created
+ assertNotExists(t, mf)
+
+ // add a dep
+ m.Dependencies = append(m.Dependencies, Dependency{
+ Importpath: "github.com/foo/bar/baz",
+ Repository: "https://github.com/foo/bar",
+ Revision: "cafebad",
+ Branch: "master",
+ Path: "/baz",
+ })
+
+ // write it back
+ if err := WriteManifest(mf, m); err != nil {
+ t.Fatalf("WriteManifest failed: %v", err)
+ }
+
+ // check the manifest was written
+ assertExists(t, mf)
+
+ // remove it
+ m.Dependencies = nil
+ if err := WriteManifest(mf, m); err != nil {
+ t.Fatalf("WriteManifest failed: %v", err)
+ }
+
+ // check that no manifest file was removed
+ assertNotExists(t, mf)
+}
+
+func TestEmptyPathIsNotWritten(t *testing.T) {
+ m := Manifest{
+ Version: 0,
+ Dependencies: []Dependency{{
+ Importpath: "github.com/foo/bar",
+ Repository: "https://github.com/foo/bar",
+ Revision: "abcdef",
+ Branch: "master",
+ }},
+ }
+ var buf bytes.Buffer
+ if err := writeManifest(&buf, &m); err != nil {
+ t.Fatal(err)
+ }
+ want := `{
+ "version": 0,
+ "dependencies": [
+ {
+ "importpath": "github.com/foo/bar",
+ "repository": "https://github.com/foo/bar",
+ "revision": "abcdef",
+ "branch": "master"
+ }
+ ]
+}`
+ got := buf.String()
+ if want != got {
+ t.Fatalf("want: %s, got %s", want, got)
+ }
+}
diff --git a/gbvendor/remove.go b/gbvendor/remove.go
new file mode 100644
index 0000000..fdc155b
--- /dev/null
+++ b/gbvendor/remove.go
@@ -0,0 +1,23 @@
+package vendor
+
+import (
+ "os"
+ "path/filepath"
+ "runtime"
+)
+
+// RemoveAll removes path and any children it contains. Unlike os.RemoveAll it
+// deletes read only files on Windows.
+func RemoveAll(path string) error {
+ if runtime.GOOS == "windows" {
+ // make sure all files are writable so we can delete them
+ filepath.Walk(path, func(path string, info os.FileInfo, err error) error {
+ mode := info.Mode()
+ if mode|0200 == mode {
+ return nil
+ }
+ return os.Chmod(path, mode|0200)
+ })
+ }
+ return os.RemoveAll(path)
+}
diff --git a/gbvendor/repo.go b/gbvendor/repo.go
new file mode 100644
index 0000000..521054b
--- /dev/null
+++ b/gbvendor/repo.go
@@ -0,0 +1,542 @@
+package vendor
+
+import (
+ "bytes"
+ "fmt"
+ "io"
+ "io/ioutil"
+ "net/url"
+ "os"
+ "os/exec"
+ "path/filepath"
+ "regexp"
+ "strings"
+
+ "github.com/constabulary/gb"
+)
+
+// RemoteRepo describes a remote dvcs repository.
+type RemoteRepo interface {
+
+ // Checkout checks out a specific branch, tag, or revision.
+ // The interpretation of these three values is impementation
+ // specific.
+ Checkout(branch, tag, revision string) (WorkingCopy, error)
+
+ // URL returns the URL the clone was taken from. It should
+ // only be called after Clone.
+ URL() string
+}
+
+// WorkingCopy represents a local copy of a remote dvcs repository.
+type WorkingCopy interface {
+
+ // Dir is the root of this working copy.
+ Dir() string
+
+ // Revision returns the revision of this working copy.
+ Revision() (string, error)
+
+ // Branch returns the branch to which this working copy belongs.
+ Branch() (string, error)
+
+ // Destroy removes the working copy and cleans path to the working copy.
+ Destroy() error
+}
+
+var (
+ ghregex = regexp.MustCompile(`^(?P<root>github\.com/([A-Za-z0-9_.\-]+/[A-Za-z0-9_.\-]+))(/[A-Za-z0-9_.\-]+)*$`)
+ bbregex = regexp.MustCompile(`^(?P<root>bitbucket\.org/(?P<bitname>[A-Za-z0-9_.\-]+/[A-Za-z0-9_.\-]+))(/[A-Za-z0-9_.\-]+)*$`)
+ lpregex = regexp.MustCompile(`^launchpad.net/([A-Za-z0-9-._]+)(/[A-Za-z0-9-._]+)?(/.+)?`)
+ gcregex = regexp.MustCompile(`^(?P<root>code\.google\.com/[pr]/(?P<project>[a-z0-9\-]+)(\.(?P<subrepo>[a-z0-9\-]+))?)(/[A-Za-z0-9_.\-]+)*$`)
+ genericre = regexp.MustCompile(`^(?P<root>(?P<repo>([a-z0-9.\-]+\.)+[a-z0-9.\-]+(:[0-9]+)?/[A-Za-z0-9_.\-/]*?)\.(?P<vcs>bzr|git|hg|svn))([/A-Za-z0-9_.\-]+)*$`)
+)
+
+// DeduceRemoteRepo takes a potential import path and returns a RemoteRepo
+// representing the remote location of the source of an import path.
+// Remote repositories can be bare import paths, or urls including a checkout scheme.
+// If deduction would cause traversal of an insecure host, a message will be
+// printed and the travelsal path will be ignored.
+func DeduceRemoteRepo(path string, insecure bool) (RemoteRepo, string, error) {
+ u, err := url.Parse(path)
+ if err != nil {
+ return nil, "", fmt.Errorf("%q is not a valid import path", path)
+ }
+
+ var schemes []string
+ if u.Scheme != "" {
+ schemes = append(schemes, u.Scheme)
+ }
+
+ path = u.Host + u.Path
+ if !regexp.MustCompile(`^([A-Za-z0-9-]+)(.[A-Za-z0-9-]+)+(/[A-Za-z0-9-_.]+)+$`).MatchString(path) {
+ return nil, "", fmt.Errorf("%q is not a valid import path", path)
+ }
+
+ switch {
+ case ghregex.MatchString(path):
+ v := ghregex.FindStringSubmatch(path)
+ url := &url.URL{
+ Host: "github.com",
+ Path: v[2],
+ }
+ repo, err := Gitrepo(url, insecure, schemes...)
+ return repo, v[0][len(v[1]):], err
+ case bbregex.MatchString(path):
+ v := bbregex.FindStringSubmatch(path)
+ url := &url.URL{
+ Host: "bitbucket.org",
+ Path: v[2],
+ }
+ repo, err := Gitrepo(url, insecure, schemes...)
+ if err == nil {
+ return repo, v[0][len(v[1]):], nil
+ }
+ repo, err = Hgrepo(url, insecure)
+ if err == nil {
+ return repo, v[0][len(v[1]):], nil
+ }
+ return nil, "", fmt.Errorf("unknown repository type")
+ case gcregex.MatchString(path):
+ v := gcregex.FindStringSubmatch(path)
+ url := &url.URL{
+ Host: "code.google.com",
+ Path: "p/" + v[2],
+ }
+ repo, err := Hgrepo(url, insecure, schemes...)
+ if err == nil {
+ return repo, v[0][len(v[1]):], nil
+ }
+ repo, err = Gitrepo(url, insecure, schemes...)
+ if err == nil {
+ return repo, v[0][len(v[1]):], nil
+ }
+ return nil, "", fmt.Errorf("unknown repository type")
+ case lpregex.MatchString(path):
+ v := lpregex.FindStringSubmatch(path)
+ v = append(v, "", "")
+ if v[2] == "" {
+ // launchpad.net/project"
+ repo, err := Bzrrepo(fmt.Sprintf("https://launchpad.net/%v", v[1]))
+ return repo, "", err
+ }
+ // launchpad.net/project/series"
+ repo, err := Bzrrepo(fmt.Sprintf("https://launchpad.net/%s/%s", v[1], v[2]))
+ return repo, v[3], err
+ }
+
+ // try the general syntax
+ if genericre.MatchString(path) {
+ v := genericre.FindStringSubmatch(path)
+ switch v[5] {
+ case "git":
+ x := strings.SplitN(v[1], "/", 2)
+ url := &url.URL{
+ Host: x[0],
+ Path: x[1],
+ }
+ repo, err := Gitrepo(url, insecure, schemes...)
+ return repo, v[6], err
+ case "hg":
+ x := strings.SplitN(v[1], "/", 2)
+ url := &url.URL{
+ Host: x[0],
+ Path: x[1],
+ }
+ repo, err := Hgrepo(url, insecure, schemes...)
+ return repo, v[6], err
+ case "bzr":
+ repo, err := Bzrrepo("https://" + v[1])
+ return repo, v[6], err
+ default:
+ return nil, "", fmt.Errorf("unknown repository type: %q", v[5])
+
+ }
+ }
+
+ // no idea, try to resolve as a vanity import
+ importpath, vcs, reporoot, err := ParseMetadata(path, insecure)
+ if err != nil {
+ return nil, "", err
+ }
+ u, err = url.Parse(reporoot)
+ if err != nil {
+ return nil, "", err
+ }
+ extra := path[len(importpath):]
+ switch vcs {
+ case "git":
+ u.Path = u.Path[1:]
+ repo, err := Gitrepo(u, insecure, u.Scheme)
+ return repo, extra, err
+ case "hg":
+ u.Path = u.Path[1:]
+ repo, err := Hgrepo(u, insecure, u.Scheme)
+ return repo, extra, err
+ case "bzr":
+ repo, err := Bzrrepo(reporoot)
+ return repo, extra, err
+ default:
+ return nil, "", fmt.Errorf("unknown repository type: %q", vcs)
+ }
+}
+
+// Gitrepo returns a RemoteRepo representing a remote git repository.
+func Gitrepo(url *url.URL, insecure bool, schemes ...string) (RemoteRepo, error) {
+ if len(schemes) == 0 {
+ schemes = []string{"https", "git", "ssh", "http"}
+ }
+ u, err := probeGitUrl(url, insecure, schemes)
+ if err != nil {
+ return nil, err
+ }
+ return &gitrepo{
+ url: u,
+ }, nil
+}
+
+func probeGitUrl(u *url.URL, insecure bool, schemes []string) (string, error) {
+ git := func(url *url.URL) error {
+ out, err := run("git", "ls-remote", url.String(), "HEAD")
+ if err != nil {
+ return err
+ }
+
+ if !bytes.Contains(out, []byte("HEAD")) {
+ return fmt.Errorf("not a git repo")
+ }
+ return nil
+ }
+ return probe(git, u, insecure, schemes...)
+}
+
+func probeHgUrl(u *url.URL, insecure bool, schemes []string) (string, error) {
+ hg := func(url *url.URL) error {
+ _, err := run("hg", "identify", url.String())
+ return err
+ }
+ return probe(hg, u, insecure, schemes...)
+}
+
+func probeBzrUrl(u string) error {
+ bzr := func(url *url.URL) error {
+ _, err := run("bzr", "info", url.String())
+ return err
+ }
+ url, err := url.Parse(u)
+ if err != nil {
+ return err
+ }
+ _, err = probe(bzr, url, false, "https")
+ return err
+}
+
+// probe calls the supplied vcs function to probe a variety of url constructions.
+// If vcs returns non nil, it is assumed that the url is not a valid repo.
+func probe(vcs func(*url.URL) error, url *url.URL, insecure bool, schemes ...string) (string, error) {
+ var unsuccessful []string
+ for _, scheme := range schemes {
+
+ // make copy of url and apply scheme
+ url := *url
+ url.Scheme = scheme
+
+ switch url.Scheme {
+ case "https", "ssh":
+ if err := vcs(&url); err == nil {
+ return url.String(), nil
+ }
+ case "http", "git":
+ if !insecure {
+ gb.Infof("skipping insecure protocol: %s", url.String())
+ continue
+ }
+ if err := vcs(&url); err == nil {
+ return url.String(), nil
+ }
+ default:
+ return "", fmt.Errorf("unsupported scheme: %v", url.Scheme)
+ }
+ unsuccessful = append(unsuccessful, url.String())
+ }
+ return "", fmt.Errorf("vcs probe failed, tried: %s", strings.Join(unsuccessful, ","))
+}
+
+// gitrepo is a git RemoteRepo.
+type gitrepo struct {
+
+ // remote repository url, see man 1 git-clone
+ url string
+}
+
+func (g *gitrepo) URL() string {
+ return g.url
+}
+
+// Checkout fetchs the remote branch, tag, or revision. If more than one is
+// supplied, an error is returned. If the branch is blank,
+// then the default remote branch will be used. If the branch is "HEAD", an
+// error will be returned.
+func (g *gitrepo) Checkout(branch, tag, revision string) (WorkingCopy, error) {
+ if branch == "HEAD" {
+ return nil, fmt.Errorf("cannot update %q as it has been previously fetched with -tag or -revision. Please use gb vendor delete then fetch again.", g.url)
+ }
+ if !atMostOne(branch, tag, revision) {
+ return nil, fmt.Errorf("only one of branch, tag or revision may be supplied")
+ }
+ dir, err := mktmp()
+ if err != nil {
+ return nil, err
+ }
+ wc := workingcopy{
+ path: dir,
+ }
+
+ args := []string{
+ "clone",
+ "-q", // silence progress report to stderr
+ g.url,
+ dir,
+ }
+ if branch != "" {
+ args = append(args, "--branch", branch)
+ }
+
+ if _, err := run("git", args...); err != nil {
+ wc.Destroy()
+ return nil, err
+ }
+
+ if revision != "" || tag != "" {
+ if err := runOutPath(os.Stderr, dir, "git", "checkout", "-q", oneOf(revision, tag)); err != nil {
+ wc.Destroy()
+ return nil, err
+ }
+ }
+
+ return &GitClone{wc}, nil
+}
+
+type workingcopy struct {
+ path string
+}
+
+func (w workingcopy) Dir() string { return w.path }
+
+func (w workingcopy) Destroy() error {
+ if err := RemoveAll(w.path); err != nil {
+ return err
+ }
+ parent := filepath.Dir(w.path)
+ return cleanPath(parent)
+}
+
+// GitClone is a git WorkingCopy.
+type GitClone struct {
+ workingcopy
+}
+
+func (g *GitClone) Revision() (string, error) {
+ rev, err := runPath(g.path, "git", "rev-parse", "HEAD")
+ return strings.TrimSpace(string(rev)), err
+}
+
+func (g *GitClone) Branch() (string, error) {
+ rev, err := runPath(g.path, "git", "rev-parse", "--abbrev-ref", "HEAD")
+ return strings.TrimSpace(string(rev)), err
+}
+
+// Hgrepo returns a RemoteRepo representing a remote git repository.
+func Hgrepo(u *url.URL, insecure bool, schemes ...string) (RemoteRepo, error) {
+ if len(schemes) == 0 {
+ schemes = []string{"https", "http"}
+ }
+ url, err := probeHgUrl(u, insecure, schemes)
+ if err != nil {
+ return nil, err
+ }
+ return &hgrepo{
+ url: url,
+ }, nil
+}
+
+// hgrepo is a Mercurial repo.
+type hgrepo struct {
+
+ // remote repository url, see man 1 hg
+ url string
+}
+
+func (h *hgrepo) URL() string { return h.url }
+
+func (h *hgrepo) Checkout(branch, tag, revision string) (WorkingCopy, error) {
+ if !atMostOne(tag, revision) {
+ return nil, fmt.Errorf("only one of tag or revision may be supplied")
+ }
+ dir, err := mktmp()
+ if err != nil {
+ return nil, err
+ }
+ args := []string{
+ "clone",
+ h.url,
+ dir,
+ }
+
+ if branch != "" {
+ args = append(args, "--branch", branch)
+ }
+ if err := runOut(os.Stderr, "hg", args...); err != nil {
+ RemoveAll(dir)
+ return nil, err
+ }
+ if revision != "" {
+ if err := runOut(os.Stderr, "hg", "--cwd", dir, "update", "-r", revision); err != nil {
+ RemoveAll(dir)
+ return nil, err
+ }
+ }
+
+ return &HgClone{
+ workingcopy{
+ path: dir,
+ },
+ }, nil
+}
+
+// HgClone is a mercurial WorkingCopy.
+type HgClone struct {
+ workingcopy
+}
+
+func (h *HgClone) Revision() (string, error) {
+ rev, err := run("hg", "--cwd", h.path, "id", "-i")
+ return strings.TrimSpace(string(rev)), err
+}
+
+func (h *HgClone) Branch() (string, error) {
+ rev, err := run("hg", "--cwd", h.path, "branch")
+ return strings.TrimSpace(string(rev)), err
+}
+
+// Bzrrepo returns a RemoteRepo representing a remote bzr repository.
+func Bzrrepo(url string) (RemoteRepo, error) {
+ if err := probeBzrUrl(url); err != nil {
+ return nil, err
+ }
+ return &bzrrepo{
+ url: url,
+ }, nil
+}
+
+// bzrrepo is a bzr RemoteRepo.
+type bzrrepo struct {
+
+ // remote repository url
+ url string
+}
+
+func (b *bzrrepo) URL() string {
+ return b.url
+}
+
+func (b *bzrrepo) Checkout(branch, tag, revision string) (WorkingCopy, error) {
+ if !atMostOne(tag, revision) {
+ return nil, fmt.Errorf("only one of tag or revision may be supplied")
+ }
+ dir, err := mktmp()
+ if err != nil {
+ return nil, err
+ }
+ wc := filepath.Join(dir, "wc")
+ if err := runOut(os.Stderr, "bzr", "branch", b.url, wc); err != nil {
+ RemoveAll(dir)
+ return nil, err
+ }
+
+ return &BzrClone{
+ workingcopy{
+ path: wc,
+ },
+ }, nil
+}
+
+// BzrClone is a bazaar WorkingCopy.
+type BzrClone struct {
+ workingcopy
+}
+
+func (b *BzrClone) Revision() (string, error) {
+ return "1", nil
+}
+
+func (b *BzrClone) Branch() (string, error) {
+ return "master", nil
+}
+
+func cleanPath(path string) error {
+ if files, _ := ioutil.ReadDir(path); len(files) > 0 || filepath.Base(path) == "src" {
+ return nil
+ }
+ parent := filepath.Dir(path)
+ if err := RemoveAll(path); err != nil {
+ return err
+ }
+ return cleanPath(parent)
+}
+
+func mkdir(path string) error {
+ return os.MkdirAll(path, 0755)
+}
+
+func mktmp() (string, error) {
+ return ioutil.TempDir("", "gb-vendor-")
+}
+
+func run(c string, args ...string) ([]byte, error) {
+ var buf bytes.Buffer
+ err := runOut(&buf, c, args...)
+ return buf.Bytes(), err
+}
+
+func runOut(w io.Writer, c string, args ...string) error {
+ cmd := exec.Command(c, args...)
+ cmd.Stdout = w
+ cmd.Stderr = os.Stderr
+ return cmd.Run()
+}
+
+func runPath(path string, c string, args ...string) ([]byte, error) {
+ var buf bytes.Buffer
+ err := runOutPath(&buf, path, c, args...)
+ return buf.Bytes(), err
+}
+
+func runOutPath(w io.Writer, path string, c string, args ...string) error {
+ cmd := exec.Command(c, args...)
+ cmd.Dir = path
+ cmd.Stdout = w
+ cmd.Stderr = os.Stderr
+ return cmd.Run()
+}
+
+// atMostOne returns true if no more than one string supplied is not empty.
+func atMostOne(args ...string) bool {
+ var c int
+ for _, arg := range args {
+ if arg != "" {
+ c++
+ }
+ }
+ return c < 2
+}
+
+// oneof returns the first non empty string
+func oneOf(args ...string) string {
+ for _, arg := range args {
+ if arg != "" {
+ return arg
+ }
+ }
+ return ""
+}
diff --git a/gbvendor/repo_test.go b/gbvendor/repo_test.go
new file mode 100644
index 0000000..03c5107
--- /dev/null
+++ b/gbvendor/repo_test.go
@@ -0,0 +1,139 @@
+package vendor
+
+import (
+ "fmt"
+ "reflect"
+ "testing"
+)
+
+func TestDeduceRemoteRepo(t *testing.T) {
+ if testing.Short() {
+ t.Skipf("skipping network tests in -short mode")
+ }
+ tests := []struct {
+ path string
+ want RemoteRepo
+ extra string
+ err error
+ insecure bool
+ }{{
+ path: "",
+ err: fmt.Errorf(`"" is not a valid import path`),
+ }, {
+ path: "corporate",
+ err: fmt.Errorf(`"corporate" is not a valid import path`),
+ }, {
+ path: "github.com/cznic/b",
+ want: &gitrepo{
+ url: "https://github.com/cznic/b",
+ },
+ }, {
+ path: "github.com/pkg/sftp",
+ want: &gitrepo{
+ url: "https://github.com/pkg/sftp",
+ },
+ }, {
+ path: "github.com/pkg/sftp/examples/gsftp",
+ want: &gitrepo{
+ url: "https://github.com/pkg/sftp",
+ },
+ extra: "/examples/gsftp",
+ }, {
+ path: "github.com/coreos/go-etcd",
+ want: &gitrepo{
+ url: "https://github.com/coreos/go-etcd",
+ },
+ }, {
+ path: "bitbucket.org/davecheney/gitrepo/cmd/main",
+ want: &gitrepo{
+ url: "https://bitbucket.org/davecheney/gitrepo",
+ },
+ extra: "/cmd/main",
+ }, {
+ path: "bitbucket.org/davecheney/hgrepo/cmd/main",
+ want: &hgrepo{
+ url: "https://bitbucket.org/davecheney/hgrepo",
+ },
+ extra: "/cmd/main",
+ }, {
+ path: "code.google.com/p/goauth2/oauth",
+ want: &hgrepo{
+ url: "https://code.google.com/p/goauth2",
+ },
+ extra: "/oauth",
+ }, {
+ path: "code.google.com/p/gami",
+ want: &gitrepo{
+ url: "https://code.google.com/p/gami",
+ },
+ }, {
+ path: "git.eclipse.org/gitroot/paho/org.eclipse.paho.mqtt.golang.git",
+ want: &gitrepo{
+ url: "https://git.eclipse.org/gitroot/paho/org.eclipse.paho.mqtt.golang.git",
+ },
+ }, {
+ path: "git.apache.org/thrift.git/lib/go/thrift",
+ want: &gitrepo{
+ url: "https://git.apache.org/thrift.git",
+ },
+ extra: "/lib/go/thrift",
+ }, {
+ path: "gopkg.in/check.v1",
+ want: &gitrepo{
+ url: "https://gopkg.in/check.v1",
+ },
+ extra: "",
+ }, {
+ path: "golang.org/x/tools/go/vcs",
+ want: &gitrepo{
+ url: "https://go.googlesource.com/tools",
+ },
+ extra: "/go/vcs",
+ }, {
+ path: "labix.org/v2/mgo",
+ want: &bzrrepo{
+ url: "https://launchpad.net/mgo/v2",
+ },
+ insecure: true,
+ }, {
+ path: "launchpad.net/gnuflag",
+ want: &bzrrepo{
+ url: "https://launchpad.net/gnuflag",
+ },
+ }, {
+ path: "https://github.com/pkg/sftp",
+ want: &gitrepo{
+ url: "https://github.com/pkg/sftp",
+ },
+ }, {
+ path: "git://github.com/pkg/sftp",
+ want: &gitrepo{
+ url: "git://github.com/pkg/sftp",
+ },
+ insecure: true,
+ }, {
+ path: "code.google.com/p/google-api-go-client/bigquery/v2",
+ want: &hgrepo{
+ url: "https://code.google.com/p/google-api-go-client",
+ },
+ extra: "/bigquery/v2",
+ }, {
+ path: "code.google.com/p/go-sqlite/go1/sqlite3",
+ want: &hgrepo{
+ url: "https://code.google.com/p/go-sqlite",
+ },
+ extra: "/go1/sqlite3",
+ }}
+
+ for _, tt := range tests {
+ t.Logf("DeduceRemoteRepo(%q, %v)", tt.path, tt.insecure)
+ got, extra, err := DeduceRemoteRepo(tt.path, tt.insecure)
+ if !reflect.DeepEqual(err, tt.err) {
+ t.Errorf("DeduceRemoteRepo(%q): want err: %v, got err: %v", tt.path, tt.err, err)
+ continue
+ }
+ if !reflect.DeepEqual(got, tt.want) || extra != tt.extra {
+ t.Errorf("DeduceRemoteRepo(%q): want %#v, %v, got %#v, %v", tt.path, tt.want, tt.extra, got, extra)
+ }
+ }
+}
diff --git a/gbvendor/stdlib.go b/gbvendor/stdlib.go
new file mode 100644
index 0000000..f297561
--- /dev/null
+++ b/gbvendor/stdlib.go
@@ -0,0 +1,138 @@
+package vendor
+
+// packages from the standard lib. They are excluded
+// from the package map.
+var stdlib = map[string]bool{
+ "C": true,
+ "archive/tar": true,
+ "archive/zip": true,
+ "bufio": true,
+ "bytes": true,
+ "compress/bzip2": true,
+ "compress/flate": true,
+ "compress/gzip": true,
+ "compress/lzw": true,
+ "compress/zlib": true,
+ "container/heap": true,
+ "container/list": true,
+ "container/ring": true,
+ "crypto": true,
+ "crypto/aes": true,
+ "crypto/cipher": true,
+ "crypto/des": true,
+ "crypto/dsa": true,
+ "crypto/ecdsa": true,
+ "crypto/elliptic": true,
+ "crypto/hmac": true,
+ "crypto/md5": true,
+ "crypto/rand": true,
+ "crypto/rc4": true,
+ "crypto/rsa": true,
+ "crypto/sha1": true,
+ "crypto/sha256": true,
+ "crypto/sha512": true,
+ "crypto/subtle": true,
+ "crypto/tls": true,
+ "crypto/x509": true,
+ "crypto/x509/pkix": true,
+ "database/sql": true,
+ "database/sql/driver": true,
+ "debug/dwarf": true,
+ "debug/elf": true,
+ "debug/gosym": true,
+ "debug/macho": true,
+ "debug/pe": true,
+ "encoding": true,
+ "encoding/ascii85": true,
+ "encoding/asn1": true,
+ "encoding/base32": true,
+ "encoding/base64": true,
+ "encoding/binary": true,
+ "encoding/csv": true,
+ "encoding/gob": true,
+ "encoding/hex": true,
+ "encoding/json": true,
+ "encoding/pem": true,
+ "encoding/xml": true,
+ "errors": true,
+ "expvar": true,
+ "flag": true,
+ "fmt": true,
+ "go/ast": true,
+ "go/build": true,
+ "go/doc": true,
+ "go/format": true,
+ "go/parser": true,
+ "go/printer": true,
+ "go/scanner": true,
+ "go/token": true,
+ "hash": true,
+ "hash/adler32": true,
+ "hash/crc32": true,
+ "hash/crc64": true,
+ "hash/fnv": true,
+ "html": true,
+ "html/template": true,
+ "image": true,
+ "image/color": true,
+ "image/draw": true,
+ "image/gif": true,
+ "image/jpeg": true,
+ "image/png": true,
+ "index/suffixarray": true,
+ "io": true,
+ "io/ioutil": true,
+ "log": true,
+ "log/syslog": true,
+ "math": true,
+ "math/big": true,
+ "math/cmplx": true,
+ "math/rand": true,
+ "mime": true,
+ "mime/multipart": true,
+ "net": true,
+ "net/http": true,
+ "net/http/cgi": true,
+ "net/http/cookiejar": true,
+ "net/http/fcgi": true,
+ "net/http/httptest": true,
+ "net/http/httputil": true,
+ "net/http/pprof": true,
+ "net/mail": true,
+ "net/rpc": true,
+ "net/rpc/jsonrpc": true,
+ "net/smtp": true,
+ "net/textproto": true,
+ "net/url": true,
+ "os": true,
+ "os/exec": true,
+ "os/signal": true,
+ "os/user": true,
+ "path": true,
+ "path/filepath": true,
+ "reflect": true,
+ "regexp": true,
+ "regexp/syntax": true,
+ "runtime": true,
+ "runtime/cgo": true,
+ "runtime/debug": true,
+ "runtime/pprof": true,
+ "sort": true,
+ "strconv": true,
+ "strings": true,
+ "sync": true,
+ "sync/atomic": true,
+ "syscall": true,
+ "testing": true,
+ "testing/iotest": true,
+ "testing/quick": true,
+ "text/scanner": true,
+ "text/tabwriter": true,
+ "text/template": true,
+ "text/template/parse": true,
+ "time": true,
+ "unicode": true,
+ "unicode/utf16": true,
+ "unicode/utf8": true,
+ "unsafe": true,
+}
diff --git a/gbvendor/stringset.go b/gbvendor/stringset.go
new file mode 100644
index 0000000..007eae5
--- /dev/null
+++ b/gbvendor/stringset.go
@@ -0,0 +1,52 @@
+package vendor
+
+// union returns the union of a and b.
+func union(a, b map[string]bool) map[string]bool {
+ r := make(map[string]bool)
+ for k := range a {
+ r[k] = true
+ }
+ for k := range b {
+ r[k] = true
+ }
+ return r
+}
+
+// intersection returns the intersection of a and b.
+func intersection(a, b map[string]bool) map[string]bool {
+ r := make(map[string]bool)
+ for k := range a {
+ if b[k] {
+ r[k] = true
+ }
+ }
+ return r
+}
+
+// difference returns the symetric difference of a and b.
+func difference(a, b map[string]bool) map[string]bool {
+ r := make(map[string]bool)
+ for k := range a {
+ if !b[k] {
+ r[k] = true
+ }
+ }
+ for k := range b {
+ if !a[k] {
+ r[k] = true
+ }
+ }
+ return r
+}
+
+// contains returns true if a contains all the elements in s.
+func contains(a map[string]bool, s ...string) bool {
+ var r bool
+ for _, e := range s {
+ if !a[e] {
+ return false
+ }
+ r = true
+ }
+ return r
+}
diff --git a/gbvendor/stringset_test.go b/gbvendor/stringset_test.go
new file mode 100644
index 0000000..d8781a4
--- /dev/null
+++ b/gbvendor/stringset_test.go
@@ -0,0 +1,147 @@
+package vendor
+
+import "testing"
+import "reflect"
+
+func set(args ...string) map[string]bool {
+ r := make(map[string]bool)
+ for _, a := range args {
+ r[a] = true
+ }
+ return r
+}
+
+func TestUnion(t *testing.T) {
+ tests := []struct {
+ a, b map[string]bool
+ want map[string]bool
+ }{{
+ a: nil, b: nil,
+ want: set(),
+ }, {
+ a: nil, b: set("b"),
+ want: set("b"),
+ }, {
+ a: set("a"), b: nil,
+ want: set("a"),
+ }, {
+ a: set("a"), b: set("b"),
+ want: set("b", "a"),
+ }, {
+ a: set("c"), b: set("c"),
+ want: set("c"),
+ }}
+
+ for _, tt := range tests {
+ got := union(tt.a, tt.b)
+ if !reflect.DeepEqual(tt.want, got) {
+ t.Errorf("union(%v, %v) want: %v, got %v", tt.a, tt.b, tt.want, got)
+ }
+ }
+}
+
+func TestIntersection(t *testing.T) {
+ tests := []struct {
+ a, b map[string]bool
+ want map[string]bool
+ }{{
+ a: nil, b: nil,
+ want: set(),
+ }, {
+ a: nil, b: set("b"),
+ want: set(),
+ }, {
+ a: set("a"), b: nil,
+ want: set(),
+ }, {
+ a: set("a"), b: set("b"),
+ want: set(),
+ }, {
+ a: set("c"), b: set("c"),
+ want: set("c"),
+ }, {
+ a: set("a", "c"), b: set("b", "c"),
+ want: set("c"),
+ }}
+
+ for _, tt := range tests {
+ got := intersection(tt.a, tt.b)
+ if !reflect.DeepEqual(tt.want, got) {
+ t.Errorf("intersection(%v, %v) want: %v, got %v", tt.a, tt.b, tt.want, got)
+ }
+ }
+}
+
+func TestDifference(t *testing.T) {
+ tests := []struct {
+ a, b map[string]bool
+ want map[string]bool
+ }{{
+ a: nil, b: nil,
+ want: set(),
+ }, {
+ a: nil, b: set("b"),
+ want: set("b"),
+ }, {
+ a: set("a"), b: nil,
+ want: set("a"),
+ }, {
+ a: set("a"), b: set("b"),
+ want: set("a", "b"),
+ }, {
+ a: set("c"), b: set("c"),
+ want: set(),
+ }, {
+ a: set("a", "c"), b: set("b", "c"),
+ want: set("a", "b"),
+ }}
+
+ for _, tt := range tests {
+ got := difference(tt.a, tt.b)
+ if !reflect.DeepEqual(tt.want, got) {
+ t.Errorf("difference(%v, %v) want: %v, got %v", tt.a, tt.b, tt.want, got)
+ }
+ }
+}
+
+func TestContains(t *testing.T) {
+ tests := []struct {
+ a map[string]bool
+ s []string
+ want bool
+ }{{
+ a: nil, s: nil,
+ want: false,
+ }, {
+ a: set("a"), s: nil,
+ want: false,
+ }, {
+ a: set("a"), s: []string{"a"},
+ want: true,
+ }, {
+ a: set("a"), s: []string{"b"},
+ want: false,
+ }, {
+ a: set("a", "b"), s: []string{"b"},
+ want: true,
+ }, {
+ a: set("a"), s: []string{"a", "b"},
+ want: false,
+ }, {
+ a: set("a", "b", "c"), s: []string{"a", "b"},
+ want: true,
+ }, {
+ a: set("a", "b", "c"), s: []string{"x", "b"},
+ want: false,
+ }, {
+ a: set("a", "b", "c"), s: []string{"b", "c", "d"},
+ want: false,
+ }}
+
+ for _, tt := range tests {
+ got := contains(tt.a, tt.s...)
+ if !reflect.DeepEqual(tt.want, got) {
+ t.Errorf("contains(%v, %v) want: %v, got %v", tt.a, tt.s, tt.want, got)
+ }
+ }
+}
diff --git a/help.go b/help.go
new file mode 100644
index 0000000..a0c8856
--- /dev/null
+++ b/help.go
@@ -0,0 +1,117 @@
+package main
+
+import (
+ "bufio"
+ "bytes"
+ "fmt"
+ "io"
+ "os"
+ "strings"
+ "text/template"
+ "unicode"
+ "unicode/utf8"
+)
+
+var helpTemplate = `usage: gvt {{.UsageLine}}
+
+{{.Long | trim}}
+`
+
+// help implements the 'help' command.
+func help(args []string) {
+ if len(args) == 0 {
+ printUsage(os.Stdout)
+ return
+ }
+ if len(args) != 1 {
+ fmt.Fprintf(os.Stderr, "usage: gvt help command\n\nToo many arguments given.\n")
+ os.Exit(2)
+ }
+
+ arg := args[0]
+
+ // 'gvt help documentation' generates alldocs.go.
+ if arg == "documentation" {
+ var u bytes.Buffer
+ printUsage(&u)
+ f, _ := os.Create("alldocs.go")
+ tmpl(f, documentationTemplate, struct {
+ Usage string
+ Commands []*Command
+ }{
+ u.String(),
+ commands,
+ })
+ f.Close()
+ return
+ }
+
+ for _, cmd := range commands {
+ if cmd.Name == arg {
+ tmpl(os.Stdout, helpTemplate, cmd)
+ // not exit 2: succeeded at 'gb help cmd'.
+ return
+ }
+ }
+
+ fmt.Fprintf(os.Stderr, "Unknown help topic %#q. Run 'gb help'.\n", arg)
+ os.Exit(2) // failed at 'gb help cmd'
+}
+
+var usageTemplate = `gvt, a simple go vendoring tool based on gb-vendor.
+
+Usage:
+ gvt command [arguments]
+
+The commands are:
+{{range .}}
+ {{.Name | printf "%-11s"}} {{.Short}}{{end}}
+
+Use "gvt help [command]" for more information about a command.
+`
+
+var documentationTemplate = `// DO NOT EDIT THIS FILE.
+//go:generate gvt help documentation
+
+/*
+{{ .Usage }}
+
+{{range .Commands}}{{if .Short}}## {{.Short | capitalize}}
+{{end}}
+Usage:
+ gvt {{.UsageLine}}
+
+{{.Long | trim}}
+
+{{end}}*/
+package main
+`
+
+// tmpl executes the given template text on data, writing the result to w.
+func tmpl(w io.Writer, text string, data interface{}) {
+ t := template.New("top")
+ t.Funcs(template.FuncMap{"trim": strings.TrimSpace, "capitalize": capitalize})
+ template.Must(t.Parse(text))
+ if err := t.Execute(w, data); err != nil {
+ panic(err)
+ }
+}
+
+func capitalize(s string) string {
+ if s == "" {
+ return s
+ }
+ r, n := utf8.DecodeRuneInString(s)
+ return string(unicode.ToTitle(r)) + s[n:]
+}
+
+func printUsage(w io.Writer) {
+ bw := bufio.NewWriter(w)
+ tmpl(bw, usageTemplate, commands)
+ bw.Flush()
+}
+
+func usage() {
+ printUsage(os.Stderr)
+ os.Exit(2)
+}
diff --git a/list.go b/list.go
new file mode 100644
index 0000000..e3113d9
--- /dev/null
+++ b/list.go
@@ -0,0 +1,54 @@
+package main
+
+import (
+ "flag"
+ "fmt"
+ "html/template"
+ "os"
+ "text/tabwriter"
+
+ "github.com/FiloSottile/gvt/gbvendor"
+)
+
+var (
+ format string
+)
+
+func addListFlags(fs *flag.FlagSet) {
+ fs.StringVar(&format, "f", "{{.Importpath}}\t{{.Repository}}{{.Path}}\t{{.Branch}}\t{{.Revision}}", "format template")
+}
+
+var cmdList = &Command{
+ Name: "list",
+ UsageLine: "list [-f format]",
+ Short: "lists dependencies, one per line",
+ Long: `list formats the contents of the manifest file.
+
+The output
+
+Flags:
+ -f
+ controls the template used for printing each manifest entry. If not supplied
+ the default value is "{{.Importpath}}\t{{.Repository}}{{.Path}}\t{{.Branch}}\t{{.Revision}}"
+
+`,
+ Run: func(args []string) error {
+ m, err := vendor.ReadManifest(manifestFile())
+ if err != nil {
+ return fmt.Errorf("could not load manifest: %v", err)
+ }
+ tmpl, err := template.New("list").Parse(format)
+ if err != nil {
+ return fmt.Errorf("unable to parse template %q: %v", format, err)
+ }
+ w := tabwriter.NewWriter(os.Stdout, 1, 2, 1, ' ', 0)
+ for _, dep := range m.Dependencies {
+ if err := tmpl.Execute(w, dep); err != nil {
+ return fmt.Errorf("unable to execute template: %v", err)
+ }
+ fmt.Fprintln(w)
+ }
+ return w.Flush()
+ },
+ AddFlags: addListFlags,
+}
diff --git a/main.go b/main.go
new file mode 100644
index 0000000..89a8dc6
--- /dev/null
+++ b/main.go
@@ -0,0 +1,81 @@
+package main
+
+import (
+ "flag"
+ "log"
+ "os"
+ "path/filepath"
+)
+
+var fs = flag.NewFlagSet(os.Args[0], flag.ExitOnError)
+
+func init() {
+ fs.Usage = func() {
+ printUsage(os.Stderr)
+ os.Exit(2)
+ }
+}
+
+type Command struct {
+ Name string
+ UsageLine string
+ Short string
+ Long string
+ Run func(args []string) error
+ AddFlags func(fs *flag.FlagSet)
+}
+
+var commands = []*Command{
+ cmdFetch,
+ cmdUpdate,
+ cmdList,
+ cmdDelete,
+}
+
+func main() {
+ args := os.Args[1:]
+
+ switch {
+ case len(args) < 1, args[0] == "-h", args[0] == "-help":
+ fs.Usage()
+ os.Exit(1)
+ case args[0] == "help":
+ help(args[1:])
+ return
+ }
+
+ for _, command := range commands {
+ if command.Name == args[0] {
+
+ // add extra flags if necessary
+ if command.AddFlags != nil {
+ command.AddFlags(fs)
+ }
+
+ if err := fs.Parse(args[1:]); err != nil {
+ log.Fatalf("could not parse flags: %v", err)
+ }
+ args = fs.Args() // reset args to the leftovers from fs.Parse
+
+ if err := command.Run(args); err != nil {
+ log.Fatalf("command %q failed: %v", command.Name, err)
+ }
+ return
+ }
+ }
+ log.Fatalf("unknown command %q ", args[0])
+}
+
+const manifestfile = "manifest"
+
+func vendorDir() string {
+ wd, err := os.Getwd()
+ if err != nil {
+ log.Fatal(err)
+ }
+ return filepath.Join(wd, "vendor")
+}
+
+func manifestFile() string {
+ return filepath.Join(vendorDir(), manifestfile)
+}
diff --git a/update.go b/update.go
new file mode 100644
index 0000000..86d0fb1
--- /dev/null
+++ b/update.go
@@ -0,0 +1,128 @@
+package main
+
+import (
+ "flag"
+ "fmt"
+ "path/filepath"
+
+ "github.com/FiloSottile/gvt/gbvendor"
+)
+
+var (
+ updateAll bool // update all dependencies
+)
+
+func addUpdateFlags(fs *flag.FlagSet) {
+ fs.BoolVar(&updateAll, "all", false, "update all dependencies")
+ fs.BoolVar(&insecure, "precaire", false, "allow the use of insecure protocols")
+}
+
+var cmdUpdate = &Command{
+ Name: "update",
+ UsageLine: "update [-all] import",
+ Short: "update a local dependency",
+ Long: `update will replaces the source with the latest available from the head of the master branch.
+
+Updating from one copy of a dependency to another comes with several restrictions.
+The first is you can only update to the head of the branch your dependency was vendored from, switching branches is not supported.
+The second restriction is if you have used -tag or -revision while vendoring a dependency, your dependency is "headless"
+(to borrow a term from git) and cannot be updated.
+
+To update across branches, or from one tag/revision to another, you must first use delete to remove the dependency, then
+fetch [-tag | -revision | -branch ] [-precaire] to replace it.
+
+Flags:
+ -all
+ will update all dependencies in the manifest, otherwise only the dependency supplied.
+ -precaire
+ allow the use of insecure protocols.
+
+`,
+ Run: func(args []string) error {
+ if len(args) != 1 && !updateAll {
+ return fmt.Errorf("update: import path or --all flag is missing")
+ } else if len(args) == 1 && updateAll {
+ return fmt.Errorf("update: you cannot specify path and --all flag at once")
+ }
+
+ m, err := vendor.ReadManifest(manifestFile())
+ if err != nil {
+ return fmt.Errorf("could not load manifest: %v", err)
+ }
+
+ var dependencies []vendor.Dependency
+ if updateAll {
+ dependencies = make([]vendor.Dependency, len(m.Dependencies))
+ copy(dependencies, m.Dependencies)
+ } else {
+ p := args[0]
+ dependency, err := m.GetDependencyForImportpath(p)
+ if err != nil {
+ return fmt.Errorf("could not get dependency: %v", err)
+ }
+ dependencies = append(dependencies, dependency)
+ }
+
+ for _, d := range dependencies {
+ err = m.RemoveDependency(d)
+ if err != nil {
+ return fmt.Errorf("dependency could not be deleted from manifest: %v", err)
+ }
+
+ repo, extra, err := vendor.DeduceRemoteRepo(d.Importpath, insecure)
+ if err != nil {
+ return fmt.Errorf("could not determine repository for import %q", d.Importpath)
+ }
+
+ wc, err := repo.Checkout(d.Branch, "", "")
+ if err != nil {
+ return err
+ }
+
+ rev, err := wc.Revision()
+ if err != nil {
+ return err
+ }
+
+ branch, err := wc.Branch()
+ if err != nil {
+ return err
+ }
+
+ dep := vendor.Dependency{
+ Importpath: d.Importpath,
+ Repository: repo.URL(),
+ Revision: rev,
+ Branch: branch,
+ Path: extra,
+ }
+
+ if err := vendor.RemoveAll(filepath.Join(vendorDir(), filepath.FromSlash(d.Importpath))); err != nil {
+ // TODO(dfc) need to apply vendor.cleanpath here to remove intermediate directories.
+ return fmt.Errorf("dependency could not be deleted: %v", err)
+ }
+
+ dst := filepath.Join(vendorDir(), filepath.FromSlash(dep.Importpath))
+ src := filepath.Join(wc.Dir(), dep.Path)
+
+ if err := vendor.Copypath(dst, src); err != nil {
+ return err
+ }
+
+ if err := m.AddDependency(dep); err != nil {
+ return err
+ }
+
+ if err := vendor.WriteManifest(manifestFile(), m); err != nil {
+ return err
+ }
+
+ if err := wc.Destroy(); err != nil {
+ return err
+ }
+ }
+
+ return nil
+ },
+ AddFlags: addUpdateFlags,
+}
