go依赖包管理工具

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/wyy626562203/article/details/83717086

go依赖包管理工具

go依赖包管理工具列表：
https://github.com/golang/go/wiki/PackageManagementTools

manul

Manul是Go程序的一个vendor实用程序。

安装

manul可以使用go get获得：

go get github.com/kovetskiy/manul

软件包也可用于Ubuntu / Debian和Arch Linux。

这是个实用工具的原因是什么？

因为所有其他供应商实用程序都受到以下影响

• 一些包装go二进制和欺骗GOPATH env变量。您将拥有一个non-go-gettable的项目，需要额外的软件才能编译和运行;

• 有些人将依赖项的源代码复制到vendor目录中：

  • 使用GitHub搜索所有能找到任何东西，因为你会得到许多错误结果;
  • 更新依赖项将需要手动干预并将大量修改后的行直接提交到主仓库中;
  • 通过查看存储库，您将无法分辨项目正在使用的依赖项版本;你必须在与提交相关的vendor的附加模糊文件中保留版本。

• 各种架构问题：

  • 无法更新所有或特定的vendor依赖项;
  • 无法将vendor依赖项回滚到特定版本;
  • 无法删除未使用的vendor依赖项;
  • 无法锁定vendor依赖的版本。

解决方案

我们都喜欢git，它是一种非常强大的工具。为什么我们不使用它的功能来使用一个很棒的功能来vendoring依赖项，这个功能叫做git submodule？

使用git子模块，您将拥有每个依赖项的git存储库。它们可以通过git以与main项目相同的方式进行管理。

优点：

• 无需额外的软件来构建/运行Go项目;
• 无需额外的JSON / TOML / YAML文件来存储依赖项;
• 直接从远程origins更新vendor的依赖项;
• 回滚依赖关系的变化;
• GO-gettable

git子模块可能看起来像一个银色子弹，但手动工作仍然很笨拙。我们希望有一个强大而简单的界面来使用这种技术来销售依赖项。

manul可以为我们做。

使用

有GIF时谁需要文档？

首先，我们应该请求我们项目中的依赖项。 要做到这一点，只需使用-Q（查询）标志运行manul。 它将输出所有项目导入（依赖项），如下所示：

例如，我们有六个依赖项，让我们通过添加子模块锁定关键依赖项的版本：在我们的例子中它是zhash和blackfriday包。

对于锁定版本（安装依赖项），我们应该使用-I（install）标志并指定我们希望安装的依赖项：

安装完成后，我们可以使用标志-Q查看已vendor和非vendor的依赖项。 在上一步之后，我们应该看到git提交以及两个已经vendor的依赖项（zhash和blackfriday）：

让我们为剩余的依赖项安装子模块，走极限吧！ 只需使用标志-I运行manul而不指定任何依赖项，manul将安装所有检测到的依赖项并跳过已经vendor：
![在这里插入图片描述](https://img-blog.csdnimg.cn/20181104162654627.gif

哇，那太疯狂了！ 现在，要更新一些vendor的依赖项，例如docopt-go包，应使用标志-U和导入路径（github.com/docopt/docopt-go）调用manul：

manual可用于通过使用-R（remove）标志并指定依赖项导入路径来删除已vendor依赖项的特定子模块：

顺便说一下，manul可以使用-C（clean）标志检测并删除未使用的vendor依赖项：

manul还可以通过使用commit-ish来获取特定版本的依赖项，例如：

• manul -I golang.org/x/foo=34a235h1将在指定的提交时安装foo
• manul -U github.com/x/bar=this-tag会将其更新为此标签版本。

让我们总结一下：

• -I [ …] - 为指定或所有依赖项安装git子模块;
• -U [ …] - 更新指定的或所有已经出售的依赖项;
• -R [ …] - 删除指定或所有依赖项的git子模块;
• -Q [ …] - 列出所有使用的依赖项;
• -C - 检测并删除所有未使用的vendor依赖项的git子模块。

您可以通过传递-h或--help标志来查看类似的帮助消息。

govendor

go get -u github.com/kardianos/govendor

新用户请阅读常见问题解答

包开发人员应阅读开发人员指南。

有关高级概述，请阅读白皮书

使用go1.5 + vendor文件夹。 支持多个工作流程，单一工具。

• 使用govendor add/update复制$GOPATH中的现有依赖项。
• 如果忽略vendor/*/，请使用govendor sync恢复依赖项。
• 使用govendor fetch直接从远程引入新的依赖项或更新现有的依赖项。
• 使用govendor migrate从旧系统迁移。
• 支持Linux，OS X，Windows，可能还有其他所有。
• 支持git，hg，svn，bzr（必须安装在PATH上）。

注意

• 该项目必须在$ GOPATH / src内。
• 如果使用go1.5，请确保设置GO15VENDOREXPERIMENT = 1。

快速入门

另请参阅常见问题解答

# Setup your project.
cd "my project in GOPATH"
govendor init

# Add existing GOPATH files to vendor.
govendor add +external

# View your work.
govendor list

# Look at what is using a package
govendor list -v fmt

# Specify a specific version or revision to fetch
govendor fetch golang.org/x/net/context@a4bbce9fcae005b22ae5443f6af064d80a6f5a55
govendor fetch golang.org/x/net/context@v1   # Get latest v1.*.* tag or branch.
govendor fetch golang.org/x/net/context@=v1  # Get the tag or branch named "v1".

# Update a package to latest, given any prior version constraint
govendor fetch golang.org/x/net/context

# Format your repository only
govendor fmt +local

# Build everything in your repository only
govendor install +local

# Test your repository only
govendor test +local

子命令

init     创建 vendor 文件夹和 vendor.json 文件
list     列出已经存在的依赖包
add      从 $GOPATH 中添加依赖包，会加到 vendor.json
update   从 $GOPATH 升级依赖包
remove   从 vendor 文件夹删除依赖
status   列出本地丢失的、过期的和修改的package
fetch   从远端库增加新的，或者更新 vendor 文件中的依赖包
sync     Pull packages into vendor folder from remote repository with revisions
migrate  Move packages from a legacy tool to the vendor folder with metadata.
get     类似 go get，但是会把依赖包拷贝到 vendor 目录
license  List discovered licenses for the given status or import paths.
shell    Run a "shell" to make multiple sub-commands more efficient for large projects.

go tool commands that are wrapped:
      `+<status>` package selection may be used with them
    fmt, build, install, clean, test, vet, generate, tool

状态

包可以通过其“状态”指定。

状态	缩写状态	含义
+local	l	本地包，即项目自身的包组织
+external	e	外部包，即被 $GOPATH 管理，但不在 vendor 目录下
+vendor	v	已被 govendor 管理，即在 vendor 目录下
+std	s	标准库中的包
+excluded	x	从vendor文件中排除的外部依赖包
+unused	u	未使用的包，即包在 vendor 目录下，但项目并没有用到
+missing	m	代码引用了依赖包，但该包并没有找到
+program	p	主程序包，意味着可以编译为执行文件
+outside		外部包和缺失的包
+all		所有的包

状态可以通过其首字母引用。

• +std与+s相同
• +external 、+ext、+e相同
• +excluded 、+exc、+x相同

状态可以逻辑组成：

• +local,program表示既满足+local又满足+program
• +local +vendor表示只要满足两者之一
• +vendor,program +std 表示vendor和program是与的关系，整体和std是或的关系
• +vendor,^program表示满足vendor，但却不满足program

包装说明符

完整的package-spec是：<path>[{/...|/^}][::<origin>][@[<version-spec>]]

一些例子：

• github.com/kardianos/govendor specifies a single package and single folder.
• github.com/kardianos/govendor/... specifies govendor and all referenced packages under that path.
• github.com/kardianos/govendor/^ specifies the govendor folder and all sub-folders. Useful for resources or if you don’t want a partial repository.
• github.com/kardianos/govendor/^::github.com/myself/govendor same as above but fetch from user “myself”.
• github.com/kardianos/govendor/...@abc12032 all referenced packages at revision abc12032.
• github.com/kardianos/govendor/...@v1 same as above, but get the most recent “v1” tag, such as “v1.4.3”.
• github.com/kardianos/govendor/...@=v1 get the exact version “v1”.

包和状态

您可以在单个命令中指定多个程序包规范和多个状态。 接受status和package-spec的命令：

• list
• add
• update
• remove
• fetch

如果最后一个参数是“ - ”，你可以通过stdin将参数传递给govendor。 例如echo + vendor | govendor list -将列出所有vendor包。

忽略构建标记并排除包

忽略构建标记是选择退出的，并且被设计为与指定时选择加入的构建文件指令相反。 通常，开发人员希望支持跨平台构建，但有选择地根据需要选择退出标记，测试和体系结构。

要忽略其他标记，请编辑“vendor.json”文件并将标记添加到vendor“ignore”文件字段。 该字段使用空格来分隔要忽略的标记。 例如，以下内容将忽略test和appengine文件。

{
	"ignore": "test appengine",
}

同样，某些特定的包可以从vendoring过程中排除。 这些包将被列为排除（x），并且在运行govendor add|fetch|update时不会被复制到“vendor”文件夹。

排除包foo的任何子包foo/bar也被排除（但是包bar/foo不是）。 排除的包的导入依赖性未列出，因此不会被vendor。

要排除包，还要使用“vendor.json”文件的“ignore”字段。 包由其名称标识，它们应包含“/”字符（可能在末尾）：

{
	"ignore": "test appengine foo/",
}

rubigo

Rubigo是一个用于Golang的DEPRECATED依赖工具和包管理器，用Rust编写。Rubigo使用vendor目录（从Go 1.5开始）来安装软件包，但是可以全局添加软件包（在GOPATH/src目录中）或在vendor目录中创建本地软件包。 Rubigo支持vendor目录中的手动更改，不会删除自定义包。目前，Rubigo仅支持git存储库。此源代码根据MIT许可证获得许可，该许可证可在LICENSE文件中找到。

弃用

考虑使用Go版本模块：

• rm -r vendor rubigo.json rubigo.lock
• export GO111MODULE=on
• go mod init

特征

• 管理vendor，全球和本地包
• 使用自定义存储库克隆包
• 支持语义版本控制
• 定义包信息
• 启动一个新项目（二进制文件或库）

这个怎么运作

Rubigo在Golang项目目录中创建了两个JSON（manifest）文件（rubigo.json和rubigo.lock）。 rubigo.json包含应安装和维护的项目和软件包的信息，rubigo.lock包含已安装在vendor目录中或全局安装在GOPATH/src中的软件包的信息。您可以手动编辑这两个文件或使用Rubigo子命令，然后将它们应用于项目的依赖项。此外，在现有项目中启动Rubigo是可行的。

如何安装

您可以从发布页面下载预构建的二进制文件，也可以手动构建它，如下所示：

• 安装Rust编程语言。
• 在Linux和Mac OS上：安装cmake，libcurl4-openssl-dev，libelf-dev，libssl-dev和libdw-dev。
• 在Windows上：安装cmake，Visual Studio C ++。

使用Rust的包管理器来安装应用程序：cargo install --git https://github.com/yaa110/rubigo.git

子命令

• init，start：在现有目录中初始化Rubigo项目，例如：rubigo init。此子命令在vendor目录中搜索已安装的软件包。
• new，create：创建一个新的Golang项目，例如：rubigo new my-project或rubigo new --lib my-library。此子命令创建一个新目录，其中提供的名称包含新的.go文件和清单文件。
• get，add：将包添加到依赖项并将其克隆到供应商目录中，例如：rubigo get github.com/blah/blah --repo=github.com/my/custom/repo（--repo参数是可选的）。此子命令还可以使用--global标志将包全局安装到GOPATH/src目录，或使用--local标志创建本地包。
• update，up：更新一个或所有软件包，并将rubigo.json的更改应用于供应商目录中的rubigo.lock和软件包，例如： rubigo更新github.com/blah/blah。此子命令还可以删除程序包的目录并使用--clean flag再次克隆它。如果未提供程序包名称，则会更新所有程序包。
• remove ，rm：从清单文件和供应商目录中删除一个包，例如rubigo remove github.com/blah/blah。
• apply，install：将rubigo.lock的更改应用于供应商目录中的包，例如：rubigo apply。此子命令还可以删除程序包的目录并使用--clean flag再次克隆它。大多数情况下，在克隆项目并希望安装缺少的软件包时使用它。
• reset，sync：将清单文件更新到已在vendor目录中安装的软件包列表，例如：rubigo reset。手动更改vendor``目录并想要更新清单文件时使用它。请注意，此子命令仅收集git包并忽略本地包。
• list，ls：显示rubigo.lock文件中的包列表，例如： rubigo list。此子命令只能分别使用--remote，--local或--global标记列出git，本地或全局包（或它们的组合）。
• info，about：显示rubigo.json文件中有关项目的信息，例如： rubigo info。
• help：显示帮助信息，例如rubigo help 。也可以获得子命令的信息，例如， rubigo help get。

标志

​ --verbose，-v：使用详细输出。
​ --quiet，-q：不打印输出。
​ --yes，-y：继续没有提示确认。
​ --help，-h：显示帮助消息。
​ --version，-V：显示Rubigo的版本。

清单格式

您可以在templates目录中找到rubigo.json和rubigo.lock文件的模板。这两个文件都具有JSON格式，包含以下对象：

• info：包含有关项目的（可选）信息。只有rubigo.json包含此对象。
  • name：项目名称
  • import：项目的导入路径
  • description：关于项目的简短描述
  • homepage：Url到项目主页（应该包含协议方案，如http：//）
  • license：项目的许可证
  • authors：一系列项目的作者
    • name：作者姓名
    • email：作者的电子邮件地址
    • website：作者的网站网址（应包含协议方案，如http：//）
• packages：包含有关包的信息。
  • git：从git存储库克隆的一组依赖项
    • import：包的导入路径
    • repo：克隆存储库的自定义URL
    • version：项目的版本。有关语义规则的更多信息，请查看semver文档。
  • local：供应商目录中的本地软件包数组。
  • global：GOPATH/src目录中的全局包数组。

godep

请改用dep或其他工具。

godep通过修复它们的依赖关系来帮助重复构建软件包。

此工具假定您正在使用标准Go工作区，如此处所述。 我们希望godep能够在Go 1.4 *或更新版本上构建，但您可以在任何适用于Go 1或更新版本的项目中使用它。

如果您有疑问，请查看常见问题解答。

Golang Dep

Go社区现在有dep项目来管理依赖项。 请考虑尝试从Godep迁移到dep。 如果存在阻止迁移的问题，请向dep提出问题，以便纠正问题。 Godep将继续得到支持一段时间，但被认为处于支持状态而不是主动功能开发。

安装

go get github.com/tools/godep

如何在新项目中使用godep

假设您已经完成了所有工作，那么您可以使用go install构建项目并使用go test进行测试，这是一个开始使用的命令：

godep save

这将保存文件Godeps/Godeps.json的依赖项列表，并将其源代码复制到vendor/（或使用较旧版本的Go时的Godeps/_workspace/）。 Godep不复制：

• 源版本库中未在版本控制中跟踪的文件。
• *_test.go文件。
• testdata目录。
• go包之外的文件。

Godep不会使用ignore或appengine构建标记处理.go文件的导入。

可以通过添加-t来保存测试文件和testdata目录。

阅读vendor/的内容并确保它看起来合理。然后将Godeps/和vendor/目录提交到版本控制。

不推荐使用的-r标志

对于旧版本的Go，-r标志告诉save自动重写包导入路径。这允许您的代码直接引用Godeps/_workspace中复制的依赖项。因此，依赖于包D的包C实际上将导入C/Godeps/_workspace/src/D.这使得C的repo自包含并导致使用所有依赖项的正确版本构建C.

如果你不使用-r，当使用旧版本的Go时，为了使用固定的依赖关系并获得可重现的版本，你必须确保每次运行Go相关的命令时，你将其包装在其中一个这两种方式：

• 如果您运行的命令刚刚运行，请将其作为godep go ...运行，例如godep go install -v ./..。
• 使用其他命令时，请使用godep设置$GOPATH，如下所述。

go1.6 +不需要-r，不允许使用-r。

附加操作

恢复

godep restore将Godeps/Godeps.json中指定的软件包版本安装到$GOPATH。这会修改$GOPATH中的包的状态。注意：godep restore使git存储库处于分离状态。 go1.6 +在执行go get时不再检查master分支，请参见此处。

如果你在主$GOPATH中运行godep restore，那么get -u将在master之后的包上失败。

请参阅有关还原的常见问题部分。

编辑测试周期

Edit code
Run godep go test
(repeat)

添加依赖项

要添加新的包foo/bar，请执行以下操作：

Run go get foo/bar
Edit your code to import foo/bar.
Run godep save (or godep save ./...).

更新依赖关系

要从$GOPATH更新包，请执行以下操作：

Run go get -u foo/bar
Run godep update foo/bar.

您可以使用...通配符，例如godep update foo/....在进行更改之前，您可能希望检查对Godeps的更改，例如使用git diff，并确保它看起来合理。

多个包

如果你的存储库有多个包，你可能习惯于运行go test ./...，go install ./...等命令，然后去fmt ./...，同样，你应该运行godep save ./...捕获应用程序中所有包的依赖关系。

文件格式

Godeps是一个具有以下结构的json文件：

type Godeps struct {
  ImportPath   string
  GoVersion    string   // Abridged output of 'go version'.
  GodepVersion string   // Abridged output of 'godep version'
  Packages     []string // Arguments to godep save, if any.
  Deps         []struct {
    ImportPath string
    Comment    string // Description of commit, if present.
    Rev        string // VCS-specific commit ID.
  }
}

示例Godeps：

{
  "ImportPath": "github.com/kr/hk",
  "GoVersion": "go1.6",
  "Deps": [
    {
      "ImportPath": "code.google.com/p/go-netrc/netrc",
      "Rev": "28676070ab99"
    },
    {
      "ImportPath": "github.com/kr/binarydist",
      "Rev": "3380ade90f8b0dfa3e363fd7d7e941fa857d0d13"
    }
  ]
}

迁移到vendor/

Godep使用go工具本身支持的相同环境变量（GO15VENDOREXPERIMENT）支持Go 1.5+vendor/实验。

godep的工作方式与go命令行工具的工作方式大致相同。 如果你已经1.5.X并设置GO15VENDOREXPERIMENT = 1或者已经启用了go1.6.X（或devel）vendor/。 除非你已经拥有Godeps/_workspace。 这是一个安全功能，godep会对此发出警告。

当vendor/被启用时，godep会将已售出的代码写入顶级./vendor/目录。 创建./Godeps/Godeps.json文件以跟踪依赖项和修订。vendor/与重写不兼容。

旧的Godeps工作区和vendor目录之间目前没有自动迁移，但以下步骤应该有效：

# just to be safe
$ unset GO15VENDOREXPERIMENT

# restore currently vendored deps to the $GOPATH
$ godep restore

# The next line is only needed to automatically undo rewritten imports that were
# created with godep save -r.
$ godep save -r=false <pkg spec>

# Remove the old Godeps folder
$ rm -rf Godeps

# If on go1.5.X to enable `vendor/`
$ export GO15VENDOREXPERIMENT=1

# re-analyze deps and save to `vendor/`.
$ godep save <pkg spec>

# Add the changes to your VCS
$ git add -A . ; git commit -am "Godep workspace -> vendor/"

# You should see your Godeps/_workspace/src files "moved" to vendor/.

govend

govend是vendor Go包依赖的简单工具。 这就像去获取，但是用于vendoring外部或第三方包。

govend是：

• 类似go get，但是用于vendoring包
• 与任何项目目录结构兼容
• 旨在供应嵌套依赖关系到n度
• 与Go版本1.5+兼容。

govend没有：

• 包装go命令
• 尝试创建一个新项目
• 强制您锁定依赖版本
• 生成临时目录或文件
• 改变任何Go环境变量，包括$GOPATH

安装

$ go get -u github.com/govend/govend

使用

小项目使用

# ...                                        # code, code, code
$ govend github.com/gorilla/mux              # vendor a dependency
# ...                                        # code, code, code
$ go build                                   # go tools work normally
$ govend -u github.com/gorilla/mux           # updated a dependency
# ...                                        # code, code, code
$ go build 

大项目使用

# ...                  # code, code, code
$ govend -v            # scan your project and download all dependencies
# ...                  # code, code, code
$ go build             # go tools work normally
$ govend -u            # scan your project and update all dependencies
# ...                  # code, code, code
$ go build             # go tools work normally

团队使用

Sarah:

$ git init                     # start git project
# ...                          # code, code, code
$ govend -v -l                 # scan your project, download all dependencies,
                               # and create a vendor.yml file to lock
                               # dependency versions
# ...                          # code, code, code
$ go build                     # go tools work normally
$ govend -v -u                 # scan your project, update all dependencies,
                               # and update the vendor.yml revision versions
# ...                          # code, code, code
$ git push                     # push code to github
$ go build                     # go tools work normally

Mike:

$ git clone url       # grab all the code Sarah pushed
$ govend -v           # download all the dependencies in the vendor.yml file
                      # and use the same revision versions Sarah is using
$ go build            # build the exact same binary Sarah has
# ...                 # code, code, code

详细模式

与大多数unixy程序一样，没有消息是好消息。因此，除非出现问题，否则govend将不会向终端打印任何内容。如果要查看正在发生的进展或证据，请使用-v标志打印包下载和vendor的包导入路径。

依赖树

您可以使用-t或--tree标志来查看包依赖关系树的再现。这有助于可视化和理解依赖项所依赖的包。
明确vendor包

您可以明确地告知govendvendor一个或多个包。它的工作方式与go get相同，但不是运行：

$ go get github.com/gorilla/mux

将gorilla mux包下载到$GOPATH中，运行：

$ govend github.com/gorilla/mux

这将把gorilla mux包下载到你的本地项目vendor/目录中。如果您希望govend下载多个软件包，请加以解决。例如，您可能希望供应gorilla mux，http和securecookie包，如下所示：

$ govend github.com/gorilla/mux github.com/gorilla/http github.com/gorilla/securecookie

明确更新包

要更新已经vendor的软件包，只需使用-u 网络更新标志。此标志与go get -u具有相同的含义，并始终使用网络下载依赖项的新副本。

要更新$GOPATH中的gorilla mux包，您将运行：

$ go get -u github.com/gorilla/mux

要更新本地项目vendor/目录中的gorilla mux包，请运行：

$ govend -u github.com/gorilla/mux 

自动vendor包

在处理大型Go项目时，要求govend下载并供应每个单独的包，这将变得陈旧。 值得庆幸的是，govend可以扫描您的项目源代码并为您识别依赖项。

当没有显式提供包时，govend假设您需要此行为：

$ cd project / root
$ govend

您还可以使用-v标志显示依赖项：

$ cd project/root

$ govend -v
github.com/kr/fs
github.com/BurntSushi/toml
github.com/spf13/cobra
github.com/inconshreveable/mousetrap
github.com/spf13/pflag
gopkg.in/yaml.v2
gopkg.in/check.v1

如果您想更新项目中的所有销售包，请使用-u标志：

$ cd project/root

$ govend -v -u
github.com/kr/fs
github.com/BurntSushi/toml
github.com/spf13/cobra
github.com/inconshreveable/mousetrap
github.com/spf13/pflag
gopkg.in/yaml.v2
gopkg.in/check.v1

锁定包

命令govend仅扫描外部包并将它们下载到项目中的vendor/目录。 您可能需要对依赖项的版本控制进行更多控制，以便可以实现可靠的可重现构建。

govend可以保存路径并提交在vendor.yml文件中下载的每个存储库的修订版。 这称为vendor锁定。 文件的格式可以指定为JSON或TOML，默认情况下使用YAML。 通常，此文件位于项目的根目录中，应包含在版本控制系统中。

要生成vendor.yml文件，请使用-l标志：

$ cd project/root

$ govend -v -l
github.com/kr/fs
github.com/BurntSushi/toml
github.com/spf13/cobra
github.com/inconshreveable/mousetrap
github.com/spf13/pflag
gopkg.in/yaml.v2
gopkg.in/check.v1

生成的项目结构应如下所示：

.
├── ...
├── code
├── README.md
├── vendor
└── vendor.yml

此示例中生成的vendor.yml文件的内容为：

vendors:
- path: github.com/BurntSushi/toml
  rev: f772cd89eb0b33743387f826d1918df67f99cc7a
- path: github.com/inconshreveable/mousetrap
  rev: 76626ae9c91c4f2a10f34cad8ce83ea42c93bb75
- path: github.com/kr/fs
  rev: 2788f0dbd16903de03cb8186e5c7d97b69ad387b
- path: github.com/spf13/cobra
  rev: 65a708cee0a4424f4e353d031ce440643e312f92
- path: github.com/spf13/pflag
  rev: 7f60f83a2c81bc3c3c0d5297f61ddfa68da9d3b7
- path: gopkg.in/check.v1
  rev: 4f90aeace3a26ad7021961c297b22c42160c7b25
- path: gopkg.in/yaml.v2
  rev: f7716cbe52baa25d2e9b0d0da546fcf909fc16b4

您现在可以忽略大型vendor/目录，并将小的vendor.yml文件传递给您的好友。你的好友可以运行$ govend并获得与vendor.yml指定的完全相同的依赖版本。

这是开发人员团队如果不想将vendor/目录检查到版本控制系统中，可以确保可重现的构建。

注意：最佳做法是检查VCS的vendor/目录。

更新锁定的包

如果您想将特定vendor包更新到其最新版本，请使用-u标志：

$ govend -u github.com/gorilla/mux

如果您想将所有已vendoring的软件包更新到其最新版本，请执行以下操作：

$ govend -u

如果要将特定的已vendor包更新为特定版本，请更新vendor.yml文件中的相关rev：值。

$ govend -l

修剪包

有时必须下载大型存储库以满足单个包依赖性。如果您正在检查vendor/的VCS，则会生成大量死文件。

--prune标志将使用已知的依赖关系树来删除或删除所有未使用的包，只留下相关代码。

注意：修剪时，它不仅会删除未使用的包，还会删除以。，_开头的文件和以_test.go结尾的文件。这是因为修剪很可能会破坏第三方测试。

保持包

如果您在项目代码中停止使用或导入包路径，govend将从您的vendor.yml中删除该包。它是如何让govend在你之后清理并保持vendor.yml整洁。

--hold标志将告诉govend保持这种依赖性，即使它没有被你的项目用作导入。这对于您可能希望随项目提供的版本控制工具非常有用。

$ govend --hold github.com/hashicorp/terraform

注意：使用--hold标志时，会生成清单文件，如vendor.yml。从本质上讲，选择进入 - 保留也会选择 - 锁定。另外由于保持的性质，使用保持的仓库不能被修剪。

vendor报告

如果您想获得扫描的唯一包数量的报告，跳过以及下载了多少个存储库，请运行govend -v -r。

→ govend -v -r
github.com/kr/fs
github.com/BurntSushi/toml
github.com/spf13/cobra
github.com/inconshreveable/mousetrap
github.com/spf13/pflag
gopkg.in/yaml.v2
gopkg.in/check.v1

packages scanned: 7
packages skipped: 0
repos downloaded: 7

vendor扫描

您可能希望扫描代码以确定项目中有多少第三方依赖项。 为此，请运行govend -s <path / to / dir>。 您还可以指定不同的输出格式。

文本

$ govend -s包
github.com/kr/fs
gopkg.in/yaml.v2

JSON

$ govend -s -f json包
[
  “github.com/kr/fs”
  “gopkg.in/yaml.v2”
]

YAML

$ govend -s -f yaml包
 -  github.com/kr/fs
 -  gopkg.in/yaml.v2

XML

$ govend -s -f xml包
<字符串> gopkg.in/yaml.v2</字符串>
<字符串> github.com/kr/fs</字符串>

更多标志

您可以运行govend -h来查找更多标志和选项。

vendor支持的Go版本

• Go 1.4 or less - Go does not support vendoring
• Go 1.5 - vendor via GO15VENDOREXPERIMENT=1
• Go 1.6 - vendor unless GO15VENDOREXPERIMENT=0
• Go 1.7+ - vendor always despite the value of GO15VENDOREXPERIMENT

有关详细说明，请阅读https://golang.org/doc/go1.6#go_command。

Windows支持

govend适用于Windows。

godm

godm是一个go1.5 +依赖项管理器。 构建状态GoDoc覆盖状态

更准确地说，这是一种管理项目依赖关系的工具，它通过在精确定位的版本中进行销售。

它依赖于“GO15VENDOREXPERIMENT”，因此其他人（用户和开发人员）可以简单地获得您的项目而不必被迫使用诸如Go或开箱即用的任何其他工具。

如果你想看一个使用godm的项目看起来如何，那你就在这里有一个:)

vendor作为Git子模块存在

状态

仍处于早期发展阶段。

依赖

go1.5+（使用GO15VENDOREXPERIMENT = 1）和Git（可在$PATH中使用）

安装

# If you haven't already, enable the Go 1.5 vendor experiment (personally that line is in my ~/.bashrc).
export GO15VENDOREXPERIMENT=1
# Then it's a simple go get.
go get github.com/hectorj/godm/cmd/godm

升级

go get -u github.com/hectorj/godm/cmd/godm

用法

注意：尚不支持Mercurial

帮助

自动生成的帮助如下：

godm --help

（感谢https://github.com/codegangsta/cli）

vendor

vendor子命令vendor在当前项目中尚未vendoring。 输出成功添加的vendor的导入路径。

# Go to your package directory, wherever that is.
cd $GOPATH/src/myPackage
# Run it.
godm vendor
# If everything went well, you have new git submodules you can commit.
git commit -m "Vendoring done by godm"

clean

clean子命令删除未在当前项目中导入的vendor。 输出成功删除的vendor的导入路径。

# Go to your package directory, wherever that is.
cd $GOPATH/src/myPackage
# Run it.
godm clean
# If everything went well, you may have some Git submodules removals you can commit.
git commit -m "Vendors cleaning done by godm"

remove

remove子命令取消导入路径。 将单个导入路径作为参数。

# Go to your package directory, wherever that is.
cd $GOPATH/src/myPackage
# Run godm
godm remove github.com/my/import/path
# If everything went well, you have a Git submodule removal you can commit.
git commit -m "Unvendoring done by godm"

Bash自动完成

将godm_bash_autocomplete.bash复制到/etc/bash_completion.d/以获取命令自动完成（强烈推荐）
从其他依赖项管理工具迁移

Godep

godep restore
GOPATH=`godep path`:$GOPATH godm save

一旦你检查了迁移进展顺利，你最终可以rm -rf ./Godeps

vexp

vexp是一个vendoring实验

用法：

vexp [-v] [-u packages]

Vexp在./ …中查找所有包的所有依赖项，并将其文件复制到子目录“vendor”中，例如go工具将在运行时使用复制的包在其环境中使用GO15VENDOREXPERIMENT = 1。

有关Go 1.5供应商实验的更多详细信息，请参阅
https://groups.google.com/d/msg/golang-dev/74zjMON9glU/4lWCRDCRZg0J
以及介绍该功能的变更说明，
https://go.googlesource.com/go/+/183cc0cd41

没有选项，vexp只添加新包; 现有包保持不变。标记-u更新已经vendoring的依赖项。 它需要
以冒号分隔的包模式列表。 如果有的话依赖性匹配这些模式之一，它将是从$GOPATH复制到vendor目录，即使已经存在。

有关指定包的更多信息，请参阅“go help packages”。

gv

一个简单的Go vendoring工具。gv使用go get -d下载包并将它们移动到vendor文件夹中，以便与Go 1.5 vendoring一起使用。

要求

要使用此工具，您必须安装Go 1.5并在.bash_profile或.bashrc中启用vendoring：

export GO15VENDOREXPERIMENT=1

安装

go get -u github.com/forestgiant/gv

用法

必须从项目根目录中使用。

gv get [-f] [-fix] [-insecure] [-t] [-u] [packages]

获取包 - （仅限Bash）

我们添加了一个bash脚本来包装go get并添加一个-v标志。 如果你通过这个标志去获取它会自动使用gv进行vendoring

go get -v github.com/forestgiant/gv

要启用此功能，您必须编辑.bash_profile或.bashrc并添加：

# gv: Used to wrap go get to add -v flag 
export GOCOMMANDLOCATION=/usr/local/bin
source $GOPATH/src/github.com/forestgiant/gv/go_to_gv

版本

gv只vendors。对于版本控制检出https://github.com/forestgiant/version一个skelterjohn/vendor的分支

gvt

gvt是一个为vendor/文件夹（曾经称为GO15VENDOREXPERIMENT）制作的简约Go vendoring工具。

它基于Dave Cheney的gb-vendor。

从Go 1.11开始，go工具支持模块，这是依赖性问题的本机解决方案。

go工具了解gvt清单文件，因此您只需运行即可

GO111MODULE=on go mod init
GO111MODULE=on go mod vendor

迁移并仍然填充vendor/文件夹以实现向后兼容性。

阅读文档或维基上的更多内容。

模块支持在1.11中是实验性的，但它可能比gvt更好地为你服务。

glide

您是否习惯使用Cargo，npm，Composer，Nuget，Pip，Maven，Bundler或其他现代包管理器等工具？ 如果是这样，Glide就是Go工具。

轻松管理您的供应商和销售包。 Glide是一个用于管理Go包中vendor目录的工具。此功能首先在Go 1.5中引入，允许每个包具有包含项目依赖包的vendor目录。这些供应商包可以通过工具安装，类似于go get，或者它们可以与包一起分发。

Golang Dep

Go社区现在有dep项目来管理依赖项。请考虑尝试从Glide迁移到dep。如果存在阻止迁移的问题，请向dep提出问题，以便纠正问题。 Glide将继续得到支持一段时间，但被认为处于支持状态而不是主动功能开发。

特征

• 轻松依赖管理
• 支持版本控制包，包括Semantic Versioning 2.0.0支持。可以使用github.com/Masterminds/semver包可以解析的任何约束。
• 支持别名包（例如，用于处理github分支）
• 无需修改import语句
• 使用所有go工具
• 支持Go支持的VCS工具：
  • git
  • bzr
  • hg
  • svn
• 支持自定义本地和全局插件（请参阅docs/plugins.md）
• 存储库缓存和数据缓存可提高性能。
• 展平依赖关系，解决版本差异，避免多次包含包。
• 在版本控制系统中按需管理和安装依赖项或销售依赖项。

工作原理

Glide扫描应用程序或库的源代码以确定所需的依赖项。要确定版本和位置（例如forks的别名），Glide会读取带有规则的glide.yaml文件。有了这些信息，Glide会检索所需的依赖项。

遇到依赖包时，会扫描其导入以确定依赖关系（传递依赖关系）的依赖关系。如果依赖项目包含glide.yaml文件，则该信息用于帮助确定从要使用的位置或版本获取时的依赖关系规则。还导入了Godep，GB，GOM和GPM的配置。

依赖项将导出到go工具可以找到并使用它们的供应商/目录。生成glide.lock文件，其中包含所有依赖项，包括传递依赖项。

glide init命令可用于设置新项目，glide update使用扫描和规则重新生成依赖版本，glide install将安装glide.lock文件中列出的版本，跳过扫描，除非glide.lock文件不是发现在哪种情况下它会执行更新。

项目结构如下：

- $GOPATH/src/myProject (Your project)
  |
  |-- glide.yaml
  |
  |-- glide.lock
  |
  |-- main.go (Your main go code can live here)
  |
  |-- mySubpackage (You can create your own subpackages, too)
  |    |
  |    |-- foo.go
  |
  |-- vendor
       |-- github.com
            |
            |-- Masterminds
                  |
                  |-- ... etc.

安装

在Mac或Linux上安装最新版本的最简单方法是使用以下脚本：

curl https://glide.sh/get | sh

在Mac OS X上，您还可以通过Homebrew安装最新版本：

$brew install glide

在Ubuntu Precise（12.04），Trusty（14.04），Wily（15.10）或Xenial（16.04）上，您可以从我们的PPA安装：

sudo add-apt-repository ppa:masterminds/glide && sudo apt-get update
sudo apt-get install glide

在Ubuntu Zesty（17.04）上，这个包叫做golang-glide。

二进制包可用于Mac，Linux和Windows。

对于开发版本，也可以去github.com/Masterminds/glide。

要从源代码构建，您可以：

• 将此存储库克隆到$GOPATH/src/github.com/Masterminds/glide并将目录更改为它
• 如果您使用Go 1.5，请确保设置环境变量GO15VENDOREXPERIMENT，例如通过运行导出GO15VENDOREXPERIMENT = 1。在Go 1.6中，它默认启用，在Go 1.7中，它始终启用，但无法将其关闭。
• 运行make build

这将为您留下./glide，如果您愿意，可以将其放入$PATH。（您还可以查看make install以便为您安装。）

Glide repo现在已经配置为使用Glide来管理自己。

使用

$ glide create                            # Start a new workspace
$ open glide.yaml                         # and edit away!
$ glide get github.com/Masterminds/cookoo # Get a package and add to glide.yaml
$ glide install                           # Install packages and dependencies
# work, work, work
$ go build                                # Go tools work normally
$ glide up                                # Update to newest versions of the package

查看此目录中的glide.yaml，或docs/目录中的示例。

glide create (aliased to init)

初始化新工作区。 除此之外，这会创建一个glide.yaml文件，同时尝试猜测要放入的包和版本。 例如，如果您的项目使用Godep，它将使用那里指定的版本。Glide非常智能，可以扫描您的代码库并检测正在使用的导入，无论它们是否与其他包管理器一起指定。

$ glide create
[INFO]	Generating a YAML configuration file and guessing the dependencies
[INFO]	Attempting to import from other package managers (use --skip-import to skip)
[INFO]	Scanning code to look for dependencies
[INFO]	--> Found reference to github.com/Masterminds/semver
[INFO]	--> Found reference to github.com/Masterminds/vcs
[INFO]	--> Found reference to github.com/codegangsta/cli
[INFO]	--> Found reference to gopkg.in/yaml.v2
[INFO]	Writing configuration file (glide.yaml)
[INFO]	Would you like Glide to help you find ways to improve your glide.yaml configuration?
[INFO]	If you want to revisit this step you can use the config-wizard command at any time.
[INFO]	Yes (Y) or No (N)?
n
[INFO]	You can now edit the glide.yaml file. Consider:
[INFO]	--> Using versions and ranges. See https://glide.sh/docs/versions/
[INFO]	--> Adding additional metadata. See https://glide.sh/docs/glide.yaml/
[INFO]	--> Running the config-wizard command to improve the versions in your configuration

此处提到的配置向导可以在此处运行，也可以在以后手动运行。该向导可帮助您确定可用于依赖项的版本和范围。

glide config-wizard

这将运行一个向导，扫描您的依赖项并检索它们上的信息，以提供您可以交互式选择的建议。例如，它可以发现依赖项是否使用语义版本并帮助您选择要使用的版本范围。

glide get [package name]

您可以将一个或多个软件包下载到vendor目录，并使用glide get将其添加到glide.yaml文件中。

$ glide get github.com/Masterminds/cookoo

当使用glide get时，它会反思列出的包以解决其依赖关系，包括使用Godep，GPM，Gom和GB配置文件。

glide update(aliased to up)

下载或更新glide.yaml文件中列出的所有库，并将它们放在vendor目录中。它还将递归遍历依赖包以获取任何需要的内容并在任何配置中读取。

$ glide up

这将对寻找由Glide，Godep，gb，gom和GPM管理的其他项目的软件包进行处理。当找到一个时，将根据需要安装这些包。

将使用固定到特定版本的依赖项创建或更新glide.lock文件。例如，如果在glide.yaml文件中将版本指定为范围（例如，^ 1.2.3），则将其设置为glide.lock文件中的特定提交ID。这允许可重复的安装（参见 glide install）。

要从获取的包中删除任何嵌套的vendor/目录，请参阅-v标志。

glide install

如果要从glide.lock文件安装特定版本，请使用glide install。

$ glide install

这将读取glide.lock文件并在那里安装commit id特定版本。

当glide.lock文件没有绑定到glide.yaml文件时，例如存在更改，它将提供警告。在更新依赖关系树时，glide up 将重新创建glide.lock文件。

如果没有glide.lock文件，glide install将执行更新并生成锁定文件。

要从获取的包中删除任何嵌套的vendor/目录，请参阅-v标志。

glide novendor (aliased to nv)

当您运行go test ./..等命令时，它将遍历所有子目录，包括vendor目录。 在测试应用程序时，您可能希望测试应用程序文件，而无需运行依赖项及其依赖项的所有测试。 这是novendor命令的用武之地。它列出了除vendor之外的所有目录。

$ go test $(glide novendor)

除了vendor目录之外，这将对项目的所有目录进行测试。

glide name

当您使用Glide编写脚本时，有时您需要知道正在处理的包的名称。 glide name返回glide.yaml文件中列出的包的名称。

glide tree

Glide包含一些命令，用于检查代码并为您提供有关导入内容的详细信息。 glide tree是一个这样的命令。 运行它会提供如下数据：

$ glide tree
github.com/Masterminds/glide
	github.com/Masterminds/cookoo   (/Users/mfarina/Code/go/src/github.com/Masterminds/glide/vendor/github.com/Masterminds/cookoo)
		github.com/Masterminds/cookoo/io   (/Users/mfarina/Code/go/src/github.com/Masterminds/glide/vendor/github.com/Masterminds/cookoo/io)
	github.com/Masterminds/glide/cmd   (/Users/mfarina/Code/go/src/github.com/Masterminds/glide/cmd)
		github.com/Masterminds/cookoo   (/Users/mfarina/Code/go/src/github.com/Masterminds/glide/vendor/github.com/Masterminds/cookoo)
			github.com/Masterminds/cookoo/io   (/Users/mfarina/Code/go/src/github.com/Masterminds/glide/vendor/github.com/Masterminds/cookoo/io)
		github.com/Masterminds/glide/gb   (/Users/mfarina/Code/go/src/github.com/Masterminds/glide/gb)
		github.com/Masterminds/glide/util   (/Users/mfarina/Code/go/src/github.com/Masterminds/glide/util)
			github.com/Masterminds/vcs   (/Users/mfarina/Code/go/src/github.com/Masterminds/glide/vendor/github.com/Masterminds/vcs)
		github.com/Masterminds/glide/yaml   (/Users/mfarina/Code/go/src/github.com/Masterminds/glide/yaml)
			github.com/Masterminds/glide/util   (/Users/mfarina/Code/go/src/github.com/Masterminds/glide/util)
				github.com/Masterminds/vcs   (/Users/mfarina/Code/go/src/github.com/Masterminds/glide/vendor/github.com/Masterminds/vcs)
			github.com/Masterminds/vcs   (/Users/mfarina/Code/go/src/github.com/Masterminds/glide/vendor/github.com/Masterminds/vcs)
			gopkg.in/yaml.v2   (/Users/mfarina/Code/go/src/gopkg.in/yaml.v2)
		github.com/Masterminds/semver   (/Users/mfarina/Code/go/src/github.com/Masterminds/glide/vendor/github.com/Masterminds/semver)
		github.com/Masterminds/vcs   (/Users/mfarina/Code/go/src/github.com/Masterminds/glide/vendor/github.com/Masterminds/vcs)
		github.com/codegangsta/cli   (/Users/mfarina/Code/go/src/github.com/Masterminds/glide/vendor/github.com/codegangsta/cli)
	github.com/codegangsta/cli   (/Users/mfarina/Code/go/src/github.com/Masterminds/glide/vendor/github.com/codegangsta/cli)
	github.com/Masterminds/cookoo   (/Users/mfarina/Code/go/src/github.com/Masterminds/glide/vendor/github.com/Masterminds/cookoo)
		github.com/Masterminds/cookoo/io   (/Users/mfarina/Code/go/src/github.com/Masterminds/glide/vendor/github.com/Masterminds/cookoo/io)
	github.com/Masterminds/glide/gb   (/Users/mfarina/Code/go/src/github.com/Masterminds/glide/gb)
	github.com/Masterminds/glide/util   (/Users/mfarina/Code/go/src/github.com/Masterminds/glide/util)
		github.com/Masterminds/vcs   (/Users/mfarina/Code/go/src/github.com/Masterminds/glide/vendor/github.com/Masterminds/vcs)
	github.com/Masterminds/glide/yaml   (/Users/mfarina/Code/go/src/github.com/Masterminds/glide/yaml)
		github.com/Masterminds/glide/util   (/Users/mfarina/Code/go/src/github.com/Masterminds/glide/util)
			github.com/Masterminds/vcs   (/Users/mfarina/Code/go/src/github.com/Masterminds/glide/vendor/github.com/Masterminds/vcs)
		github.com/Masterminds/vcs   (/Users/mfarina/Code/go/src/github.com/Masterminds/glide/vendor/github.com/Masterminds/vcs)
		gopkg.in/yaml.v2   (/Users/mfarina/Code/go/src/gopkg.in/yaml.v2)
	github.com/Masterminds/semver   (/Users/mfarina/Code/go/src/github.com/Masterminds/glide/vendor/github.com/Masterminds/semver)
	github.com/Masterminds/vcs   (/Users/mfarina/Code/go/src/github.com/Masterminds/glide/vendor/github.com/Masterminds/vcs)
	github.com/codegangsta/cli   (/Users/mfarina/Code/go/src/github.com/Masterminds/glide/vendor/github.com/codegangsta/cli)

这显示了一个导入树，不包括核心库。 由于vendoring使同一个包可以存放在多个位置，因此glide tree还会打印导入包的位置。

此命令已弃用，将在不久的将来删除。

glide list

Glide的list命令显示项目导入的所有包的按字母顺序排列的列表。

$ glide list
INSTALLED packages:
	vendor/github.com/Masterminds/cookoo
	vendor/github.com/Masterminds/cookoo/fmt
	vendor/github.com/Masterminds/cookoo/io
	vendor/github.com/Masterminds/cookoo/web
	vendor/github.com/Masterminds/semver
	vendor/github.com/Masterminds/vcs
	vendor/github.com/codegangsta/cli
	vendor/gopkg.in/yaml.v2

glide help

打印glide帮助。

$ glide help

glide --version

打印版本并退出。

$ glide --version
glide version 0.12.0

glide.yaml

有关glide.yaml文件的完整详细信息，请参阅文档。

glide.yaml文件执行两项关键操作：

• 它命名当前包
• 它声明了外部依赖

一个简短的glide.yaml文件如下所示：

package: github.com/Masterminds/glide
import:
  - package: github.com/Masterminds/semver
  - package: github.com/Masterminds/cookoo
    version: ^1.2.0
    repo: [email protected]:Masterminds/cookoo.git

以上说明了…

• 这个包名为github.com/Masterminds/glide
• 这个包取决于两个库。

第一个库举例说明了最小的包导入。它只提供完全限定的导入路径。

当Glide读取第二个库的定义时，它将从repo中的源获取repo，检出1.2.0和2.0.0之间的最新版本，并将其放在vendor目录中的github.com/Masterminds/cookoo中。 （请注意，包和仓库可以完全不同）

提示：版本是VCS依赖的，可以是可以检出的任何内容，也可以是github.com/Masterminds/semver包可以解析的语义版本约束。例如，使用Git，这可以是分支，标记或散列。这会有所不同，取决于VCS支持的内容。

提示：通常，建议您使用基本包名称导入包，而不是子包名称。例如，使用github.com/kylelemons/go-gypsy而不是github.com/kylelemons/go-gypsy/yaml。

支持的版本控制系统

支持Git，SVN，Mercurial（Hg）和Bzr源控制系统。这通过vcs包发生。

常见问题（F.A.Q.）

问：为什么Glide在Go没有时会有子包的概念？

在Go中，每个目录都是一个包。当你有一个包含所有包的repo时，这很有效。如果在不同的VCS位置有不同的软件包，事情会变得有点复杂。包含一组包的项目应该使用相同的信息处理，包括版本。通过这种方式对包进行分组，我们可以管理相关信息。

问：bzr（或hg）没有按照我预期的方式工作。为什么？

这些工作正在进行中，可能需要一些额外的调整。请看一下vcs包。如果您看到更好的处理方式，请告诉我们。

问：我应该加入vendor/的版本控制吗？

由你决定。这没有必要，但它也可能会导致您的额外工作和VCS中的大量额外空间。可能还有无法预料的错误（参见示例）。

问：如何从GPM，Godep，gom或gb导入设置？

导入有两个部分。

• 如果您导入的包具有GPM配置，Godep，gom或gb Glide将自动递归安装依赖项。
• 如果要将配置从GPM，Godep，gom或gb导入Glide，请参阅glide import命令。例如，您可以为Glide运行glide import godep来检测项目Godep配置并为您生成glide.yaml文件。

其中每个都将现有的glide.yaml文件与它为这些管理器找到的依赖项合并，然后将该文件作为输出发出。它不会覆盖你的glide.yaml文件。

您可以将其写入文件，如下所示：

$ glide import godep -f glide.yaml

问：Glide可以基于OS或Arch获取包吗？

答：是的。使用包上的os和arch，可以指定应该获取包的操作系统和体系结构。例如，仅为64位Darwin / OSX系统提取以下包：

- package: some/package
  os:
    - darwin
  arch:
    - amd64

不会为其他体系结构或操作系统提取该程序包。

vendetta

go依赖管理工具适用于不喜欢依赖管理工具的人。

介绍

Vendetta是一个用于管理go项目的vendor目录中的依赖项的最小工具。 Go支持1.5版本的此类目录，但不提供管理其内容的方法。 Vendetta不像其他依赖管理工具那样突兀，因为它依赖于git子模块。 您不需要vendetta来构建项目，也不需要大多数其他开发任务。 Vendetta仅用于使用子模块填充vendor目录，或者在项目的依赖项更改时更新它们。 因为它使用git子模块，所以您的项目存储库仍然很小，并且很容易将vendor目录的内容与其原始存储库相关联。

安装

如果你设置了GOPATH：

go get github.com/dpw/vendetta

这将在$GOPATH/bin中安装vendetta

git clone https://github.com/dpw/vendetta.git && (cd vendetta ; go build)

vendetta 二进制文件将在克隆的vendetta 目录中。

使用

Usage: vendetta [options][directory]

指定的目录应该是包含Go项目的git仓库的顶级目录。 如果省略，则使用当前目录。

与go get一样，vendetta会识别构建顶级项目所需的任何缺失包（包括其他依赖项所需的包）。 然后它找到包含那些缺少的包的项目，并运行git命令为它们添加子模块。

当你使用子模块克隆一个由子模块生成的项目时，子模块目录最初将为空。 执行git submodule update --init --recursive以检索子模块内容。

Vendetta遵循所有相关的Go约定，例如忽略testdata目录。

选项

• -p:去除在vendor/下不需要的子模块.
• -u:更新项目的依赖关系。 这将从远程存储库中提取 vendor/下的所需子模块.

背景

Go 1.5介绍了Go Vendor功能。这为vendor目录的标准go工具集提供了支持，其中包含项目依赖项的源代码。请注意，在Go 1.5中，您必须设置GO15VENDOREXPERIMENT环境变量才能启用此功能;但是Go 1.6默认启用它。

Go Vendor功能是go中依赖管理的重要一步。但是开箱即用，它没有提供一种方法来填充具有依赖项的项目的vendor目录，或者在项目发展时管理这些依赖项。试图手动执行此操作既麻烦又容易出错。

其他go vendoring工具可用。但它们支持两种方法：要么将依赖项的源代码复制到vendor/，这会使项目的存储库膨胀。或者，他们在vendor/下编写依赖关系元数据文件，该文件说明了如何获取依赖关系。但是，任何想要构建项目的人都需要使用特定工具来检索依赖项。 （并且依赖元数据文件没有主导标准 - 对于名为vendor.json的文件，甚至有两种不同的格式。）

相反，vendetta依赖于git的子模块功能，它为一个git存储库指向另一个git存储库（以及其中的特定提交）提供了一种方法。子模块是git的标准功能，所以git会为你检索它们。您可能已经具有子模块的经验。构建在git之上的工具可以理解子模块（例如github知道子模块，并且会在github上显示指向另一个项目的子模块作为链接）。

当您克隆包含子模块的存储库时，您需要执行git submodule update --init --recursive以检索子模块内容。对于那些对git子模块不熟悉的人来说，这一步骤有时令人惊讶。但是可以通过将其合并到构建脚本或makefile中来隐藏它。go get并且克隆一个repo后会去做 git submodule update，因此在以这种方式获取go包时没有必要显式运行它。

git子模块的缺点是，作为一个特定于git的特性，它们只允许存在于（或被镜像到）git存储库的依赖项。但考虑到go社区中git的流行，以及将其他VCS镜像到git的容易程度，这并不是一个限制。

Trash

将./vendor 目录中的垃圾保持在最低限度。

如何使用

确保您使用的是go1.6或更高版本。

• 下载并将最新版本提取到PATH。 或者，使用go get -u github.com/rancher/trash安装或更新当前开发版本。
• 将vendor.conf文件复制到项目中并根据需要进行编辑。
• 运行 trash。

vendor.conf（在您的项目根目录中）指定要提取，检出并复制到./vendor库目录。 例如：

github.com/rancher/trash

github.com/Sirupsen/logrus                      v0.8.7    https://github.com/imikushin/logrus.git
github.com/codegangsta/cli                      b5232bb
github.com/cloudfoundry-incubator/candiedyaml   5a459c2

或者，以YML格式：

import:
- package: github.com/Sirupsen/logrus               # package name
  version: v0.8.7                                   # tag or commit
  repo:    https://github.com/imikushin/logrus.git  # (optional) git URL

- package: github.com/codegangsta/cli
  version: b5232bb2934f606f9f27a1305f1eea224e8e8b88

- package: github.com/cloudfoundry-incubator/candiedyaml
  version: 55a459c2d9da2b078f0725e5fb324823b2c71702

运行trash以填充./vendor目录并删除不必要的文件。 运行trash --keep以将所有签出的文件保存在./vendor目录中。

灵感

我真的很喜欢glide，它就像一个真正的包管理器：指定你需要的东西，glide up并享受更新的库。但它对我遇到的几个问题没有帮助：

• 应管理所有必要的库代码并将其加入项目库（由项目政策强加）
• 应该删除不必要的代码，以便为较小的git checkout和更快的docker build

帮助

为了方便，trash可以检测glide.yaml（和glide.yml，以及trash.yaml）并使用它而不是vendor.conf（你可以强制它使用任何其他文件）。 以防万一，这是程序帮助：

$ trash -h
NAME:
   trash - Vendor imported packages and throw away the trash!

USAGE:
   trash [global options] command [command options] [arguments...]

VERSION:
   v0.2.5

AUTHOR(S):
   @imikushin, @ibuildthecloud

COMMANDS:
     help, h  Shows a list of commands or help for one command

GLOBAL OPTIONS:
   --file value, -f value       Vendored packages list (default: "vendor.conf")
   --directory value, -C value  The directory in which to run, --file is relative to this (default: ".")
   --keep, -k                   Keep all downloaded vendor code (preserving .git dirs)
   --update, -u                 Update vendored packages, add missing ones
   --debug, -d                  Debug logging
   --cache value                Cache directory (default: "/Users/ivan/.trash-cache") [$TRASH_CACHE]
   --help, -h                   show help
   --version, -v                print the version

gsv

介绍

gsv是Go Submodule Vendoring工具。 它使用Git子模块进行本地Go vendor。 这种方法使配置文件变得多余，并且不需要额外的工具来构建gsv-vendored Go项目，因为Git（无论如何已经安装）用于跟踪您的vendor依赖项的修订。

因此，为了获取并安装使用gsv来供应其依赖项的Go包，这很简单

go get $PACKAGE_URL

Go 1.5.X需要一些额外的步骤（参见常见问题解答）。

与基于副本的vendor方法相比，gsv保留了依赖项的历史记录，并将它们链接到主项目的历史记录，这有助于使用Git工具套件。 因此，可以浏览每个依赖项的git日志并分析自上次更新以来所做的更改。 此外，git bisect可用于在依赖项的存储库中查找提交，例如导致主项目中断。 等等。

依赖

libgit2 需要安装。 包存在

• Ubuntu
• Fedora
• Arch Linux
• Homebrew

如果您的发行版没有打包它，那么您需要自行编译源代码安装它。

安装

安装依赖项后执行

go get github.com/toxeus/gsv

并确保$GOPATH/bin在$PATH中。

使用

让我们假设我们想要在我们的项目中提供go-etcd及其递归依赖

cd $GOPATH/$OUR_PROJECT
gsv github.com/coreos/go-etcd/etcd
git commit -m "vendor: added go-etcd and its dependencies"

常见问题

我有个问题。 下一步是什么？

请打开issue](https://github.com/toxeus/gsv/issues/new)并尝试提供可重复的示例

我想贡献。下一步怎么做？

如果您想做出更大的改变，那么请打开issue，以便我们可以讨论最佳方法。

如果你想修复一些小问题，那么请随时直接打开拉取请求。

如何更新所有依赖项？

目前使用

git submodule foreach 'git fetch && git rebase master@{u}'

你知道git2go吗？

是! 上次我检查 git2go 中对子模块的支持不足以满足该项目的要求。 这就是Git代码最终用Cgo编写的原因。

如何使用Go 1.5获取和构建gsv项目？

像这样

export GO15VENDOREXPERIMENT=1
go get -d $PROJECT_URL
cd $GOPATH/$PROJECT_PATH
git submodule update --init
go install ./...

如何使用Go 1.5构建gsv？

See here

go build ./… 或go test ./…fails

gsv只是满足构建和测试项目所需的供应商依赖项。构建和测试vendor依赖项所需的依赖关系不会被引入。

因此，当从项目的根文件夹运行时，go build ./... 和/或go test ./... 可能会中断。要解决此问题，应使用以下命令

go build $(go list ./... | grep -v vendor)
go test $(go list ./... | grep -v vendor)

这不是一个玩笑，而是golang团队的官方推荐。

请注意，拉入依赖项的构建和测试依赖项不太可能修复 go build ./... 和 go test ./... 因为拉入的包将具有不满足的依赖性。 不是管理构建和测试依赖性的正确解决方案。

TODO

按优先顺序排列。无需完全按照此处的建议实施。

• 添加-purge标志，以便检测和删除未使用的vendor子模块。
• 使用Go的stdlib代码而不是gb-vendor
• 添加-updateall标志，以便将所有依赖项更新为其当前origin/master。
• 看看git2go，看看子模块支持是否有进展。
• 寻找libgit2的替代品。 这种依赖性降低了可移植性并使安装更加困难。

信任

该项目可以为gb-vendor完成的工作进行引导。

gom

为什么

go get命令很有用。 但我们想解决包版本与更新的问题。你可以这么做go get -tags=1.1 ..., go get -tag=0.3？ 我们想冻结包版本。 Ruby的捆绑很棒。

安装

go get github.com/mattn/gom

Gomfile

gom 'github.com/mattn/go-runewidth', :tag => 'go1'
gom 'github.com/mattn/go-scan', :commit => 'ecb144fb1f2848a24ebfdadf8e64380406d87206'
gom 'github.com/daviddengcn/go-colortext'
gom 'github.com/mattn/go-ole', :goos => 'windows'

# Execute only in the "test" environment.
group :test do
    gom 'github.com/mattn/go-sqlite3'
end

# Execute only for the "custom_group" group.
group :custom_group do
    gom 'github.com/golang/lint/golint'
end

默认情况下，gom install会安装所有软件包，但列出的组中的软件包除外。 您可以使用标志（开发，测试和生产）根据环境从组安装软件包：gom -test install

我可以使用-groups标志指定自定义组：gom -test -groups = custom_group，special install

使用

创建_vendor目录并将包捆绑到其中

gom install

使用_vendor包在当前目录上构建

gom build

使用_vendor包在当前目录上运行测试

gom test

使用gom test生成.travis.yml

gom gen travis-yml

您始终可以使用环境变量GOM_VENDOR_NAME更改相对于当前$ GOPATH目录的名称

$ # 要使用常规$GOPATH/src文件夹，您应该设置环境变量GOM_VENDOR_NAME值为'.'
$ GOM_VENDOR_NAME=. gom <command>

教程

编写Gomfile和bundle

$ ls
main.go

$ gom gen gomfile

$ cat Gomfile
gom 'github.com/daviddengcn/go-colortext'
gom 'github.com/mattn/go-runewidth'

$ gom install
installing github.com/daviddengcn/go-colortext
installing github.com/mattn/go-runewidth

$ find \_vendor/src -maxdepth 2
\_vendor/src
\_vendor/src/github.com
\_vendor/src/github.com/daviddengcn
\_vendor/src/github.com/mattn

$ gom build

如果要捆绑指定的标记，分支或提交

gom 'github.com/mattn/go-runewidth', :tag => 'tag_name'
gom 'github.com/mattn/go-runewidth', :branch => 'branch_name'
gom 'github.com/mattn/go-runewidth', :commit => 'commit_name'

如果需要访问go get无法访问的库

gom 'github.com/username/repository', :command => 'git clone http://example.com/repository.git'

如果要使用命令git clone更改本地存储库目录，还要使用skipdep和insecure，这在内部网络环境中很有用。

gom 'github.com/username/repository', :private => 'true', :target => 'repository', :insecure=>'true', :skipdep=>'true' 

gopm

Gopm（Go Package Manager）是Go的包管理和构建工具。

Go的在线版缓存和包下载服务 gopm.io。

请在开始之前查看文档。

要求

Go development environment: >= go1.2

安装

我们使用gobuild进行在线跨平台编译工作。 您可以在此处查看完整的可用二进制列表。

go get -u github.com/gpmgo/gopm

可执行文件将在您的文件系统中的$GOPATH/bin下生成; 出于全局使用目的，我们建议您将此路径添加到PATH环境变量中。

特征

• 无需安装任何版本控制系统工具（如git或hg）即可下载软件包。
• 下载，安装或构建具有特定修订版的软件包。
• 当用gopm build或gopm install构建程序时，一切都发生在它自己的GOPATH中并且不会打扰你做过的任何事情（除非你告诉它）。
• 可以将Go项目放在任何你想要的地方（通过.gopmfile）。

命令

NAME:
   Gopm - Go Package Manager

USAGE:
   Gopm [global options] command [command options] [arguments...]

COMMANDS:
   list		list all dependencies of current project
   gen		generate a gopmfile for current Go project
   get		fetch remote package(s) and dependencies
   bin		download and link dependencies and build binary
   config	configure gopm settings
   run		link dependencies and go run
   test		link dependencies and go test
   build	link dependencies and go build
   install	link dependencies and go install
   clean	clean all temporary files
   update	check and update gopm resources including itself
   help, h	Shows a list of commands or help for one command

GLOBAL OPTIONS:
   --noterm, -n		disable color output
   --strict, -s		strict mode
   --debug, -d		debug mode
   --help, -h		show help
   --version, -v	print the version

文档

快速入门

在本小节中，我们将会演示一个安装两种不同版本的 beego 并打印版本信息的简单示例。

准备工作

您不需要将这个项目置于任何 $GOPATH 下，所以我们就将它放在 ~/demo 中：

$ mkdir ~/demo
$ cd ~/demo

然后，创建 main.go 文件:

$ touch main.go

复制以下代码并粘贴到文件中：

package main

import (
	"github.com/astaxie/beego"
)

func main() {
	println("Beego version:", beego.VERSION)
}

很好！

gopmfile

这个文件包含 gopm 所需要的所有信息，我们现在就来看看可以在这个示例中对它做什么。

首先，您需要在项目目录中创建 .gopmfile 文件：

$ touch .gopmfile

不错，接着把以下内容复制到文件中：

[target]
path = demo

键 path 指示了您的项目名称。

注意事项 如果您的导入路径类似 github.com/gpmgo/gopm 则应该使用 path = github.com/gpmgo/gopm 而不是 path = gopm。

构建项目

默认配置

现在让我们先基于默认设定来构建这个项目，也就是全部使用最新版本的依赖包。

$ gopm build

当命令执行成功时，不会输出任何内容。但如果您想要查看详细信息，则可以通过选项 -v 实现：

$ gopm build -v

下面是一个输出样例：

[GOPM] 14-09-17 17:40:11 [ INFO] Local repository path: /Users/jiahuachen/.gopm/repos
[GOPM] 14-09-17 17:40:11 [ INFO] Indicated GOPATH: /Users/jiahuachen/Applications/Go
[GOPM] 14-09-17 17:40:11 [DEBUG] Linking demo...
[GOPM] 14-09-17 17:40:11 [DEBUG] Loading dependencies...
[GOPM] 14-09-17 17:40:11 [ INFO] Building...
[GOPM] 14-09-17 17:40:11 [ INFO] Setting GOPATH to /Users/jiahuachen/demo/.vendor
[GOPM] 14-09-17 17:40:11 [ INFO] ===== application outputs start =====

[GOPM] 14-09-17 17:40:11 [ INFO] ====== application outputs end ======
[GOPM] 14-09-17 17:40:11 [ INFO] Setting GOPATH back to /Users/jiahuachen/Applications/Go
[GOPM] 14-09-17 17:40:11 [ INFO] Command executed successfully!

正如您所看到的，由于我的 $GOPATH 中已经下载了最新版本的 beego 及其依赖包，而且我没有指定任何特殊版本，因此 gopm 不会对它们进行链接操作。

现在执行以下指令：

$ ./demo

您应该看到类似下面的输出：

beego version: 1.4.0

自定义配置

假如说由于 beego 的 API 破坏，我们需要基于 v0.9.0 版本的 beego 构建我们的项目，所以我们需要将 gopmfile 修改为以下内容：

[target]
path = demo

[deps]
github.com/astaxie/beego = tag:v0.9.0

在节 deps 中我们指示我们需要的 beego 版本为 tag:v0.9.0。

下载依赖并重新构建我们的项目，然后运行：

$ gopm get
$ gopm build
$ ./demo

同样的，您可以用过 -v 选项来查看详细信息：

[GOPM] 14-09-17 18:07:28 [ INFO] Local repository path: /Users/jiahuachen/.gopm/repos
[GOPM] 14-09-17 18:07:28 [ INFO] Indicated GOPATH: /Users/jiahuachen/Applications/Go
[GOPM] 14-09-17 18:07:28 [DEBUG] Linking demo...
[GOPM] 14-09-17 18:07:28 [DEBUG] Loading dependencies...
[GOPM] 14-09-17 18:07:28 [DEBUG] Linking github.com/astaxie/beego.v0.9.0...
[GOPM] 14-09-17 18:07:28 [DEBUG] Linking github.com/garyburd/redigo...
[GOPM] 14-09-17 18:07:28 [ WARN] Getting imports: no buildable Go source files in /Users/jiahuachen/demo/.vendor/src/github.com/garyburd/redigo
[GOPM] 14-09-17 18:07:28 [ INFO] Building...
[GOPM] 14-09-17 18:07:28 [ INFO] Setting GOPATH to /Users/jiahuachen/demo/.vendor
[GOPM] 14-09-17 18:07:28 [ INFO] ===== application outputs start =====

[GOPM] 14-09-17 18:07:29 [ INFO] ====== application outputs end ======
[GOPM] 14-09-17 18:07:29 [ INFO] Setting GOPATH back to /Users/jiahuachen/Applications/Go
[GOPM] 14-09-17 18:07:29 [ INFO] Command executed successfully!

值得注意的是，gopm 为此下载了 3 个包（到 gopm 本地仓库），分别是 github.com/astaxie/beego 和 github.com/garyburd/redigo 这几个我并没有安装在我的电脑上，以及忽略了我已经安装（在 $GOPATH）的包 code.google.com/p/vitess/go/memcache。

这个例子充分说明了 gopm 能够很好地与 $GOPATH 共同协作。

现在，输出应该变成以下内容：

Beego version: 0.9.0

list 命令

帮助信息：gopm list -h or gopm help list:

NAME:
   list - list all dependencies of current project

USAGE:
   command list [command options] [arguments...]

DESCRIPTION:
   Command list lsit all dependencies of current Go project

gopm list

Make sure you run this command in the root path of a go project.

OPTIONS:
   --tags 			apply build tags
   --test, -t		show test imports
   --verbose, -v	show process details

gopm list

• 功能：根据当前项目并结合 gopmfile 列出所有依赖和相应的版本。
• 示例：gopm list

使用示例

下面为 gopm list -v 命令的示例输出：

[GOPM] 14-09-22 20:48:08 [ INFO] Local repository path: /Users/jiahuachen/.gopm/repos
[GOPM] 14-09-22 20:48:08 [ INFO] Indicated GOPATH: /Users/jiahuachen/Applications/Go
Dependency list(20):
-> github.com/Unknwon/cae @ commit:2e70a1351b
-> github.com/Unknwon/com @ commit:2cbcbc6916
-> github.com/Unknwon/goconfig @ commit:0f8d8dc1c0
-> github.com/Unknwon/i18n @ commit:47baeff8d0
-> github.com/Unknwon/macaron
-> github.com/codegangsta/cli @ commit:7381bc4e62
-> github.com/go-sql-driver/mysql @ commit:8111ee3ec3
-> github.com/go-xorm/core @ commit:750aae0fa5
-> github.com/go-xorm/xorm @ commit:2d8b3135b1
-> github.com/gogits/gfm @ commit:40f747a9c0
-> github.com/gogits/oauth2 @ commit:99cbec870a
-> github.com/lib/pq @ commit:b021d0ef20
-> github.com/macaron-contrib/cache @ commit:204d8e5137
-> github.com/macaron-contrib/captcha
-> github.com/macaron-contrib/csrf
-> github.com/macaron-contrib/i18n
-> github.com/macaron-contrib/session
-> github.com/macaron-contrib/toolbox @ commit:57127bcc89
-> github.com/nfnt/resize @ commit:581d15cb53
-> github.com/saintfish/chardet @ commit:3af4cd4741

选项

• --tags：应用构建 tags。
• --test, -t：列举出 test 文件的依赖。
• --verbose, -v：显示详细信息。

gen 命令

Help information: gopm gen -h or gopm help gen:

NAME:
   gen - generate a gopmfile for current Go project

USAGE:
   command gen [command options] [arguments...]

DESCRIPTION:
   Command gen gets dependencies and generates a gopmfile

gopm gen

Make sure you run this command in the root path of a go project.

OPTIONS:
   --tags 		apply build tags
   --local, -l		generate local GOPATH directories
   --verbose, -v	show process details

gopm gen

• 功能：根据当前 Go 项目生成 gopmfile。
• 说明：获取依赖并写入 gopmfile。
• 示例：gopm gen。

使用用例

我现在正在目录 $GOPATH/src/github.com/gogits/gogs 下，此时我需要生成一个 gopmfile：

$ gopm gen
$ cat .gopmfile

输出：

[target]
path = github.com/gogits/gogs

[deps]
github.com/beego/memcache = commit:2aea774416
github.com/beego/redigo = commit:856744a0d5
github.com/Unknwon/cae = commit:2e70a1351b
github.com/Unknwon/com = commit:2cbcbc6916
github.com/Unknwon/goconfig = commit:0f8d8dc1c0
github.com/Unknwon/i18n = commit:47baeff8d0
github.com/Unknwon/macaron = 
github.com/codegangsta/cli = commit:7381bc4e62
github.com/go-sql-driver/mysql = commit:8111ee3ec3
github.com/go-xorm/core = commit:750aae0fa5
github.com/go-xorm/xorm = commit:2d8b3135b1
github.com/gogits/gfm = commit:40f747a9c0
github.com/gogits/oauth2 = commit:99cbec870a
github.com/lib/pq = commit:b021d0ef20
github.com/macaron-contrib/cache = commit:204d8e5137
github.com/macaron-contrib/captcha = 
github.com/macaron-contrib/csrf = 
github.com/macaron-contrib/i18n = 
github.com/macaron-contrib/session = 
github.com/macaron-contrib/toolbox = commit:57127bcc89
github.com/mattn/go-sqlite3 = commit:a80c27ba33
github.com/nfnt/resize = commit:581d15cb53
github.com/saintfish/chardet = commit:3af4cd4741

[res]
include = conf|etc|public|scripts|templates

有关如何书写包版本的信息，请阅读 gopmfile。

选项

• --tags：在列举依赖时应用构建 tags。
• --verbose, -v：显示详细信息。

get 命令

帮助信息：gopm get -h 或 gopm help get：

NAME:
   get - fetch remote package(s) and dependencies

USAGE:
   command get [command options] [arguments...]

DESCRIPTION:
   Command get fetches a package or packages,
and any pakcage that it or they depend(s) on.
If the package has a gopmfile, the fetch process will be driven by that.

gopm get
gopm get <import path>@[<tag|commit|branch>:<value>]
gopm get <package name>@[<tag|commit|branch>:<value>]

Can specify one or more: gopm get cli@tag:v1.2.0 github.com/Unknwon/macaron

If no version specified and package exists in GOPATH,
it will be skipped, unless user enabled '--remote, -r' option
then all the packages go into gopm local repository.

OPTIONS:
   --tags 			apply build tags
   --download, -d	download given package only
   --update, -u		update package(s) and dependencies if any
   --local, -l		download all packages to local GOPATH
   --gopath, -g		download all pakcages to GOPATH
   --remote, -r		download all pakcages to gopm local repository
   --verbose, -v	show process details

gopm get

• 功能：根据 gopmfile 拉取远程包及其依赖到本地仓库。
• 说明：如果未传入任何参数，则 gopm 根据在当前目录的项目来进行依赖包的拉取。如果发现 gopmfile 文件，则会应用相关规则。
• 示例：gopm get。

使用示例

gopm get

假设您的当前目录是 gopm（github.com/gpmgo/gopm）项目的根目录：

$ pwd

输出：

$GOPATH/src/github.com/gpmgo/gopm

然后在目录下有一个 gopmfile 文件：

$ cat .gopmfile

输出：

[target]
path = github.com/gpmgo/gopm

[deps]
github.com/Unknwon/com =
github.com/Unknwon/goconfig =
github.com/aybabtme/color =
github.com/codegangsta/cli =
github.com/Unknwon/cae =

如果节 deps 中的 4 个包不存在于你的 $GOPATH 中，则该命令会下载它们（到 gopm 本地仓库 ~/.gopm/repos）。

假设您需要将他们全部下载到 $GOPATH 中，然后做一些修改重新编译 gopm。则您可以使用选项 --gopath, -g 来达到目的。

然而，当您希望保持您的 $GOPATH 整洁，而将它们全部下载到 gopm 本地仓库。则您可以使用选项 --remote, -r 来达到目的。

gopm get <import path>@[<tag|commit|branch>:<value>]

• 功能：拉取指定版本的远程包及其依赖到本地仓库。
• 说明：该命令可接受一个或多个参数附带或不带指定版本。
• 示例：
  • 最新版本：gopm get github.com/go-xorm/xorm.
  • 固定分支（branch）：gopm get github.com/go-xorm/xorm@branch:master。
  • 指定标签（tag）：gopm get github.com/go-xorm/xorm@tag:v0.2.3。
  • 某个提交（commit）：gopm get github.com/go-xorm/xorm@commit:6ffffe9。

使用用例

最新版本：gopm get github.com/go-xorm/xorm

该命令下载最新版本的 xorm，并根据 gopmfile 下载它的依赖包。

固定分支：gopm get github.com/go-xorm/xorm@branch:master

该命令下载 xorm 的 master 分支的最新版，并根据 gopmfile 下载它的依赖包。

指定标签：gopm get github.com/go-xorm/xorm@tag:v0.2.3

该命令下载 tag:v0.2.3 版本的 xorm，并根据 gopmfile 下载它的依赖包。

某个提交：gopm get github.com/go-xorm/xorm@commit:6ffffe9

该命令下载提交 commit:6ffffe9 时刻的 xorm，并根据 gopmfile 下载它的依赖包。

gopm get <package name>@[<tag|commit|branch>:<value>]

• 功能：拉取指定版本的远程包及其依赖到本地仓库；但可使用项目名称代替完整的导入路径。
• 说明：该命令为包导入路径的快捷版。
• 示例：
  • 最新版本：gopm get xorm。
  • 固定分支（branch）：gopm get xorm@branch:master。
  • 指定标签（tag）：gopm get xorm@tag:v0.2.3。
  • 某个提交（commit）：gopm get xorm@commit:6ffffe9。

查看 知名 Go 项目列表 获取更多信息。

选项

• --tags：应用构建 tags。
• --download, -d：仅下载当前指定的包。
• --update, -u：检查更新所有包。
• --gopath, -g：下载所有包至 GOPATH 中。
• --remote, -r：将所有包下载至 gopm 本地仓库。
• --verbose, -v：显示详细信息。

bin 命令

帮助信息：gopm bin -h 或 gopm bin get：

NAME:
   bin - download and link dependencies and build binary

USAGE:
   command bin [command options] [arguments...]

DESCRIPTION:
   Command bin downloads and links dependencies according to gopmfile,
and build executable binary to work directory

gopm bin <import path>@[<tag|commit|branch>:<value>]
gopm bin <package name>@[<tag|commit|branch>:<value>]

Can only specify one each time, and only works for projects that
contain main package

OPTIONS:
   --tags 		apply build tags
   --dir, -d './'	build binary to given directory
   --update, -u		update pakcage(s) and dependencies if any
   --remote, -r		build with pakcages in gopm local repository only
   --verbose, -v	show process details

gopm bin <import path>@[<tag|commit|branch>:<value>]

• 功能：下载指定版本的远程包及其依赖并构建可执行文件。
• 说明：无需手动处理源代码即可快速构建二进制文件。
• 示例：
  • 最新版本：gopm bin github.com/gpmgo/gopm.
  • 固定分支（branch）：gopm bin github.com/gpmgo/gopm@branch:master。
  • 指定标签（tag）：gopm bin github.com/gpmgo/gopm@tag:tag:v0.1.0。
  • 某个提交（commit）：gopm bin github.com/gpmgo/gopm@commit:23ce93a。

使用示例

如果您想要将二进制构建至指定路径，则可以使用 --dir, -d 选项来达到目的。例如，我想将 gopm 构建至 $GOROOT/bin，则我应该执行 gopm bin -d $GOROOT/bin github.com/gpmgo/gopm。

最新版本：gopm bin github.com/gpmgo/gopm

该命令下载最新版本的 gopm，并将二进制构建至当前目录。

固定分支：gopm bin github.com/gpmgo/gopm@branch:master

该命令下载 gopm 的 master 分支的最新版，并将二进制构建至当前目录。

指定标签：gopm bin github.com/gpmgo/gopm@tag:tag:v0.1.0

该命令下载 tag:v0.1.0 版本的 gopm，并将二进制构建至当前目录。

某个提交：gopm bin github.com/gpmgo/gopm@commit:23ce93a

该命令下载提交 commit:23ce93a 时刻的 gopm，并将二进制构建至当前目录。

gopm bin <package name>@[<tag|commit|branch>:<value>]

• 功能：下载指定版本的远程包及其依赖并构建可执行文件；但可使用项目名称代替完整的导入路径。
• 说明：该命令为包导入路径的快捷版。
• 示例：
  • 最新版本：gopm bin gopm。
  • 固定分支（branch）：gopm bin gopm@branch:master。
  • 指定标签（tag）：gopm bin gopm@tag:v0.1.0。
  • 某个提交（commit）：gopm bin gopm@commit:23ce93a。

查看 知名 Go 项目列表 获取更多信息。

选项

• --tags：应用构建 tags。
• -dir, -d：构建可执行文件到指定目录。
• --update, -u：检查更新所有包。
• --verbose, -v：显示详细信息。

run 命令

帮助信息：gopm run -h 或 gopm help run：

NAME:
   run - link dependencies and go run

USAGE:
   command run [command options] [arguments...]

DESCRIPTION:
   Command run links dependencies according to gopmfile,
and execute 'go run'

gopm run <go run commands>
gopm run -l will recursively find .gopmfile with value localPath
and run the cmd in the .gopmfile, Windows hasn't supported yet,
you need to run the command right at the local_gopath dir.

OPTIONS:
   --tags 		apply build tags
   --local, -l		run command with local gopath context
   --verbose, -v	show process details

gopm run <go run commands>

• 功能：根据 gopmfile 链接依赖并执行 go run。
• 示例：gopm run main.go。

选项

• --tags：应用构建 tags。
• --verbose, -v：显示详细信息。

test 命令

帮助信息：gopm test -h 或 gopm test run：

NAME:
   test - link dependencies and go test

USAGE:
   command test [command options] [arguments...]

DESCRIPTION:
   Command test links dependencies according to gopmfile,
and execute 'go test'

gopm test <go test commands>

OPTIONS:
   --tags 		apply build tags
   --verbose, -v	show process details

gopm test <go test commands>

• 功能：根据 gopmfile 链接依赖并执行 go test。
• 示例：gopm test。

选项

• --tags：应用构建 tags。
• --verbose, -v：显示详细信息。

build 命令

帮助信息：gopm build -h 或 gopm help build：

NAME:
   build - link dependencies and go build

USAGE:
   command build [command options] [arguments...]

DESCRIPTION:
   Command build links dependencies according to gopmfile,
and execute 'go build'

gopm build <go build commands>

OPTIONS:
   --tags 		apply build tags
   --update, -u		update pakcage(s) and dependencies if any
   --remote, -r		build with pakcages in gopm local repository only
   --verbose, -v	show process details

gopm build <go build commands>

• 功能：根据 gopmfile 链接依赖并执行 go build。
• 说明：下载丢失的依赖并链接，然后构建二进制。
• 示例：gopm build。

选项

• --tags：应用构建 tags。
• --update, -u：在构建之前检查包和依赖更新。
• --verbose, -v：显示详细信息。

install 命令

帮助信息：gopm install -h 或 gopm help install：

NAME:
   install - link dependencies and go install

USAGE:
   command install [command options] [arguments...]

DESCRIPTION:
   Command install links dependencies according to gopmfile,
and execute 'go install'

gopm install

If no argument is supplied, then gopmfile must be present

OPTIONS:
   --tags 		apply build tags
   --remote, -r		build with pakcages in gopm local repository only
   --verbose, -v	show process details

gopm install

• 功能：根据当前项目 gopmfile 链接依赖并执行 go install。
• 说明：下载丢失的依赖然后链接并安装它们。
• 示例：gopm install。

gopm install <import path>

• 功能：根据指定导入路径 gopmfile 链接依赖并执行 go install。
• 说明：下载丢失的依赖然后链接并安装它们。
• 示例：gopm install github.com/Unknwon/com。

选项

• --tags：应用构建 tags。
• --verbose, -v：显示详细信息。

clean 命令

帮助信息：gopm clean -h 或 gopm clean run：

NAME:
   clean - clean all temporary files

USAGE:
   command clean [command options] [arguments...]

DESCRIPTION:
   Command clean deletes all temporary files generated by gopm

gopm clean

OPTIONS:
   --verbose, -v	show process details

gopm clean

• 功能：清除由 gopm 产生的临时文件。
• 示例：gopm clean。

选项

• --verbose, -v：显示详细信息。

update 命令

帮助信息：gopm update -h 或 gopm help update：

NAME:
   update - check and update gopm resources including itself

USAGE:
   command update [command options] [arguments...]

DESCRIPTION:
   Command update checks updates of resources and gopm itself.

gopm update

Resources will be updated automatically after executed this command,
but you have to confirm before updaing gopm itself.

OPTIONS:
   --verbose, -v	show process details

gopm update

• 功能：检查更新最新的 gopm 资源，包括 gopm 自身。
• 说明：检查资源的版本并下载最新版本。
• 示例：gopm update：

选项

• --verbose, -v：显示详细信息。

gopmfile

gopmfile 需放在项目根目录下，名称为 .gopmfile。

样例 gopmfile 文件：

[target]
path = github.com/gpmgo/gopm

[deps]
github.com/codegangsta/cli = branch:master

[res]
include = conf|etc|public|scripts|templates

• target -> path 指示项目名称或导入路径。
• deps 节包含了特殊（非最新）版本的依赖。
• res 在执行 gopm bin 命令时自动打包的资源。

如何编写包版本

有五种可能的包版本组合：

• 空白：表示使用最新版本的依赖进行构建。
• /path/to/my/project：绝对或者相对的文件路径，例如：d:\projects\xorm。
• branch:<value>：固定分支，例如：branch:master。
• tag:<value>：指定标签，例如：tag:v0.9.0。
• commit:<value>：某个提交，例如：commit:6ffffe9。一般来说只需要 SHA 的前 7 个字母就可以确定一个提交。

Dep

dep是Go的依赖管理工具。 它需要Go 1.9或更新版本才能编译。

dep是“官方实验”。 截至1.11的Go工具链（实验上）采用了与dep明显不同的方法。 因此，我们正在继续开发dep，但是工作主要是为了开发工具链中版本化行为的替代原型。

有关dep的指南和参考资料，请参阅文档。

安装

强烈建议您使用已发布的版本。发行版页面上提供了发行二进制文件。

在MacOS上，您可以使用Homebrew安装或升级到最新发布的版本：

$ brew install dep
$ brew upgrade dep

在其他平台上，您可以使用install.sh脚本：

$ curl https://raw.githubusercontent.com/golang/dep/master/install.sh | sh

它将默认安装到$GOPATH/bin目录或使用INSTALL_DIRECTORY环境变量指定的任何其他目录。

如果您的平台不支持，您需要手动构建它或让团队知道，我们会考虑将您的平台添加到发布版本中。

如果你对dep兴趣，你可以通过go get安装：

go get -u github.com/golang/dep/cmd/dep

TODO