mirror of https://github.com/k3s-io/k3s
Remove third_party/forked/godep
Jordan Liggitt
parent
b3527f41f0
commit
7f246d461b
|
|
@ -404,34 +404,6 @@ kube::util::ensure_clean_working_dir() {
|
|||
done 1>&2
|
||||
}
|
||||
|
||||
# Ensure that the given godep version is installed and in the path. Almost
|
||||
# nobody should use any version but the default.
|
||||
#
|
||||
# Sets:
|
||||
# KUBE_GODEP: The path to the godep binary
|
||||
#
|
||||
kube::util::ensure_godep_version() {
|
||||
local godep_target_version=${1:-"v80-k8s-r1"} # this version is known to work
|
||||
|
||||
# If KUBE_GODEP is already set, and it's the right version, then use it.
|
||||
if [[ -n "${KUBE_GODEP:-}" && "$(${KUBE_GODEP:?} version 2>/dev/null)" == *"godep ${godep_target_version}"* ]]; then
|
||||
kube::log::status "Using ${KUBE_GODEP}"
|
||||
return
|
||||
fi
|
||||
|
||||
# Otherwise, install forked godep
|
||||
kube::log::status "Installing godep version ${godep_target_version}"
|
||||
GOBIN="${KUBE_OUTPUT_BINPATH}" go install k8s.io/kubernetes/third_party/forked/godep
|
||||
export KUBE_GODEP="${KUBE_OUTPUT_BINPATH}/godep"
|
||||
kube::log::status "Installed ${KUBE_GODEP}"
|
||||
|
||||
# Verify that the installed godep from fork is what we expect
|
||||
if [[ "$(${KUBE_GODEP:?} version 2>/dev/null)" != *"godep ${godep_target_version}"* ]]; then
|
||||
kube::log::error "Expected godep ${godep_target_version} from ${KUBE_GODEP}, got $(${KUBE_GODEP:?} version)"
|
||||
return 1
|
||||
fi
|
||||
}
|
||||
|
||||
# Ensure that none of the staging repos is checked out in the GOPATH because this
|
||||
# easily confused godep.
|
||||
kube::util::ensure_no_staging_repos_in_gopath() {
|
||||
|
|
|
|||
|
|
@ -22,7 +22,6 @@ filegroup(
|
|||
"//third_party/forked/etcd221/wal:all-srcs",
|
||||
"//third_party/forked/etcd237/pkg/fileutil:all-srcs",
|
||||
"//third_party/forked/etcd237/wal:all-srcs",
|
||||
"//third_party/forked/godep:all-srcs",
|
||||
"//third_party/forked/golang/expansion:all-srcs",
|
||||
"//third_party/forked/golang/reflect:all-srcs",
|
||||
"//third_party/forked/golang/template:all-srcs",
|
||||
|
|
|
|||
|
|
@ -1 +0,0 @@
|
|||
/godep
|
||||
|
|
@ -1,34 +0,0 @@
|
|||
language: go
|
||||
sudo: false
|
||||
go: 1.6
|
||||
script:
|
||||
# Godep's unit tests run git, and git complains
|
||||
# if we don't set these config parameters.
|
||||
# We put dummy values here because they don't matter.
|
||||
- git config --global user.email "you@example.com"
|
||||
- git config --global user.name "Your Name"
|
||||
- test -z "$(go fmt)"
|
||||
- go vet
|
||||
- go test -v
|
||||
- go test -v -race
|
||||
- test -z "$(goimports -l .)"
|
||||
before_install:
|
||||
- go get golang.org/x/tools/cmd/goimports
|
||||
before_deploy:
|
||||
- export OS_TARGETS="linux darwin windows"
|
||||
- export ARCH_TARGETS="386 amd64"
|
||||
- go get github.com/mitchellh/gox
|
||||
- gox -os "$OS_TARGETS" -arch="$ARCH_TARGETS"
|
||||
deploy:
|
||||
skip_cleanup: true
|
||||
provider: releases
|
||||
api_key:
|
||||
secure: Q1JP8LziaXMTxFmNXiyC1YhS9e4M4WnI6UDjRTMf6mm1LZeJyUFOCCtXnifL7RyCIR1hpjp6s8M1aWE+NpuweF96IZI3Uk4ASx5C8FePC4qvhsCdtJ2sLD2GTIrp9b0MS9/+ao20AIbpVDSaLaF9IjqXpMxMyM0P8P5coRTkwItlGxmQbVJW3YuiYcPa8UojwM4EyafO2CIoUKapW8lwb9KcimBJV8PfF/XZjPVhMkn2ABhh5Hqbn2zBJtvPYMMzi0CnY50JQF5LwN3vGTMpTsRP+lOLCNbOWfkl+2hgG7VpKrtx+cX62knOodpF457sIJ31KUzmeLUVBejTGb1zuVeTojuyi8Huo8YBIBCcN+p3Dqd+n2ZK45mIrheGiEJIkf/vI4MI6A01Nu/o+xU0IPsVfAL/xU5j5nntEGfFWVoclPrl9qcfqf74xdRcARzcCJVmdc8iw49DBDHJfnPa3zxzVz//00+Rz6mZXmhk+Npk/HLLNW59vmJIjP+8XOtPor7dST9HrS1a9AcnmIjNuw9yfbwK5769SDVxCKgqNwXW/Dy5F39aIH5AL4I4y9hCEeeT8ctvSJHGOyiB9MWU5jnt5tluPtz5opG51tFXnIYP/XaWpTfO+eJ6x55pbwT+n3LfRS5l1POM+jGAFF1MFWwc14RY7qynEIEzm4Wb/UE=
|
||||
file:
|
||||
- godep_darwin_amd64
|
||||
- godep_linux_amd64
|
||||
- godep_windows_386.exe
|
||||
- godep_windows_amd64.exe
|
||||
on:
|
||||
tags: true
|
||||
repo: tools/godep
|
||||
|
|
@ -1,57 +0,0 @@
|
|||
load("@io_bazel_rules_go//go:def.bzl", "go_binary", "go_library")
|
||||
|
||||
licenses(["notice"])
|
||||
|
||||
go_library(
|
||||
name = "go_default_library",
|
||||
srcs = [
|
||||
"dep.go",
|
||||
"diff.go",
|
||||
"doc.go",
|
||||
"errors.go",
|
||||
"get.go",
|
||||
"go.go",
|
||||
"godepfile.go",
|
||||
"license.go",
|
||||
"list.go",
|
||||
"main.go",
|
||||
"msg.go",
|
||||
"path.go",
|
||||
"pkg.go",
|
||||
"restore.go",
|
||||
"rewrite.go",
|
||||
"save.go",
|
||||
"update.go",
|
||||
"util.go",
|
||||
"vcs.go",
|
||||
"version.go",
|
||||
],
|
||||
importpath = "k8s.io/kubernetes/third_party/forked/godep",
|
||||
visibility = ["//visibility:private"],
|
||||
deps = [
|
||||
"//vendor/github.com/kr/fs:go_default_library",
|
||||
"//vendor/github.com/kr/pretty:go_default_library",
|
||||
"//vendor/github.com/pmezard/go-difflib/difflib:go_default_library",
|
||||
"//vendor/golang.org/x/tools/go/vcs:go_default_library",
|
||||
],
|
||||
)
|
||||
|
||||
go_binary(
|
||||
name = "godep",
|
||||
embed = [":go_default_library"],
|
||||
visibility = ["//visibility:public"],
|
||||
)
|
||||
|
||||
filegroup(
|
||||
name = "package-srcs",
|
||||
srcs = glob(["**"]),
|
||||
tags = ["automanaged"],
|
||||
visibility = ["//visibility:private"],
|
||||
)
|
||||
|
||||
filegroup(
|
||||
name = "all-srcs",
|
||||
srcs = [":package-srcs"],
|
||||
tags = ["automanaged"],
|
||||
visibility = ["//visibility:public"],
|
||||
)
|
||||
|
|
@ -1,412 +0,0 @@
|
|||
#v80 (2018/01/26)
|
||||
|
||||
* Address lin/vet feedback.
|
||||
|
||||
#v79 (2017/02/01)
|
||||
|
||||
* Fixes #531: fullPackageInDir didn't capture the error from fillPackage()
|
||||
|
||||
#v78 (2017/01/19)
|
||||
|
||||
* Don't use build.ImportDir when discovering packages for the package spec. Fixes #529
|
||||
|
||||
#v77 (2017/01/13)
|
||||
|
||||
* Don't include quotes around hg revisions
|
||||
|
||||
#v76 (2017/01/10)
|
||||
|
||||
* Default to vendor being on unless older go versions.
|
||||
|
||||
#v75 (2016/11/02)
|
||||
|
||||
* Add "AUTHORS" and "CONTRIBUTORS" to legal files list: https://github.com/tools/godep/pull/522
|
||||
|
||||
#v74 (2016/06/01)
|
||||
|
||||
* Enable vendor/ on go1.7
|
||||
* No longer use a godep workspace, use vendor/ (yay!)
|
||||
* Notify that support for Godep workspaces will be removed once go1.8 ships
|
||||
|
||||
#v73 (2016/05/31)
|
||||
|
||||
* Fix permission changes on Windows via @alexbrand. Closes #481.
|
||||
|
||||
#v72 (2016/05/27)
|
||||
|
||||
* Improve handling of git remote show origin. Should help in cases where remote HEAD is ambiguous.
|
||||
* Add ISSUE_TEMPLATE
|
||||
|
||||
#v71 (2016/05/24)
|
||||
|
||||
* Preserve permissions on copied files.
|
||||
|
||||
#v70 (2016/05/20)
|
||||
|
||||
* Fix the May changelog dates
|
||||
* No need to call build.Import, we already have the root of the dependency. Fixes an additional comment on #365
|
||||
|
||||
#v69 (2016/05/16)
|
||||
|
||||
* Make sure `devel-<short sha>` enabled `vendor/` unless there is a classic Godep _workspace already.
|
||||
|
||||
#v68 (2016/05/16)
|
||||
|
||||
* `devel-<short sha>` is always considered newer than any released go version
|
||||
|
||||
#v67 (2016/05/13)
|
||||
|
||||
* Attempt to handle missing deps a little better.
|
||||
|
||||
#v66 (2016/05/10)
|
||||
|
||||
* Use `git remote show origin` to find the default branch when restoring a git based package repository that is in detached head state
|
||||
|
||||
#v65 (2016/05/09)
|
||||
|
||||
* Rewrite update so that it considers new transitive dependencies, both in the same repo and outside of it.
|
||||
|
||||
#v64 (2016/05/09)
|
||||
|
||||
* godep update golang.org/x/tools/go/vcs
|
||||
|
||||
#v63 (2016/05/03)
|
||||
|
||||
* Support recording devel-<short sha> so development versions of Go can be matched
|
||||
|
||||
#v62 (2016/04/07)
|
||||
|
||||
* Note new go1.6+ behavior of not checking out master in README / restore help text.
|
||||
|
||||
#v61 (2016/04/06)
|
||||
|
||||
* Obey go version build tags based on recorded major go version. Fixes #448.
|
||||
|
||||
#v60 (2016/03/18)
|
||||
|
||||
* Make the $GOPATH check a warning.
|
||||
|
||||
#v59 (2016/03/18)
|
||||
|
||||
* Enforce requirement to be inside of a go src directory. A lot of time is usually spent
|
||||
tracking down bug reports where people are doign stuff from outside of their $GOPATH. This
|
||||
should help with that, at least until there it time to properly test godep use outside of a
|
||||
$GOPATH and fix the issues.
|
||||
|
||||
#v58 (2016/03/15)
|
||||
|
||||
* Add GodepVersion to Godeps.json file so that as godep changes / adds features / fixes bugs we can know which version of godep most recently wrote out the file.
|
||||
|
||||
#v57 (2016/03/07)
|
||||
|
||||
* Don't use `git rev-parse --show-toplevel` to determine git repo roots as it resolves symlinks: https://github.com/tools/godep/pull/418
|
||||
|
||||
# v56 (2016/02/26)
|
||||
|
||||
* replace path comparisons with case insensitive pathEqual()
|
||||
* add versionString() to debug output
|
||||
* Send log output to Stderr
|
||||
|
||||
# v55 2016/02/22
|
||||
|
||||
* re-saved deps to clean out extra stuff (see v54; godep restore; godep save -r=false; rm -rf Godeps; godep save -r). We're still using a workspace with rewrites so users of older go version can still go get this tool.
|
||||
* Replace simple == with strings.EqualFold in listFiles to avoid problems with case insensitive filesystems ("Code" != "code" when doing a byte by byte comparison)
|
||||
|
||||
# v54 2016/02/22
|
||||
|
||||
* Update some docs around vendor/
|
||||
* More precise recording of dependencies. Removed recursive copying of sub directories of a package (precise vendoring). This should allow using `./...` with the go tool for compilation of project using `vendor/`. See https://github.com/tools/godep/pull/415
|
||||
|
||||
# v53 2016/02/11
|
||||
|
||||
* Disable VendorExperiment if a godep workspace already exists.
|
||||
|
||||
# v52 2016/01/27
|
||||
|
||||
* Trim 'rc' out of go version strings when determining major version.
|
||||
|
||||
# v51 2016/01/21
|
||||
|
||||
* Trim 'beta' out of go version strings when determining major version.
|
||||
|
||||
# v50 2016/01/19
|
||||
|
||||
* More verbose output on save -v.
|
||||
|
||||
# v49 2016/01/13
|
||||
|
||||
* Add UK spelling license/licence to the pile + fix up a bunch of typos
|
||||
* Clarify tag handling in docs
|
||||
|
||||
# v48 2016/01/13
|
||||
|
||||
* Abort restore if there is no $GOPATH set.
|
||||
|
||||
# v47 2016/01/12
|
||||
|
||||
* Dev versions of go should honor the current meaning of GO15VENDOREXPERIMENT
|
||||
|
||||
# v46 2016/01/03
|
||||
|
||||
* Record "devel" when the release is a devel release of go (compiled from git).
|
||||
|
||||
# v45 2015/12/28
|
||||
|
||||
* Upcase windows drive letters before comparing. Fixes #383.
|
||||
|
||||
# v44 2015/12/23
|
||||
|
||||
* Clean package roots when attempting to find a vendor directory so we don't loop forever.
|
||||
* Fixes 382
|
||||
|
||||
# v43 2015/12/22
|
||||
|
||||
* Better error messages when parsing Godeps.json: Fixes #372
|
||||
|
||||
# v42 2015/12/22
|
||||
|
||||
* Fix a bunch of GO15VENDOREXPERIMENT issues
|
||||
* Find package directories better. Previously we used build.FindOnly which didn't work the way I expected it to (any dir would work w/o error).
|
||||
* Set the VendorExperiment bool based on go version as 1.6 defaults to on.
|
||||
* A bunch of extra debugging for use while sanity checking myself.
|
||||
* vendor flag for test structs.
|
||||
* Some tests for vendor/ stuff:
|
||||
* Basic Test
|
||||
* Transitive
|
||||
* Transitive, across GOPATHs + collapse vendor/ directories.
|
||||
* Should Fix #358
|
||||
|
||||
# v41 2015/12/17
|
||||
|
||||
* Don't rewrite packages outside of the project. This would happen if you specified
|
||||
an external package for vendoring when you ran `goodep save -r ./... github.com/some/other/package`
|
||||
|
||||
# v40 2015/12/17
|
||||
|
||||
* When downloading a dependency, create the base directory if needed.
|
||||
|
||||
# v39 2015/12/16
|
||||
|
||||
* Record only the major go version (ex. go1.5) instead of the complete string.
|
||||
|
||||
# v38 2015/12/16
|
||||
|
||||
* Replace `go get`, further fix up restore error handling/reporting.
|
||||
* Fixes #186
|
||||
* Don't bother restoring/downloading if already done.
|
||||
|
||||
# v37 2015/12/15
|
||||
|
||||
* Change up how download/restore works a little
|
||||
* Try to load the package after downloading/restoring. Previously
|
||||
that was done too early in the process.
|
||||
* make previous verbose output debug output
|
||||
* report a typed error instead of a string from listPackage so it can
|
||||
be asserted to provide a nicer error.
|
||||
* Catch go get errors that say there are no go files found. See code
|
||||
comment as to why.
|
||||
* do *all* downloading during download phase.
|
||||
|
||||
# v36 2015/12/14
|
||||
|
||||
* Fixes #358: Using wrong variable. Will add test after release.
|
||||
|
||||
# v35 2015/12/11
|
||||
|
||||
* Fixes #356: Major performance regressions in v34
|
||||
* Enable cpu profiling via flag on save.
|
||||
* Cache packages by dir
|
||||
* Don't do a full import pass on deps for packages in the GOROOT
|
||||
* create a bit less garbage at times
|
||||
* Generalize -v & -d flags
|
||||
|
||||
# v34 2015/12/08
|
||||
|
||||
* We now use build.Context to help locate packages only and do our own parsing (via go/ast).
|
||||
* Fixes reported issues caused by v33 (Removal of `go list`):
|
||||
* #345: Bug in godep restore
|
||||
* #346: Fix loading a dot package
|
||||
* #348: Godep save issue when importing lib/pq
|
||||
* #350: undefined: build.MultiplePackageError
|
||||
* #351: stow away helper files
|
||||
* #353: cannot find package "appengine"
|
||||
* Don't process imports of `.go` files tagged with the `appengine` build tag.
|
||||
|
||||
# v33 2015/12/07
|
||||
|
||||
* Replace the use of `go list`. This is a large change although all existing tests pass.
|
||||
* Don't process the imports of `.go` files with the `ignore` build tag.
|
||||
|
||||
# v32 2015/12/02
|
||||
|
||||
* Eval Symlinks in Contains() check.
|
||||
|
||||
# v31 2015/12/02
|
||||
|
||||
* In restore, mention which package had the problem -- @shurcool
|
||||
|
||||
# v30 2015/11/25
|
||||
|
||||
* Add `-t` flag to the `godep get` command.
|
||||
|
||||
# v29 2015/11/17
|
||||
|
||||
* Temp work around to fix issue with LICENSE files.
|
||||
|
||||
# v28 2015/11/09
|
||||
|
||||
* Make `version` an actual command.
|
||||
|
||||
# v27 2015/11/06
|
||||
|
||||
* run command once during restore -v
|
||||
|
||||
# v26 2015/11/05
|
||||
|
||||
* Better fix for the issue fixed in v25: All update paths are now path.Clean()'d
|
||||
|
||||
# v25 2015/11/05
|
||||
|
||||
* `godep update package/` == `godep update package`. Fixes #313
|
||||
|
||||
# v24 2015/11/05
|
||||
|
||||
* Honor -t during update. Fixes #312
|
||||
|
||||
# v23 2015/11/05
|
||||
|
||||
* Do not use --debug to find full revision name for mercurial repositories
|
||||
|
||||
# v22 2015/11/14
|
||||
|
||||
* s/GOVENDOREXPERIMENT/GO15VENDOREXPERIMENT :-(
|
||||
|
||||
# v21 2015/11/13
|
||||
|
||||
* Fix #310: Case insensitive fs issue
|
||||
|
||||
# v20 2015/11/13
|
||||
|
||||
* Attempt to include license files when vendoring. (@client9)
|
||||
|
||||
# v19 2015/11/3
|
||||
|
||||
* Fix conflict error message. Revisions were swapped. Also better selection of package that needs update.
|
||||
|
||||
# v18 2015/10/16
|
||||
|
||||
* Improve error message when trying to save a conflicting revision.
|
||||
|
||||
# v17 2015/10/15
|
||||
|
||||
* Fix for v16 bug. All vcs list commands now produce paths relative to the root of the vcs.
|
||||
|
||||
# v16 2015/10/15
|
||||
|
||||
* Determine repo root using vcs commands and use that instead of dep.dir
|
||||
|
||||
# v15 2015/10/14
|
||||
|
||||
* Update .travis.yml file to do releases to github
|
||||
|
||||
# v14 2015/10/08
|
||||
|
||||
* Don't print out a workspace path when GO15VENDOREXPERIMENT is active. The vendor/ directory is not a valid workspace, so can't be added to your $GOPATH.
|
||||
|
||||
# v13 2015/10/07
|
||||
|
||||
* Do restores in 2 separate steps, first download all deps and then check out the recorded revisions.
|
||||
* Update Changelog date format
|
||||
|
||||
# v12 2015/09/22
|
||||
|
||||
* Extract errors into separate file.
|
||||
|
||||
# v11 2015/08/22
|
||||
|
||||
* Amend code to pass golint.
|
||||
|
||||
# v10 2015/09/21
|
||||
|
||||
* Analyse vendored package test dependencies.
|
||||
* Update documentation.
|
||||
|
||||
# v9 2015/09/17
|
||||
|
||||
* Don't save test dependencies by default.
|
||||
|
||||
# v8 2015/09/17
|
||||
|
||||
* Reorganize code.
|
||||
|
||||
# v7 2015/09/09
|
||||
|
||||
* Add verbose flag.
|
||||
* Skip untracked files.
|
||||
* Add VCS list command.
|
||||
|
||||
# v6 2015/09/04
|
||||
|
||||
* Revert ignoring testdata directories and instead ignore it while
|
||||
processing Go files and copy the whole directory unmodified.
|
||||
|
||||
# v5 2015/09/04
|
||||
|
||||
* Fix vcs selection in restore command to work as go get does
|
||||
|
||||
# v4 2015/09/03
|
||||
|
||||
* Remove the deprecated copy option.
|
||||
|
||||
# v3 2015/08/26
|
||||
|
||||
* Ignore testdata directories
|
||||
|
||||
# v2 2015/08/11
|
||||
|
||||
* Include command line packages in the set to copy
|
||||
|
||||
This is a simplification to how we define the behavior
|
||||
of the save command. Now it has two distinct package
|
||||
parameters, the "root set" and the "destination", and
|
||||
they have clearer roles. The packages listed on the
|
||||
command line form the root set; they and all their
|
||||
dependencies will be copied into the Godeps directory.
|
||||
Additionally, the destination (always ".") will form the
|
||||
initial list of "seen" import paths to exclude from
|
||||
copying.
|
||||
|
||||
In the common case, the root set is equal to the
|
||||
destination, so the effective behavior doesn't change.
|
||||
This is primarily just a simpler definition. However, if
|
||||
the user specifies a package on the command line that
|
||||
lives outside of . then that package will be copied.
|
||||
|
||||
As a side effect, there's a simplification to the way we
|
||||
add packages to the initial "seen" set. Formerly, to
|
||||
avoid copying dependencies unnecessarily, we would try
|
||||
to find the root of the VCS repo for each package in the
|
||||
root set, and mark the import path of the entire repo as
|
||||
seen. This meant for a repo at path C, if destination
|
||||
C/S imports C/T, we would not copy C/T into C/S/Godeps.
|
||||
Now we don't treat the repo root specially, and as
|
||||
mentioned above, the destination alone is considered
|
||||
seen.
|
||||
|
||||
This also means we don't require listed packages to be
|
||||
in VCS unless they're outside of the destination.
|
||||
|
||||
# v1 2015/07/20
|
||||
|
||||
* godep version command
|
||||
|
||||
Output the version as well as some godep runtime information that is
|
||||
useful for debugging user's issues.
|
||||
|
||||
The version const would be bumped each time a PR is merged into master
|
||||
to ensure that we'll be able to tell which version someone got when they
|
||||
did a `go get github.com/tools/godep`.
|
||||
|
||||
# Older changes
|
||||
|
||||
Many and more, see `git log -p`
|
||||
|
|
@ -1,22 +0,0 @@
|
|||
## Why do I need to check in `vendor/`?
|
||||
|
||||
godep's primary concern is to allow you to repeatably build your project. Your
|
||||
dependencies are part of that project. Without them it won't build. Not
|
||||
committing `vendor/` adds additional external dependencies that are outside of
|
||||
your control. In Go, fetching packages is tied to multiple external systems
|
||||
(DNS, web servers, etc). Over time other developers or code hosting sites may
|
||||
discontinue service, delete code, force push, or take any number of other
|
||||
actions that may make a package unreachable. Therefore it's the opinion of the
|
||||
godep authors that `vendor/` should always be checked in.
|
||||
|
||||
## Should I use `godep restore`?
|
||||
|
||||
Probably not, unless you **need** to. Situations where you would **need** to are:
|
||||
|
||||
1. Using older Godep Workspaces (`Godeps/_workspace`) and not using `godep go
|
||||
<cmd>`.
|
||||
1. Resetting the state of $GOPATH to what is in your `Godeps.json` file in order
|
||||
to cleanly re-vendor everything w/o upgrading/changing any deps. This is
|
||||
useful when [migrating](https://github.com/tools/godep#migrating-to-vendor)
|
||||
from workspaces to `vendor` or when a bug is fixed in `godep` that cleans up
|
||||
a previous vendoring error.
|
||||
|
|
@ -1,28 +0,0 @@
|
|||
Copyright © 2013 Keith Rarick.
|
||||
Portions Copyright (c) 2012 The Go Authors. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are
|
||||
met:
|
||||
|
||||
* Redistributions of source code must retain the above copyright
|
||||
notice, this list of conditions and the following disclaimer.
|
||||
* Redistributions in binary form must reproduce the above
|
||||
copyright notice, this list of conditions and the following disclaimer
|
||||
in the documentation and/or other materials provided with the
|
||||
distribution.
|
||||
* Neither the name of Google Inc. nor the names of its
|
||||
contributors may be used to endorse or promote products derived from
|
||||
this software without specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
|
@ -1,209 +0,0 @@
|
|||
# Godep - Archived
|
||||
|
||||
Please use [dep](https://github.com/golang/dep) or another tool instead.
|
||||
|
||||
The rest of this readme is preserved for those that may still need its contents.
|
||||
|
||||
[](https://travis-ci.org/tools/godep)
|
||||
|
||||
[](https://godoc.org/github.com/tools/godep)
|
||||
|
||||
godep helps build packages reproducibly by fixing their dependencies.
|
||||
|
||||
This tool assumes you are working in a standard Go workspace, as described [here](http://golang.org/doc/code.html). We
|
||||
expect godep to build on Go 1.4* or newer, but you can use it on any project that works with Go 1 or newer.
|
||||
|
||||
Please check the [FAQ](FAQ.md) if you have a question.
|
||||
|
||||
## Golang Dep
|
||||
|
||||
The Go community now has the [dep](https://github.com/golang/dep) project to
|
||||
manage dependencies. Please consider trying to migrate from Godep to dep. If there
|
||||
is an issue preventing you from migrating please file an issue with dep so the
|
||||
problem can be corrected. Godep will continue to be supported for some time but
|
||||
is considered to be in a state of support rather than active feature development.
|
||||
|
||||
## Install
|
||||
|
||||
```console
|
||||
go get github.com/tools/godep
|
||||
```
|
||||
|
||||
## How to use godep with a new project
|
||||
|
||||
Assuming you've got everything working already, so you can build your project
|
||||
with `go install` and test it with `go test`, it's one command to start using:
|
||||
|
||||
```console
|
||||
godep save
|
||||
```
|
||||
|
||||
This will save a list of dependencies to the file `Godeps/Godeps.json` and copy
|
||||
their source code into `vendor/` (or `Godeps/_workspace/` when using older
|
||||
versions of Go). Godep does **not copy**:
|
||||
|
||||
- files from source repositories that are not tracked in version control.
|
||||
- `*_test.go` files.
|
||||
- `testdata` directories.
|
||||
- files outside of the go packages.
|
||||
|
||||
Godep does not process the imports of `.go` files with either the `ignore`
|
||||
or `appengine` build tags.
|
||||
|
||||
Test files and testdata directories can be saved by adding `-t`.
|
||||
|
||||
Read over the contents of `vendor/` and make sure it looks reasonable. Then
|
||||
commit the `Godeps/` and `vendor/` directories to version control.
|
||||
|
||||
## The deprecated `-r` flag
|
||||
|
||||
For older versions of Go, the `-r` flag tells save to automatically rewrite
|
||||
package import paths. This allows your code to refer directly to the copied
|
||||
dependencies in `Godeps/_workspace`. So, a package C that depends on package
|
||||
D will actually import `C/Godeps/_workspace/src/D`. This makes C's repo
|
||||
self-contained and causes `go get` to build C with the right version of all
|
||||
dependencies.
|
||||
|
||||
If you don't use `-r`, when using older version of Go, then in order to use the
|
||||
fixed dependencies and get reproducible builds, you must make sure that **every
|
||||
time** you run a Go-related command, you wrap it in one of these two ways:
|
||||
|
||||
- If the command you are running is just `go`, run it as `godep go ...`, e.g.
|
||||
`godep go install -v ./...`
|
||||
- When using a different command, set your `$GOPATH` using `godep path` as
|
||||
described below.
|
||||
|
||||
`-r` isn't necessary with go1.6+ and isn't allowed.
|
||||
|
||||
## Additional Operations
|
||||
|
||||
### Restore
|
||||
|
||||
The `godep restore` installs the
|
||||
package versions specified in `Godeps/Godeps.json` to your `$GOPATH`. This
|
||||
modifies the state of packages in your `$GOPATH`. NOTE: `godep restore` leaves
|
||||
git repositories in a detached state. `go1.6`+ no longer checks out the master
|
||||
branch when doing a `go get`, see [here](https://github.com/golang/go/commit/42206598671a44111c8f726ad33dc7b265bdf669).
|
||||
|
||||
> If you run `godep restore` in your main `$GOPATH` `go get -u` will fail on packages that are behind master.
|
||||
|
||||
Please see the [FAQ](https://github.com/tools/godep/blob/master/FAQ.md#should-i-use-godep-restore) section about restore.
|
||||
|
||||
### Edit-test Cycle
|
||||
|
||||
1. Edit code
|
||||
1. Run `godep go test`
|
||||
1. (repeat)
|
||||
|
||||
### Add a Dependency
|
||||
|
||||
To add a new package foo/bar, do this:
|
||||
|
||||
1. Run `go get foo/bar`
|
||||
1. Edit your code to import foo/bar.
|
||||
1. Run `godep save` (or `godep save ./...`).
|
||||
|
||||
### Update a Dependency
|
||||
|
||||
To update a package from your `$GOPATH`, do this:
|
||||
|
||||
1. Run `go get -u foo/bar`
|
||||
1. Run `godep update foo/bar`.
|
||||
|
||||
You can use the `...` wildcard, for example `godep update foo/...`. Before comitting the change, you'll probably want to
|
||||
inspect the changes to Godeps, for example with `git diff`, and make sure it looks reasonable.
|
||||
|
||||
## Multiple Packages
|
||||
|
||||
If your repository has more than one package, you're probably accustomed to
|
||||
running commands like `go test ./...`, `go install ./...`, and `go fmt ./...`.
|
||||
Similarly, you should run `godep save ./...` to capture the dependencies of all
|
||||
packages in your application.
|
||||
|
||||
## File Format
|
||||
|
||||
Godeps is a json file with the following structure:
|
||||
|
||||
```go
|
||||
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.
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
Example Godeps:
|
||||
|
||||
```json
|
||||
{
|
||||
"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"
|
||||
}
|
||||
]
|
||||
}
|
||||
```
|
||||
|
||||
## Migrating to vendor/
|
||||
|
||||
Godep supports the Go 1.5+ vendor/
|
||||
[experiment](https://github.com/golang/go/commit/183cc0cd41f06f83cb7a2490a499e3f9101befff)
|
||||
utilizing the same environment variable that the go tooling itself supports
|
||||
(`GO15VENDOREXPERIMENT`).
|
||||
|
||||
godep mostly works the same way as the `go` command line tool. If you have go
|
||||
1.5.X and set `GO15VENDOREXPERIMENT=1` or have go1.6.X (or devel) `vendor/`
|
||||
is enabled. **Unless** you already have a `Godeps/_workspace`. This is a safety
|
||||
feature and godep warns you about this.
|
||||
|
||||
When `vendor/` is enabled godep will write the vendored code into the top level
|
||||
`./vendor/` directory. A `./Godeps/Godeps.json` file is created to track
|
||||
the dependencies and revisions. `vendor/` is not compatible with rewrites.
|
||||
|
||||
There is currently no automated migration between the old Godeps workspace and
|
||||
the vendor directory, but the following steps should work:
|
||||
|
||||
```term
|
||||
# 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/.
|
||||
```
|
||||
|
||||
## Releasing
|
||||
|
||||
1. Increment the version in `version.go`.
|
||||
1. Tag the commit with the same version number.
|
||||
1. Update `Changelog.md`.
|
||||
|
|
@ -1,128 +0,0 @@
|
|||
package main
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"os"
|
||||
"os/exec"
|
||||
"sort"
|
||||
"strings"
|
||||
)
|
||||
|
||||
// A Dependency is a specific revision of a package.
|
||||
type Dependency struct {
|
||||
ImportPath string
|
||||
Comment string `json:",omitempty"` // Description of commit, if present.
|
||||
Rev string // VCS-specific commit ID.
|
||||
|
||||
// used by command save & update
|
||||
ws string // workspace
|
||||
root string // import path to repo root
|
||||
dir string // full path to package
|
||||
|
||||
// used by command update
|
||||
matched bool // selected for update by command line
|
||||
pkg *Package
|
||||
missing bool // packages is missing
|
||||
|
||||
// used by command go
|
||||
vcs *VCS
|
||||
}
|
||||
|
||||
func eqDeps(a, b []Dependency) bool {
|
||||
ok := true
|
||||
for _, da := range a {
|
||||
for _, db := range b {
|
||||
if da.ImportPath == db.ImportPath && da.Rev != db.Rev {
|
||||
ok = false
|
||||
}
|
||||
}
|
||||
}
|
||||
return ok
|
||||
}
|
||||
|
||||
// containsPathPrefix returns whether any string in a
|
||||
// is s or a directory containing s.
|
||||
// For example, pattern ["a"] matches "a" and "a/b"
|
||||
// (but not "ab").
|
||||
func containsPathPrefix(pats []string, s string) bool {
|
||||
for _, pat := range pats {
|
||||
if pat == s || strings.HasPrefix(s, pat+"/") {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
func uniq(a []string) []string {
|
||||
var s string
|
||||
var i int
|
||||
if !sort.StringsAreSorted(a) {
|
||||
sort.Strings(a)
|
||||
}
|
||||
for _, t := range a {
|
||||
if t != s {
|
||||
a[i] = t
|
||||
i++
|
||||
s = t
|
||||
}
|
||||
}
|
||||
return a[:i]
|
||||
}
|
||||
|
||||
// trimGoVersion and return the major version
|
||||
func trimGoVersion(version string) (string, error) {
|
||||
if version == "devel" {
|
||||
return "devel", nil
|
||||
}
|
||||
if strings.HasPrefix(version, "devel+") || strings.HasPrefix(version, "devel-") {
|
||||
return strings.Replace(version, "devel+", "devel-", 1), nil
|
||||
}
|
||||
p := strings.Split(version, ".")
|
||||
if len(p) < 2 {
|
||||
return "", fmt.Errorf("Error determining major go version from: %q", version)
|
||||
}
|
||||
var split string
|
||||
switch {
|
||||
case strings.Contains(p[1], "beta"):
|
||||
split = "beta"
|
||||
case strings.Contains(p[1], "rc"):
|
||||
split = "rc"
|
||||
}
|
||||
if split != "" {
|
||||
p[1] = strings.Split(p[1], split)[0]
|
||||
}
|
||||
return p[0] + "." + p[1], nil
|
||||
}
|
||||
|
||||
var goVersionTestOutput = ""
|
||||
|
||||
func getGoVersion() (string, error) {
|
||||
// For testing purposes only
|
||||
if goVersionTestOutput != "" {
|
||||
return goVersionTestOutput, nil
|
||||
}
|
||||
|
||||
// Godep might have been compiled with a different
|
||||
// version, so we can't just use runtime.Version here.
|
||||
cmd := exec.Command("go", "version")
|
||||
cmd.Stderr = os.Stderr
|
||||
out, err := cmd.Output()
|
||||
return string(out), err
|
||||
}
|
||||
|
||||
// goVersion returns the major version string of the Go compiler
|
||||
// currently installed, e.g. "go1.5".
|
||||
func goVersion() (string, error) {
|
||||
out, err := getGoVersion()
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
gv := strings.Split(out, " ")
|
||||
if len(gv) < 4 {
|
||||
return "", fmt.Errorf("Error splitting output of `go version`: Expected 4 or more elements, but there are < 4: %q", out)
|
||||
}
|
||||
if gv[2] == "devel" {
|
||||
return trimGoVersion(gv[2] + gv[3])
|
||||
}
|
||||
return trimGoVersion(gv[2])
|
||||
}
|
||||
|
|
@ -1,74 +0,0 @@
|
|||
package main
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"fmt"
|
||||
"log"
|
||||
|
||||
"github.com/pmezard/go-difflib/difflib"
|
||||
)
|
||||
|
||||
var cmdDiff = &Command{
|
||||
Name: "diff",
|
||||
Short: "shows the diff between current and previously saved set of dependencies",
|
||||
Long: `
|
||||
Shows the difference, in a unified diff format, between the
|
||||
current set of dependencies and those generated on a
|
||||
previous 'go save' execution.
|
||||
`,
|
||||
Run: runDiff,
|
||||
OnlyInGOPATH: true,
|
||||
}
|
||||
|
||||
func runDiff(cmd *Command, args []string) {
|
||||
gold, err := loadDefaultGodepsFile()
|
||||
if err != nil {
|
||||
log.Fatalln(err)
|
||||
}
|
||||
|
||||
pkgs := []string{"."}
|
||||
dot, err := LoadPackages(pkgs...)
|
||||
if err != nil {
|
||||
log.Fatalln(err)
|
||||
}
|
||||
|
||||
gnew := &Godeps{
|
||||
ImportPath: dot[0].ImportPath,
|
||||
GoVersion: gold.GoVersion,
|
||||
}
|
||||
|
||||
err = gnew.fill(dot, dot[0].ImportPath)
|
||||
if err != nil {
|
||||
log.Fatalln(err)
|
||||
}
|
||||
|
||||
diff, err := diffStr(&gold, gnew)
|
||||
if err != nil {
|
||||
log.Fatalln(err)
|
||||
}
|
||||
fmt.Println(diff)
|
||||
}
|
||||
|
||||
// diffStr returns a unified diff string of two Godeps.
|
||||
func diffStr(a, b *Godeps) (string, error) {
|
||||
var ab, bb bytes.Buffer
|
||||
|
||||
_, err := a.writeTo(&ab)
|
||||
if err != nil {
|
||||
log.Fatalln(err)
|
||||
}
|
||||
|
||||
_, err = b.writeTo(&bb)
|
||||
if err != nil {
|
||||
log.Fatalln(err)
|
||||
}
|
||||
|
||||
diff := difflib.UnifiedDiff{
|
||||
A: difflib.SplitLines(ab.String()),
|
||||
B: difflib.SplitLines(bb.String()),
|
||||
FromFile: b.file(),
|
||||
ToFile: "$GOPATH",
|
||||
Context: 10,
|
||||
}
|
||||
return difflib.GetUnifiedDiffString(diff)
|
||||
}
|
||||
|
|
@ -1,22 +0,0 @@
|
|||
/*
|
||||
|
||||
Command godep helps build packages reproducibly by fixing
|
||||
their dependencies.
|
||||
|
||||
Example Usage
|
||||
|
||||
Save currently-used dependencies to file Godeps:
|
||||
|
||||
$ godep save
|
||||
|
||||
Build project using saved dependencies:
|
||||
|
||||
$ godep go install
|
||||
|
||||
or
|
||||
|
||||
$ GOPATH=`godep path`:$GOPATH
|
||||
$ go install
|
||||
|
||||
*/
|
||||
package main
|
||||
|
|
@ -1,18 +0,0 @@
|
|||
package main
|
||||
|
||||
import "errors"
|
||||
|
||||
var (
|
||||
errorLoadingDeps = errors.New("error loading dependencies")
|
||||
errorLoadingPackages = errors.New("error loading packages")
|
||||
errorCopyingSourceCode = errors.New("error copying source code")
|
||||
errorNoPackagesUpdatable = errors.New("no packages can be updated")
|
||||
)
|
||||
|
||||
type errPackageNotFound struct {
|
||||
path string
|
||||
}
|
||||
|
||||
func (e errPackageNotFound) Error() string {
|
||||
return "Package (" + e.path + ") not found"
|
||||
}
|
||||
|
|
@ -1,96 +0,0 @@
|
|||
package main
|
||||
|
||||
import (
|
||||
"log"
|
||||
"os"
|
||||
"os/exec"
|
||||
)
|
||||
|
||||
var cmdGet = &Command{
|
||||
Name: "get",
|
||||
Args: "[-t] [packages]",
|
||||
Short: "download and install packages with specified dependencies",
|
||||
Long: `
|
||||
Get downloads to GOPATH the packages named by the import paths, and installs
|
||||
them with the dependencies specified in their Godeps files.
|
||||
|
||||
If any of the packages do not have Godeps files, those are installed
|
||||
as if by go get.
|
||||
|
||||
If -t is given, dependencies of test files are also downloaded and installed.
|
||||
|
||||
For more about specifying packages, see 'go help packages'.
|
||||
`,
|
||||
Run: runGet,
|
||||
OnlyInGOPATH: true,
|
||||
}
|
||||
|
||||
var getT bool
|
||||
|
||||
func init() {
|
||||
cmdGet.Flag.BoolVar(&getT, "t", false, "get test dependencies")
|
||||
}
|
||||
|
||||
func runGet(cmd *Command, args []string) {
|
||||
if len(args) == 0 {
|
||||
args = []string{"."}
|
||||
}
|
||||
|
||||
cmdArgs := []interface{}{"get", "-d"}
|
||||
if verbose {
|
||||
cmdArgs = append(cmdArgs, "-v")
|
||||
}
|
||||
|
||||
if getT {
|
||||
cmdArgs = append(cmdArgs, "-t")
|
||||
}
|
||||
|
||||
err := command("go", append(cmdArgs, args)...).Run()
|
||||
if err != nil {
|
||||
log.Fatalln(err)
|
||||
}
|
||||
|
||||
// group import paths by Godeps location
|
||||
groups := make(map[string][]string)
|
||||
ps, err := LoadPackages(args...)
|
||||
if err != nil {
|
||||
log.Fatalln(err)
|
||||
}
|
||||
for _, pkg := range ps {
|
||||
if pkg.Error.Err != "" {
|
||||
log.Fatalln(pkg.Error.Err)
|
||||
}
|
||||
dir, _ := findInParents(pkg.Dir, "Godeps")
|
||||
groups[dir] = append(groups[dir], pkg.ImportPath)
|
||||
}
|
||||
for dir, packages := range groups {
|
||||
var c *exec.Cmd
|
||||
if dir == "" {
|
||||
c = command("go", "install", packages)
|
||||
} else {
|
||||
c = command("godep", "go", "install", packages)
|
||||
c.Dir = dir
|
||||
}
|
||||
if err := c.Run(); err != nil {
|
||||
log.Fatalln(err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// command is like exec.Command, but the returned
|
||||
// Cmd inherits stderr from the current process, and
|
||||
// elements of args may be either string or []string.
|
||||
func command(name string, args ...interface{}) *exec.Cmd {
|
||||
var a []string
|
||||
for _, arg := range args {
|
||||
switch v := arg.(type) {
|
||||
case string:
|
||||
a = append(a, v)
|
||||
case []string:
|
||||
a = append(a, v...)
|
||||
}
|
||||
}
|
||||
c := exec.Command(name, a...)
|
||||
c.Stderr = os.Stderr
|
||||
return c
|
||||
}
|
||||
|
|
@ -1,129 +0,0 @@
|
|||
package main
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"log"
|
||||
"os"
|
||||
"os/exec"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
)
|
||||
|
||||
var cmdGo = &Command{
|
||||
Name: "go",
|
||||
Args: "command [arguments]",
|
||||
Short: "run the go tool with saved dependencies",
|
||||
Long: `
|
||||
Go runs the go tool with a modified GOPATH giving access to
|
||||
dependencies saved in Godeps.
|
||||
|
||||
Any go tool command can run this way, but "godep go get"
|
||||
is unnecessary and has been disabled. Instead, use
|
||||
"godep go install".
|
||||
`,
|
||||
Run: runGo,
|
||||
OnlyInGOPATH: true,
|
||||
}
|
||||
|
||||
// Find the godep GOPATH for this file tree and run the go tool.
|
||||
func runGo(cmd *Command, args []string) {
|
||||
gopath := prepareGopath()
|
||||
if s := os.Getenv("GOPATH"); s != "" {
|
||||
gopath += string(os.PathListSeparator) + os.Getenv("GOPATH")
|
||||
}
|
||||
if len(args) > 0 && args[0] == "get" {
|
||||
log.Printf("invalid subcommand: %q", "go get")
|
||||
fmt.Fprintln(os.Stderr, "Use 'godep go install' instead.")
|
||||
fmt.Fprintln(os.Stderr, "Run 'godep help go' for usage.")
|
||||
os.Exit(2)
|
||||
}
|
||||
c := exec.Command("go", args...)
|
||||
c.Env = append(envNoGopath(), "GOPATH="+gopath)
|
||||
c.Stdin = os.Stdin
|
||||
c.Stdout = os.Stdout
|
||||
c.Stderr = os.Stderr
|
||||
err := c.Run()
|
||||
if err != nil {
|
||||
log.Fatalln("go", err)
|
||||
}
|
||||
}
|
||||
|
||||
// prepareGopath reads dependency information from the filesystem
|
||||
// entry name, fetches any necessary code, and returns a gopath
|
||||
// causing the specified dependencies to be used.
|
||||
func prepareGopath() (gopath string) {
|
||||
dir, isDir := findGodeps()
|
||||
if dir == "" {
|
||||
log.Fatalln("No Godeps found (or in any parent directory)")
|
||||
}
|
||||
if !isDir {
|
||||
log.Fatalln(strings.TrimSpace(needSource))
|
||||
}
|
||||
return filepath.Join(dir, "Godeps", "_workspace")
|
||||
}
|
||||
|
||||
// findGodeps looks for a directory entry "Godeps" in the
|
||||
// current directory or any parent, and returns the containing
|
||||
// directory and whether the entry itself is a directory.
|
||||
// If Godeps can't be found, findGodeps returns "".
|
||||
// For any other error, it exits the program.
|
||||
func findGodeps() (dir string, isDir bool) {
|
||||
wd, err := os.Getwd()
|
||||
if err != nil {
|
||||
log.Fatalln(err)
|
||||
}
|
||||
return findInParents(wd, "Godeps")
|
||||
}
|
||||
|
||||
// isRoot returns true iff a path is a root.
|
||||
// On Unix: "/".
|
||||
// On Windows: "C:\", "D:\", ...
|
||||
func isRoot(p string) bool {
|
||||
p = filepath.Clean(p)
|
||||
volume := filepath.VolumeName(p)
|
||||
|
||||
p = strings.TrimPrefix(p, volume)
|
||||
p = filepath.ToSlash(p)
|
||||
|
||||
return p == "/"
|
||||
}
|
||||
|
||||
// findInParents returns the path to the directory containing name
|
||||
// in dir or any ancestor, and whether name itself is a directory.
|
||||
// If name cannot be found, findInParents returns the empty string.
|
||||
func findInParents(dir, name string) (container string, isDir bool) {
|
||||
for {
|
||||
fi, err := os.Stat(filepath.Join(dir, name))
|
||||
if os.IsNotExist(err) && isRoot(dir) {
|
||||
return "", false
|
||||
}
|
||||
if os.IsNotExist(err) {
|
||||
dir = filepath.Dir(dir)
|
||||
continue
|
||||
}
|
||||
if err != nil {
|
||||
log.Fatalln(err)
|
||||
}
|
||||
return dir, fi.IsDir()
|
||||
}
|
||||
}
|
||||
|
||||
func envNoGopath() (a []string) {
|
||||
for _, s := range os.Environ() {
|
||||
if !strings.HasPrefix(s, "GOPATH=") {
|
||||
a = append(a, s)
|
||||
}
|
||||
}
|
||||
return a
|
||||
}
|
||||
|
||||
const needSource = `
|
||||
outdated Godeps missing source code
|
||||
|
||||
This dependency list was created with an old version of godep.
|
||||
|
||||
To work around this, you have two options:
|
||||
1. Run 'godep restore', and try again.
|
||||
2. Ask the maintainer to switch to a newer version of godep,
|
||||
then try again with the updated package.
|
||||
`
|
||||
|
|
@ -1,218 +0,0 @@
|
|||
package main
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"io"
|
||||
"log"
|
||||
"os"
|
||||
"path/filepath"
|
||||
)
|
||||
|
||||
var (
|
||||
godepsFile = filepath.Join("Godeps", "Godeps.json")
|
||||
oldGodepsFile = filepath.Join("Godeps")
|
||||
)
|
||||
|
||||
// Godeps describes what a package needs to be rebuilt reproducibly.
|
||||
// It's the same information stored in file Godeps.
|
||||
type Godeps struct {
|
||||
ImportPath string
|
||||
GoVersion string
|
||||
GodepVersion string
|
||||
Packages []string `json:",omitempty"` // Arguments to save, if any.
|
||||
Deps []Dependency
|
||||
isOldFile bool
|
||||
}
|
||||
|
||||
func loadGodepsFile(path string) (Godeps, error) {
|
||||
var g Godeps
|
||||
f, err := os.Open(path)
|
||||
if err != nil {
|
||||
return g, err
|
||||
}
|
||||
defer f.Close()
|
||||
err = json.NewDecoder(f).Decode(&g)
|
||||
if err != nil {
|
||||
err = fmt.Errorf("Unable to parse %s: %s", path, err.Error())
|
||||
}
|
||||
return g, err
|
||||
}
|
||||
|
||||
func loadDefaultGodepsFile() (Godeps, error) {
|
||||
var g Godeps
|
||||
var err error
|
||||
g, err = loadGodepsFile(godepsFile)
|
||||
if err != nil {
|
||||
if os.IsNotExist(err) {
|
||||
var err1 error
|
||||
g, err1 = loadGodepsFile(oldGodepsFile)
|
||||
if err1 != nil {
|
||||
if os.IsNotExist(err1) {
|
||||
return g, err
|
||||
}
|
||||
return g, err1
|
||||
}
|
||||
g.isOldFile = true
|
||||
return g, nil
|
||||
}
|
||||
}
|
||||
return g, err
|
||||
}
|
||||
|
||||
// pkgs is the list of packages to read dependencies for
|
||||
func (g *Godeps) fill(pkgs []*Package, destImportPath string) error {
|
||||
debugln("fill", destImportPath)
|
||||
ppln(pkgs)
|
||||
var err1 error
|
||||
var path, testImports []string
|
||||
dipp := []string{destImportPath}
|
||||
for _, p := range pkgs {
|
||||
if p.Standard {
|
||||
log.Println("ignoring stdlib package:", p.ImportPath)
|
||||
continue
|
||||
}
|
||||
if p.Error.Err != "" {
|
||||
log.Println(p.Error.Err)
|
||||
err1 = errorLoadingPackages
|
||||
continue
|
||||
}
|
||||
path = append(path, p.ImportPath)
|
||||
path = append(path, p.Deps...)
|
||||
testImports = append(testImports, p.TestImports...)
|
||||
testImports = append(testImports, p.XTestImports...)
|
||||
}
|
||||
ps, err := LoadPackages(testImports...)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
for _, p := range ps {
|
||||
if p.Standard {
|
||||
continue
|
||||
}
|
||||
if p.Error.Err != "" {
|
||||
log.Println(p.Error.Err)
|
||||
err1 = errorLoadingPackages
|
||||
continue
|
||||
}
|
||||
path = append(path, p.ImportPath)
|
||||
path = append(path, p.Deps...)
|
||||
}
|
||||
debugln("path", path)
|
||||
for i, p := range path {
|
||||
path[i] = unqualify(p)
|
||||
}
|
||||
path = uniq(path)
|
||||
debugln("uniq, unqualify'd path", path)
|
||||
ps, err = LoadPackages(path...)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
for _, pkg := range ps {
|
||||
if pkg.Error.Err != "" {
|
||||
log.Println(pkg.Error.Err)
|
||||
err1 = errorLoadingDeps
|
||||
continue
|
||||
}
|
||||
if pkg.Standard || containsPathPrefix(dipp, pkg.ImportPath) {
|
||||
debugln("standard or dest skipping", pkg.ImportPath)
|
||||
continue
|
||||
}
|
||||
vcs, reporoot, err := VCSFromDir(pkg.Dir, filepath.Join(pkg.Root, "src"))
|
||||
if err != nil {
|
||||
log.Println(err)
|
||||
err1 = errorLoadingDeps
|
||||
continue
|
||||
}
|
||||
id, err := vcs.identify(pkg.Dir)
|
||||
if err != nil {
|
||||
log.Println(err)
|
||||
err1 = errorLoadingDeps
|
||||
continue
|
||||
}
|
||||
if vcs.isDirty(pkg.Dir, id) {
|
||||
log.Println("dirty working tree (please commit changes):", pkg.Dir)
|
||||
err1 = errorLoadingDeps
|
||||
continue
|
||||
}
|
||||
comment := vcs.describe(pkg.Dir, id)
|
||||
g.Deps = append(g.Deps, Dependency{
|
||||
ImportPath: pkg.ImportPath,
|
||||
Rev: id,
|
||||
Comment: comment,
|
||||
dir: pkg.Dir,
|
||||
ws: pkg.Root,
|
||||
root: filepath.ToSlash(reporoot),
|
||||
vcs: vcs,
|
||||
})
|
||||
}
|
||||
return err1
|
||||
}
|
||||
|
||||
func (g *Godeps) copy() *Godeps {
|
||||
h := *g
|
||||
h.Deps = make([]Dependency, len(g.Deps))
|
||||
copy(h.Deps, g.Deps)
|
||||
return &h
|
||||
}
|
||||
|
||||
func (g *Godeps) file() string {
|
||||
if g.isOldFile {
|
||||
return oldGodepsFile
|
||||
}
|
||||
return godepsFile
|
||||
}
|
||||
|
||||
func (g *Godeps) save() (int64, error) {
|
||||
f, err := os.Create(g.file())
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
defer f.Close()
|
||||
return g.writeTo(f)
|
||||
}
|
||||
|
||||
func (g *Godeps) writeTo(w io.Writer) (int64, error) {
|
||||
g.GodepVersion = fmt.Sprintf("v%s", version) // godep always writes its current version.
|
||||
b, err := json.MarshalIndent(g, "", "\t")
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
n, err := w.Write(append(b, '\n'))
|
||||
return int64(n), err
|
||||
}
|
||||
|
||||
func (g *Godeps) addOrUpdateDeps(deps []Dependency) {
|
||||
var missing []Dependency
|
||||
for _, d := range deps {
|
||||
var found bool
|
||||
for i := range g.Deps {
|
||||
if g.Deps[i].ImportPath == d.ImportPath {
|
||||
g.Deps[i] = d
|
||||
found = true
|
||||
break
|
||||
}
|
||||
}
|
||||
if !found {
|
||||
missing = append(missing, d)
|
||||
}
|
||||
}
|
||||
g.Deps = append(g.Deps, missing...)
|
||||
}
|
||||
|
||||
func (g *Godeps) removeDeps(deps []Dependency) {
|
||||
var f []Dependency
|
||||
for i := range g.Deps {
|
||||
var found bool
|
||||
for _, d := range deps {
|
||||
if g.Deps[i].ImportPath == d.ImportPath {
|
||||
found = true
|
||||
break
|
||||
}
|
||||
}
|
||||
if !found {
|
||||
f = append(f, g.Deps[i])
|
||||
}
|
||||
}
|
||||
g.Deps = f
|
||||
}
|
||||
|
|
@ -1,59 +0,0 @@
|
|||
package main
|
||||
|
||||
import (
|
||||
"strings"
|
||||
)
|
||||
|
||||
// LicenseFilePrefix is a list of filename prefixes that indicate it
|
||||
// might contain a software license
|
||||
var LicenseFilePrefix = []string{
|
||||
"licence", // UK spelling
|
||||
"license", // US spelling
|
||||
"copying",
|
||||
"unlicense",
|
||||
"copyright",
|
||||
"copyleft",
|
||||
"authors",
|
||||
"contributors",
|
||||
}
|
||||
|
||||
// LegalFileSubstring are substrings that indicate the file is likely
|
||||
// to contain some type of legal declaration. "legal" is often used
|
||||
// that it might moved to LicenseFilePrefix
|
||||
var LegalFileSubstring = []string{
|
||||
"legal",
|
||||
"notice",
|
||||
"disclaimer",
|
||||
"patent",
|
||||
"third-party",
|
||||
"thirdparty",
|
||||
}
|
||||
|
||||
// IsLicenseFile returns true if the filename might be contain a
|
||||
// software license
|
||||
func IsLicenseFile(filename string) bool {
|
||||
lowerfile := strings.ToLower(filename)
|
||||
for _, prefix := range LicenseFilePrefix {
|
||||
if strings.HasPrefix(lowerfile, prefix) {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
// IsLegalFile returns true if the file is likely to contain some type
|
||||
// of of legal declaration or licensing information
|
||||
func IsLegalFile(filename string) bool {
|
||||
lowerfile := strings.ToLower(filename)
|
||||
for _, prefix := range LicenseFilePrefix {
|
||||
if strings.HasPrefix(lowerfile, prefix) {
|
||||
return true
|
||||
}
|
||||
}
|
||||
for _, substring := range LegalFileSubstring {
|
||||
if strings.Contains(lowerfile, substring) {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
|
@ -1,601 +0,0 @@
|
|||
package main
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"fmt"
|
||||
"go/build"
|
||||
"go/parser"
|
||||
"go/token"
|
||||
"log"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"regexp"
|
||||
"strconv"
|
||||
"strings"
|
||||
"unicode"
|
||||
|
||||
pathpkg "path"
|
||||
)
|
||||
|
||||
var (
|
||||
gorootSrc = filepath.Join(build.Default.GOROOT, "src")
|
||||
ignoreTags = []string{"appengine", "ignore"} //TODO: appengine is a special case for now: https://github.com/tools/godep/issues/353
|
||||
versionMatch = regexp.MustCompile(`\Ago\d+\.\d+\z`)
|
||||
versionNegativeMatch = regexp.MustCompile(`\A\!go\d+\.\d+\z`)
|
||||
)
|
||||
|
||||
type errorMissingDep struct {
|
||||
i, dir string // import, dir
|
||||
}
|
||||
|
||||
func (e errorMissingDep) Error() string {
|
||||
return "Unable to find dependent package " + e.i + " in context of " + e.dir
|
||||
}
|
||||
|
||||
// packageContext is used to track an import and which package imported it.
|
||||
type packageContext struct {
|
||||
pkg *build.Package // package that imports the import
|
||||
imp string // import
|
||||
}
|
||||
|
||||
// depScanner tracks the processed and to be processed packageContexts
|
||||
type depScanner struct {
|
||||
processed []packageContext
|
||||
todo []packageContext
|
||||
}
|
||||
|
||||
// Next package and import to process
|
||||
func (ds *depScanner) Next() (*build.Package, string) {
|
||||
c := ds.todo[0]
|
||||
ds.processed = append(ds.processed, c)
|
||||
ds.todo = ds.todo[1:]
|
||||
return c.pkg, c.imp
|
||||
}
|
||||
|
||||
// Continue looping?
|
||||
func (ds *depScanner) Continue() bool {
|
||||
return len(ds.todo) > 0
|
||||
}
|
||||
|
||||
// Add a package and imports to the depScanner. Skips already processed/pending package/import combos
|
||||
func (ds *depScanner) Add(pkg *build.Package, imports ...string) {
|
||||
NextImport:
|
||||
for _, i := range imports {
|
||||
if i == "C" {
|
||||
i = "runtime/cgo"
|
||||
}
|
||||
for _, epc := range ds.processed {
|
||||
if pkg.Dir == epc.pkg.Dir && i == epc.imp {
|
||||
debugln("ctxts epc.pkg.Dir == pkg.Dir && i == epc.imp, skipping", epc.pkg.Dir, i)
|
||||
continue NextImport
|
||||
}
|
||||
}
|
||||
for _, epc := range ds.todo {
|
||||
if pkg.Dir == epc.pkg.Dir && i == epc.imp {
|
||||
debugln("ctxts epc.pkg.Dir == pkg.Dir && i == epc.imp, skipping", epc.pkg.Dir, i)
|
||||
continue NextImport
|
||||
}
|
||||
}
|
||||
pc := packageContext{pkg, i}
|
||||
debugln("Adding pc:", pc.pkg.Dir, pc.imp)
|
||||
ds.todo = append(ds.todo, pc)
|
||||
}
|
||||
}
|
||||
|
||||
var (
|
||||
pkgCache = make(map[string]*build.Package) // dir => *build.Package
|
||||
)
|
||||
|
||||
// returns the package in dir either from a cache or by importing it and then caching it
|
||||
func fullPackageInDir(dir string) (*build.Package, error) {
|
||||
var err error
|
||||
pkg, ok := pkgCache[dir]
|
||||
if !ok {
|
||||
pkg, _ = build.ImportDir(dir, build.FindOnly)
|
||||
if pkg.Goroot {
|
||||
pkg, err = build.ImportDir(pkg.Dir, 0)
|
||||
} else {
|
||||
err = fillPackage(pkg)
|
||||
}
|
||||
if err == nil {
|
||||
pkgCache[dir] = pkg
|
||||
}
|
||||
}
|
||||
return pkg, err
|
||||
}
|
||||
|
||||
// listPackage specified by path
|
||||
func listPackage(path string) (*Package, error) {
|
||||
debugln("listPackage", path)
|
||||
var lp *build.Package
|
||||
dir, err := findDirForPath(path, nil)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
lp, err = fullPackageInDir(dir)
|
||||
p := &Package{
|
||||
Dir: lp.Dir,
|
||||
Root: lp.Root,
|
||||
ImportPath: lp.ImportPath,
|
||||
XTestImports: lp.XTestImports,
|
||||
TestImports: lp.TestImports,
|
||||
GoFiles: lp.GoFiles,
|
||||
CgoFiles: lp.CgoFiles,
|
||||
TestGoFiles: lp.TestGoFiles,
|
||||
XTestGoFiles: lp.XTestGoFiles,
|
||||
IgnoredGoFiles: lp.IgnoredGoFiles,
|
||||
}
|
||||
p.Standard = lp.Goroot && lp.ImportPath != "" && !strings.Contains(lp.ImportPath, ".")
|
||||
if err != nil || p.Standard {
|
||||
return p, err
|
||||
}
|
||||
debugln("Looking For Package:", path, "in", dir)
|
||||
ppln(lp)
|
||||
|
||||
ds := depScanner{}
|
||||
ds.Add(lp, lp.Imports...)
|
||||
for ds.Continue() {
|
||||
ip, i := ds.Next()
|
||||
|
||||
debugf("Processing import %s for %s\n", i, ip.Dir)
|
||||
pdir, err := findDirForPath(i, ip)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
dp, err := fullPackageInDir(pdir)
|
||||
if err != nil { // This really should happen in this context though
|
||||
ppln(err)
|
||||
return nil, errorMissingDep{i: i, dir: ip.Dir}
|
||||
}
|
||||
ppln(dp)
|
||||
if !dp.Goroot {
|
||||
// Don't bother adding packages in GOROOT to the dependency scanner, they don't import things from outside of it.
|
||||
ds.Add(dp, dp.Imports...)
|
||||
}
|
||||
debugln("lp:")
|
||||
ppln(lp)
|
||||
debugln("ip:")
|
||||
ppln(ip)
|
||||
if lp == ip {
|
||||
debugln("lp == ip")
|
||||
p.Imports = append(p.Imports, dp.ImportPath)
|
||||
}
|
||||
p.Deps = append(p.Deps, dp.ImportPath)
|
||||
p.Dependencies = addDependency(p.Dependencies, dp)
|
||||
}
|
||||
p.Imports = uniq(p.Imports)
|
||||
p.Deps = uniq(p.Deps)
|
||||
debugln("Done Looking For Package:", path, "in", dir)
|
||||
ppln(p)
|
||||
return p, nil
|
||||
}
|
||||
|
||||
func addDependency(deps []build.Package, d *build.Package) []build.Package {
|
||||
for i := range deps {
|
||||
if deps[i].Dir == d.Dir {
|
||||
return deps
|
||||
}
|
||||
}
|
||||
return append(deps, *d)
|
||||
}
|
||||
|
||||
// finds the directory for the given import path in the context of the provided build.Package (if provided)
|
||||
func findDirForPath(path string, ip *build.Package) (string, error) {
|
||||
debugln("findDirForPath", path, ip)
|
||||
var search []string
|
||||
|
||||
if build.IsLocalImport(path) {
|
||||
dir := path
|
||||
if !filepath.IsAbs(dir) {
|
||||
if abs, err := filepath.Abs(dir); err == nil {
|
||||
// interpret relative to current directory
|
||||
dir = abs
|
||||
}
|
||||
}
|
||||
return dir, nil
|
||||
}
|
||||
|
||||
// We need to check to see if the import exists in vendor/ folders up the hierarchy of the importing package
|
||||
if VendorExperiment && ip != nil {
|
||||
debugln("resolving vendor posibilities:", ip.Dir, ip.Root)
|
||||
cr := cleanPath(ip.Root)
|
||||
|
||||
for base := cleanPath(ip.Dir); !pathEqual(base, cr); base = cleanPath(filepath.Dir(base)) {
|
||||
s := filepath.Join(base, "vendor", path)
|
||||
debugln("Adding search dir:", s)
|
||||
search = append(search, s)
|
||||
}
|
||||
}
|
||||
|
||||
for _, base := range build.Default.SrcDirs() {
|
||||
search = append(search, filepath.Join(base, path))
|
||||
}
|
||||
|
||||
for _, dir := range search {
|
||||
debugln("searching", dir)
|
||||
fi, err := stat(dir)
|
||||
if err == nil && fi.IsDir() {
|
||||
return dir, nil
|
||||
}
|
||||
}
|
||||
|
||||
return "", errPackageNotFound{path}
|
||||
}
|
||||
|
||||
type statEntry struct {
|
||||
fi os.FileInfo
|
||||
err error
|
||||
}
|
||||
|
||||
var (
|
||||
statCache = make(map[string]statEntry)
|
||||
)
|
||||
|
||||
func clearStatCache() {
|
||||
statCache = make(map[string]statEntry)
|
||||
}
|
||||
|
||||
func stat(p string) (os.FileInfo, error) {
|
||||
if e, ok := statCache[p]; ok {
|
||||
return e.fi, e.err
|
||||
}
|
||||
fi, err := os.Stat(p)
|
||||
statCache[p] = statEntry{fi, err}
|
||||
return fi, err
|
||||
}
|
||||
|
||||
// fillPackage full of info. Assumes p.Dir is set at a minimum
|
||||
func fillPackage(p *build.Package) error {
|
||||
if p.Goroot {
|
||||
return nil
|
||||
}
|
||||
|
||||
if p.SrcRoot == "" {
|
||||
for _, base := range build.Default.SrcDirs() {
|
||||
if strings.HasPrefix(p.Dir, base) {
|
||||
p.SrcRoot = base
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if p.SrcRoot == "" {
|
||||
return errors.New("Unable to find SrcRoot for package " + p.ImportPath)
|
||||
}
|
||||
|
||||
if p.Root == "" {
|
||||
p.Root = filepath.Dir(p.SrcRoot)
|
||||
}
|
||||
|
||||
var buildMatch = "+build "
|
||||
var buildFieldSplit = func(r rune) bool {
|
||||
return unicode.IsSpace(r) || r == ','
|
||||
}
|
||||
|
||||
debugln("Filling package:", p.ImportPath, "from", p.Dir)
|
||||
gofiles, err := filepath.Glob(filepath.Join(p.Dir, "*.go"))
|
||||
if err != nil {
|
||||
debugln("Error globbing", err)
|
||||
return err
|
||||
}
|
||||
|
||||
if len(gofiles) == 0 {
|
||||
return &build.NoGoError{Dir: p.Dir}
|
||||
}
|
||||
|
||||
var testImports []string
|
||||
var imports []string
|
||||
NextFile:
|
||||
for _, file := range gofiles {
|
||||
debugln(file)
|
||||
pf, err := parser.ParseFile(token.NewFileSet(), file, nil, parser.ImportsOnly|parser.ParseComments)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
testFile := strings.HasSuffix(file, "_test.go")
|
||||
fname := filepath.Base(file)
|
||||
for _, c := range pf.Comments {
|
||||
ct := c.Text()
|
||||
if i := strings.Index(ct, buildMatch); i != -1 {
|
||||
for _, t := range strings.FieldsFunc(ct[i+len(buildMatch):], buildFieldSplit) {
|
||||
for _, tag := range ignoreTags {
|
||||
if t == tag {
|
||||
p.IgnoredGoFiles = append(p.IgnoredGoFiles, fname)
|
||||
continue NextFile
|
||||
}
|
||||
}
|
||||
|
||||
if versionMatch.MatchString(t) && !isSameOrNewer(t, majorGoVersion) {
|
||||
debugln("Adding", fname, "to ignored list because of version tag", t)
|
||||
p.IgnoredGoFiles = append(p.IgnoredGoFiles, fname)
|
||||
continue NextFile
|
||||
}
|
||||
if versionNegativeMatch.MatchString(t) && isSameOrNewer(t[1:], majorGoVersion) {
|
||||
debugln("Adding", fname, "to ignored list because of version tag", t)
|
||||
p.IgnoredGoFiles = append(p.IgnoredGoFiles, fname)
|
||||
continue NextFile
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if testFile {
|
||||
p.TestGoFiles = append(p.TestGoFiles, fname)
|
||||
} else {
|
||||
p.GoFiles = append(p.GoFiles, fname)
|
||||
}
|
||||
for _, is := range pf.Imports {
|
||||
name, err := strconv.Unquote(is.Path.Value)
|
||||
if err != nil {
|
||||
return err // can't happen?
|
||||
}
|
||||
if testFile {
|
||||
testImports = append(testImports, name)
|
||||
} else {
|
||||
imports = append(imports, name)
|
||||
}
|
||||
}
|
||||
}
|
||||
imports = uniq(imports)
|
||||
testImports = uniq(testImports)
|
||||
p.Imports = imports
|
||||
p.TestImports = testImports
|
||||
return nil
|
||||
}
|
||||
|
||||
// All of the following functions were vendored from go proper. Locations are noted in comments, but may change in future Go versions.
|
||||
|
||||
// importPaths returns the import paths to use for the given command line.
|
||||
// $GOROOT/src/cmd/main.go:366
|
||||
func importPaths(args []string) []string {
|
||||
debugf("importPathsNoDotExpansion(%q) == ", args)
|
||||
args = importPathsNoDotExpansion(args)
|
||||
debugf("%q\n", args)
|
||||
var out []string
|
||||
for _, a := range args {
|
||||
if strings.Contains(a, "...") {
|
||||
if build.IsLocalImport(a) {
|
||||
debugf("build.IsLocalImport(%q) == true\n", a)
|
||||
pkgs := allPackagesInFS(a)
|
||||
debugf("allPackagesInFS(%q) == %q\n", a, pkgs)
|
||||
out = append(out, pkgs...)
|
||||
} else {
|
||||
debugf("build.IsLocalImport(%q) == false\n", a)
|
||||
pkgs := allPackages(a)
|
||||
debugf("allPackages(%q) == %q\n", a, pkgs)
|
||||
out = append(out, allPackages(a)...)
|
||||
}
|
||||
continue
|
||||
}
|
||||
out = append(out, a)
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
// importPathsNoDotExpansion returns the import paths to use for the given
|
||||
// command line, but it does no ... expansion.
|
||||
// $GOROOT/src/cmd/main.go:332
|
||||
func importPathsNoDotExpansion(args []string) []string {
|
||||
if len(args) == 0 {
|
||||
return []string{"."}
|
||||
}
|
||||
var out []string
|
||||
for _, a := range args {
|
||||
// Arguments are supposed to be import paths, but
|
||||
// as a courtesy to Windows developers, rewrite \ to /
|
||||
// in command-line arguments. Handles .\... and so on.
|
||||
if filepath.Separator == '\\' {
|
||||
a = strings.Replace(a, `\`, `/`, -1)
|
||||
}
|
||||
|
||||
// Put argument in canonical form, but preserve leading ./.
|
||||
if strings.HasPrefix(a, "./") {
|
||||
a = "./" + pathpkg.Clean(a)
|
||||
if a == "./." {
|
||||
a = "."
|
||||
}
|
||||
} else {
|
||||
a = pathpkg.Clean(a)
|
||||
}
|
||||
if a == "all" || a == "std" || a == "cmd" {
|
||||
out = append(out, allPackages(a)...)
|
||||
continue
|
||||
}
|
||||
out = append(out, a)
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
// allPackagesInFS is like allPackages but is passed a pattern
|
||||
// beginning ./ or ../, meaning it should scan the tree rooted
|
||||
// at the given directory. There are ... in the pattern too.
|
||||
// $GOROOT/src/cmd/main.go:620
|
||||
func allPackagesInFS(pattern string) []string {
|
||||
pkgs := matchPackagesInFS(pattern)
|
||||
if len(pkgs) == 0 {
|
||||
fmt.Fprintf(os.Stderr, "warning: %q matched no packages\n", pattern)
|
||||
}
|
||||
return pkgs
|
||||
}
|
||||
|
||||
// allPackages returns all the packages that can be found
|
||||
// under the $GOPATH directories and $GOROOT matching pattern.
|
||||
// The pattern is either "all" (all packages), "std" (standard packages),
|
||||
// "cmd" (standard commands), or a path including "...".
|
||||
// $GOROOT/src/cmd/main.go:542
|
||||
func allPackages(pattern string) []string {
|
||||
pkgs := matchPackages(pattern)
|
||||
if len(pkgs) == 0 {
|
||||
fmt.Fprintf(os.Stderr, "warning: %q matched no packages\n", pattern)
|
||||
}
|
||||
return pkgs
|
||||
}
|
||||
|
||||
// $GOROOT/src/cmd/main.go:554
|
||||
// This has been changed to not use build.ImportDir
|
||||
func matchPackages(pattern string) []string {
|
||||
match := func(string) bool { return true }
|
||||
treeCanMatch := func(string) bool { return true }
|
||||
if pattern != "all" && pattern != "std" && pattern != "cmd" {
|
||||
match = matchPattern(pattern)
|
||||
treeCanMatch = treeCanMatchPattern(pattern)
|
||||
}
|
||||
|
||||
have := map[string]bool{
|
||||
"builtin": true, // ignore pseudo-package that exists only for documentation
|
||||
}
|
||||
if !build.Default.CgoEnabled {
|
||||
have["runtime/cgo"] = true // ignore during walk
|
||||
}
|
||||
var pkgs []string
|
||||
|
||||
for _, src := range build.Default.SrcDirs() {
|
||||
if (pattern == "std" || pattern == "cmd") && src != gorootSrc {
|
||||
continue
|
||||
}
|
||||
src = filepath.Clean(src) + string(filepath.Separator)
|
||||
root := src
|
||||
if pattern == "cmd" {
|
||||
root += "cmd" + string(filepath.Separator)
|
||||
}
|
||||
filepath.Walk(root, func(path string, fi os.FileInfo, err error) error {
|
||||
if err != nil || !fi.IsDir() || path == src {
|
||||
return nil
|
||||
}
|
||||
|
||||
// Avoid .foo, _foo, and testdata directory trees.
|
||||
_, elem := filepath.Split(path)
|
||||
if strings.HasPrefix(elem, ".") || strings.HasPrefix(elem, "_") || elem == "testdata" {
|
||||
return filepath.SkipDir
|
||||
}
|
||||
|
||||
name := filepath.ToSlash(path[len(src):])
|
||||
if pattern == "std" && (strings.Contains(name, ".") || name == "cmd") {
|
||||
// The name "std" is only the standard library.
|
||||
// If the name has a dot, assume it's a domain name for go get,
|
||||
// and if the name is cmd, it's the root of the command tree.
|
||||
return filepath.SkipDir
|
||||
}
|
||||
if !treeCanMatch(name) {
|
||||
return filepath.SkipDir
|
||||
}
|
||||
if have[name] {
|
||||
return nil
|
||||
}
|
||||
have[name] = true
|
||||
if !match(name) {
|
||||
return nil
|
||||
}
|
||||
|
||||
ap, err := filepath.Abs(path)
|
||||
if err != nil {
|
||||
return nil
|
||||
}
|
||||
if _, err = fullPackageInDir(ap); err != nil {
|
||||
debugf("matchPackage(%q) ap=%q Error: %q\n", ap, pattern, err)
|
||||
if _, noGo := err.(*build.NoGoError); noGo {
|
||||
return nil
|
||||
}
|
||||
}
|
||||
pkgs = append(pkgs, name)
|
||||
return nil
|
||||
})
|
||||
}
|
||||
return pkgs
|
||||
}
|
||||
|
||||
// treeCanMatchPattern(pattern)(name) reports whether
|
||||
// name or children of name can possibly match pattern.
|
||||
// Pattern is the same limited glob accepted by matchPattern.
|
||||
// $GOROOT/src/cmd/main.go:527
|
||||
func treeCanMatchPattern(pattern string) func(name string) bool {
|
||||
wildCard := false
|
||||
if i := strings.Index(pattern, "..."); i >= 0 {
|
||||
wildCard = true
|
||||
pattern = pattern[:i]
|
||||
}
|
||||
return func(name string) bool {
|
||||
return len(name) <= len(pattern) && hasPathPrefix(pattern, name) ||
|
||||
wildCard && strings.HasPrefix(name, pattern)
|
||||
}
|
||||
}
|
||||
|
||||
// hasPathPrefix reports whether the path s begins with the
|
||||
// elements in prefix.
|
||||
// $GOROOT/src/cmd/main.go:489
|
||||
func hasPathPrefix(s, prefix string) bool {
|
||||
switch {
|
||||
default:
|
||||
return false
|
||||
case len(s) == len(prefix):
|
||||
return s == prefix
|
||||
case len(s) > len(prefix):
|
||||
if prefix != "" && prefix[len(prefix)-1] == '/' {
|
||||
return strings.HasPrefix(s, prefix)
|
||||
}
|
||||
return s[len(prefix)] == '/' && s[:len(prefix)] == prefix
|
||||
}
|
||||
}
|
||||
|
||||
// $GOROOT/src/cmd/go/main.go:631
|
||||
// This has been changed to not use build.ImportDir
|
||||
func matchPackagesInFS(pattern string) []string {
|
||||
// Find directory to begin the scan.
|
||||
// Could be smarter but this one optimization
|
||||
// is enough for now, since ... is usually at the
|
||||
// end of a path.
|
||||
i := strings.Index(pattern, "...")
|
||||
dir, _ := pathpkg.Split(pattern[:i])
|
||||
|
||||
// pattern begins with ./ or ../.
|
||||
// path.Clean will discard the ./ but not the ../.
|
||||
// We need to preserve the ./ for pattern matching
|
||||
// and in the returned import paths.
|
||||
prefix := ""
|
||||
if strings.HasPrefix(pattern, "./") {
|
||||
prefix = "./"
|
||||
}
|
||||
match := matchPattern(pattern)
|
||||
|
||||
var pkgs []string
|
||||
filepath.Walk(dir, func(path string, fi os.FileInfo, err error) error {
|
||||
if err != nil || !fi.IsDir() {
|
||||
return nil
|
||||
}
|
||||
if path == dir {
|
||||
// filepath.Walk starts at dir and recurses. For the recursive case,
|
||||
// the path is the result of filepath.Join, which calls filepath.Clean.
|
||||
// The initial case is not Cleaned, though, so we do this explicitly.
|
||||
//
|
||||
// This converts a path like "./io/" to "io". Without this step, running
|
||||
// "cd $GOROOT/src; go list ./io/..." would incorrectly skip the io
|
||||
// package, because prepending the prefix "./" to the unclean path would
|
||||
// result in "././io", and match("././io") returns false.
|
||||
path = filepath.Clean(path)
|
||||
}
|
||||
|
||||
// Avoid .foo, _foo, and testdata directory trees, but do not avoid "." or "..".
|
||||
_, elem := filepath.Split(path)
|
||||
dot := strings.HasPrefix(elem, ".") && elem != "." && elem != ".."
|
||||
if dot || strings.HasPrefix(elem, "_") || elem == "testdata" {
|
||||
return filepath.SkipDir
|
||||
}
|
||||
|
||||
name := prefix + filepath.ToSlash(path)
|
||||
if !match(name) {
|
||||
return nil
|
||||
}
|
||||
ap, err := filepath.Abs(path)
|
||||
if err != nil {
|
||||
return nil
|
||||
}
|
||||
if _, err = fullPackageInDir(ap); err != nil {
|
||||
debugf("matchPackageInFS(%q) ap=%q Error: %q\n", ap, pattern, err)
|
||||
if _, noGo := err.(*build.NoGoError); !noGo {
|
||||
log.Print(err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
pkgs = append(pkgs, name)
|
||||
return nil
|
||||
})
|
||||
return pkgs
|
||||
}
|
||||
|
|
@ -1,255 +0,0 @@
|
|||
package main
|
||||
|
||||
import (
|
||||
"flag"
|
||||
"fmt"
|
||||
"go/build"
|
||||
"io"
|
||||
"log"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"runtime/pprof"
|
||||
"strings"
|
||||
"text/template"
|
||||
)
|
||||
|
||||
var (
|
||||
cpuprofile string
|
||||
verbose bool // Verbose flag for commands that support it
|
||||
debug bool // Debug flag for commands that support it
|
||||
majorGoVersion string
|
||||
VendorExperiment bool
|
||||
sep string
|
||||
)
|
||||
|
||||
// Command is an implementation of a godep command
|
||||
// like godep save or godep go.
|
||||
type Command struct {
|
||||
// Run runs the command.
|
||||
// The args are the arguments after the command name.
|
||||
Run func(cmd *Command, args []string)
|
||||
|
||||
// Name of the command
|
||||
Name string
|
||||
|
||||
// Args the command would expect
|
||||
Args string
|
||||
|
||||
// Short is the short description shown in the 'godep help' output.
|
||||
Short string
|
||||
|
||||
// Long is the long message shown in the
|
||||
// 'godep help <this-command>' output.
|
||||
Long string
|
||||
|
||||
// Flag is a set of flags specific to this command.
|
||||
Flag flag.FlagSet
|
||||
|
||||
// OnlyInGOPATH limits this command to being run only while inside of a GOPATH
|
||||
OnlyInGOPATH bool
|
||||
}
|
||||
|
||||
// UsageExit prints usage information and exits.
|
||||
func (c *Command) UsageExit() {
|
||||
fmt.Fprintf(os.Stderr, "Args: godep %s [-v] [-d] %s\n\n", c.Name, c.Args)
|
||||
fmt.Fprintf(os.Stderr, "Run 'godep help %s' for help.\n", c.Name)
|
||||
os.Exit(2)
|
||||
}
|
||||
|
||||
// Commands lists the available commands and help topics.
|
||||
// The order here is the order in which they are printed
|
||||
// by 'godep help'.
|
||||
var commands = []*Command{
|
||||
cmdSave,
|
||||
cmdGo,
|
||||
cmdGet,
|
||||
cmdPath,
|
||||
cmdRestore,
|
||||
cmdUpdate,
|
||||
cmdDiff,
|
||||
cmdVersion,
|
||||
}
|
||||
|
||||
// VendorExperiment is the Go 1.5 vendor directory experiment flag, see
|
||||
// https://github.com/golang/go/commit/183cc0cd41f06f83cb7a2490a499e3f9101befff
|
||||
// Honor the env var unless the project already has an old school godep workspace
|
||||
func determineVendor(v string) bool {
|
||||
go15ve := os.Getenv("GO15VENDOREXPERIMENT")
|
||||
var ev bool
|
||||
switch v {
|
||||
case "go1", "go1.1", "go1.2", "go1.3", "go1.4":
|
||||
ev = false
|
||||
case "go1.5":
|
||||
ev = go15ve == "1"
|
||||
case "go1.6":
|
||||
ev = go15ve != "0"
|
||||
default: //go1.7+, devel*
|
||||
ev = true
|
||||
}
|
||||
|
||||
ws := filepath.Join("Godeps", "_workspace")
|
||||
s, err := os.Stat(ws)
|
||||
if err == nil && s.IsDir() {
|
||||
log.Printf("WARNING: Godep workspaces (./Godeps/_workspace) are deprecated and support for them will be removed when go1.8 is released.")
|
||||
if ev {
|
||||
log.Printf("WARNING: Go version (%s) & $GO15VENDOREXPERIMENT=%s wants to enable the vendor experiment, but disabling because a Godep workspace (%s) exists\n", v, go15ve, ws)
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
return ev
|
||||
}
|
||||
|
||||
func main() {
|
||||
log.SetFlags(0)
|
||||
log.SetPrefix("godep: ")
|
||||
log.SetOutput(os.Stderr)
|
||||
|
||||
flag.Usage = usageExit
|
||||
flag.Parse()
|
||||
args := flag.Args()
|
||||
if len(args) < 1 {
|
||||
usageExit()
|
||||
}
|
||||
|
||||
if args[0] == "help" {
|
||||
help(args[1:])
|
||||
return
|
||||
}
|
||||
|
||||
var err error
|
||||
majorGoVersion, err = goVersion()
|
||||
if err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
|
||||
for _, cmd := range commands {
|
||||
if cmd.Name == args[0] {
|
||||
if cmd.OnlyInGOPATH {
|
||||
checkInGOPATH()
|
||||
}
|
||||
|
||||
VendorExperiment = determineVendor(majorGoVersion)
|
||||
// sep is the signature set of path elements that
|
||||
// precede the original path of an imported package.
|
||||
sep = defaultSep(VendorExperiment)
|
||||
|
||||
cmd.Flag.BoolVar(&verbose, "v", false, "enable verbose output")
|
||||
cmd.Flag.BoolVar(&debug, "d", false, "enable debug output")
|
||||
cmd.Flag.StringVar(&cpuprofile, "cpuprofile", "", "Write cpu profile to this file")
|
||||
cmd.Flag.Usage = func() { cmd.UsageExit() }
|
||||
cmd.Flag.Parse(args[1:])
|
||||
|
||||
debugln("versionString()", versionString())
|
||||
debugln("majorGoVersion", majorGoVersion)
|
||||
debugln("VendorExperiment", VendorExperiment)
|
||||
debugln("sep", sep)
|
||||
|
||||
if cpuprofile != "" {
|
||||
f, err := os.Create(cpuprofile)
|
||||
if err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
pprof.StartCPUProfile(f)
|
||||
defer pprof.StopCPUProfile()
|
||||
}
|
||||
cmd.Run(cmd, cmd.Flag.Args())
|
||||
return
|
||||
}
|
||||
}
|
||||
|
||||
fmt.Fprintf(os.Stderr, "godep: unknown command %q\n", args[0])
|
||||
fmt.Fprintf(os.Stderr, "Run 'godep help' for usage.\n")
|
||||
os.Exit(2)
|
||||
}
|
||||
|
||||
func subPath(sub, path string) bool {
|
||||
ls := strings.ToLower(sub)
|
||||
lp := strings.ToLower(path)
|
||||
if ls == lp {
|
||||
return false
|
||||
}
|
||||
return strings.HasPrefix(ls, lp)
|
||||
}
|
||||
|
||||
func checkInGOPATH() {
|
||||
pwd, err := os.Getwd()
|
||||
if err != nil {
|
||||
log.Fatal("Unable to determine current working directory", err)
|
||||
}
|
||||
dirs := build.Default.SrcDirs()
|
||||
for _, p := range dirs {
|
||||
if ok := subPath(pwd, p); ok {
|
||||
return
|
||||
}
|
||||
}
|
||||
|
||||
log.Println("[WARNING]: godep should only be used inside a valid go package directory and")
|
||||
log.Println("[WARNING]: may not function correctly. You are probably outside of your $GOPATH.")
|
||||
log.Printf("[WARNING]:\tCurrent Directory: %s\n", pwd)
|
||||
log.Printf("[WARNING]:\t$GOPATH: %s\n", os.Getenv("GOPATH"))
|
||||
}
|
||||
|
||||
var usageTemplate = `
|
||||
Godep is a tool for managing Go package dependencies.
|
||||
|
||||
Usage:
|
||||
|
||||
godep command [arguments]
|
||||
|
||||
The commands are:
|
||||
{{range .}}
|
||||
{{.Name | printf "%-8s"}} {{.Short}}{{end}}
|
||||
|
||||
Use "godep help [command]" for more information about a command.
|
||||
`
|
||||
|
||||
var helpTemplate = `
|
||||
Args: godep {{.Name}} [-v] [-d] {{.Args}}
|
||||
|
||||
{{.Long | trim}}
|
||||
|
||||
If -v is given, verbose output is enabled.
|
||||
|
||||
If -d is given, debug output is enabled (you probably don't want this, see -v).
|
||||
|
||||
`
|
||||
|
||||
func help(args []string) {
|
||||
if len(args) == 0 {
|
||||
printUsage(os.Stdout)
|
||||
return
|
||||
}
|
||||
if len(args) != 1 {
|
||||
fmt.Fprintf(os.Stderr, "usage: godep help command\n\n")
|
||||
fmt.Fprintf(os.Stderr, "Too many arguments given.\n")
|
||||
os.Exit(2)
|
||||
}
|
||||
for _, cmd := range commands {
|
||||
if cmd.Name == args[0] {
|
||||
tmpl(os.Stdout, helpTemplate, cmd)
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func usageExit() {
|
||||
printUsage(os.Stderr)
|
||||
os.Exit(2)
|
||||
}
|
||||
|
||||
func printUsage(w io.Writer) {
|
||||
tmpl(w, usageTemplate, commands)
|
||||
}
|
||||
|
||||
// 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,
|
||||
})
|
||||
template.Must(t.Parse(strings.TrimSpace(text) + "\n\n"))
|
||||
if err := t.Execute(w, data); err != nil {
|
||||
panic(err)
|
||||
}
|
||||
}
|
||||
|
|
@ -1,35 +0,0 @@
|
|||
package main
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"log"
|
||||
|
||||
"github.com/kr/pretty"
|
||||
)
|
||||
|
||||
func debugln(a ...interface{}) (int, error) {
|
||||
if debug {
|
||||
return fmt.Println(a...)
|
||||
}
|
||||
return 0, nil
|
||||
}
|
||||
|
||||
func verboseln(a ...interface{}) {
|
||||
if verbose {
|
||||
log.Println(a...)
|
||||
}
|
||||
}
|
||||
|
||||
func debugf(format string, a ...interface{}) (int, error) {
|
||||
if debug {
|
||||
return fmt.Printf(format, a...)
|
||||
}
|
||||
return 0, nil
|
||||
}
|
||||
|
||||
func ppln(a ...interface{}) (int, error) {
|
||||
if debug {
|
||||
return pretty.Println(a...)
|
||||
}
|
||||
return 0, nil
|
||||
}
|
||||
|
|
@ -1,36 +0,0 @@
|
|||
package main
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"os"
|
||||
)
|
||||
|
||||
var cmdPath = &Command{
|
||||
Name: "path",
|
||||
Short: "print GOPATH for dependency code",
|
||||
Long: `
|
||||
Command path prints a path for use in env var GOPATH
|
||||
that makes available the specified version of each dependency.
|
||||
|
||||
The printed path does not include any GOPATH value from
|
||||
the environment.
|
||||
|
||||
For more about how GOPATH works, see 'go help gopath'.
|
||||
`,
|
||||
Run: runPath,
|
||||
OnlyInGOPATH: true,
|
||||
}
|
||||
|
||||
// Print the gopath that points to
|
||||
// the included dependency code.
|
||||
func runPath(cmd *Command, args []string) {
|
||||
if len(args) != 0 {
|
||||
cmd.UsageExit()
|
||||
}
|
||||
if VendorExperiment {
|
||||
fmt.Fprintln(os.Stderr, "Error: GO15VENDOREXPERIMENT is enabled and the vendor/ directory is not a valid Go workspace.")
|
||||
os.Exit(1)
|
||||
}
|
||||
gopath := prepareGopath()
|
||||
fmt.Println(gopath)
|
||||
}
|
||||
|
|
@ -1,94 +0,0 @@
|
|||
package main
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"go/build"
|
||||
"os"
|
||||
"regexp"
|
||||
"sort"
|
||||
"strings"
|
||||
)
|
||||
|
||||
// Package represents a Go package.
|
||||
type Package struct {
|
||||
Dir string
|
||||
Root string
|
||||
ImportPath string
|
||||
Deps []string
|
||||
Standard bool
|
||||
Processed bool
|
||||
|
||||
GoFiles []string
|
||||
CgoFiles []string
|
||||
IgnoredGoFiles []string
|
||||
|
||||
TestGoFiles []string
|
||||
TestImports []string
|
||||
XTestGoFiles []string
|
||||
XTestImports []string
|
||||
|
||||
Error struct {
|
||||
Err string
|
||||
}
|
||||
|
||||
// --- New stuff for now
|
||||
Imports []string
|
||||
Dependencies []build.Package
|
||||
}
|
||||
|
||||
// LoadPackages loads the named packages
|
||||
// Unlike the go tool, an empty argument list is treated as an empty list; "."
|
||||
// must be given explicitly if desired.
|
||||
// IgnoredGoFiles will be processed and their dependencies resolved recursively
|
||||
func LoadPackages(names ...string) (a []*Package, err error) {
|
||||
debugln("LoadPackages", names)
|
||||
if len(names) == 0 {
|
||||
return nil, nil
|
||||
}
|
||||
|
||||
pkgs := strings.Split(ignorePackages, ",")
|
||||
sort.Strings(pkgs)
|
||||
for _, i := range importPaths(names) {
|
||||
p, err := listPackage(i)
|
||||
if err != nil {
|
||||
if len(pkgs) > 0 {
|
||||
idx := sort.SearchStrings(pkgs, i)
|
||||
if idx < len(pkgs) && pkgs[idx] == i {
|
||||
fmt.Fprintf(os.Stderr, "warning: ignoring package %q \n", i)
|
||||
continue
|
||||
}
|
||||
}
|
||||
return nil, err
|
||||
}
|
||||
a = append(a, p)
|
||||
}
|
||||
return a, nil
|
||||
}
|
||||
|
||||
func (p *Package) allGoFiles() []string {
|
||||
var a []string
|
||||
a = append(a, p.GoFiles...)
|
||||
a = append(a, p.CgoFiles...)
|
||||
a = append(a, p.TestGoFiles...)
|
||||
a = append(a, p.XTestGoFiles...)
|
||||
a = append(a, p.IgnoredGoFiles...)
|
||||
return a
|
||||
}
|
||||
|
||||
// matchPattern(pattern)(name) reports whether
|
||||
// name matches pattern. Pattern is a limited glob
|
||||
// pattern in which '...' means 'any string' and there
|
||||
// is no other special syntax.
|
||||
// Taken from $GOROOT/src/cmd/go/main.go.
|
||||
func matchPattern(pattern string) func(name string) bool {
|
||||
re := regexp.QuoteMeta(pattern)
|
||||
re = strings.Replace(re, `\.\.\.`, `.*`, -1)
|
||||
// Special case: foo/... matches foo too.
|
||||
if strings.HasSuffix(re, `/.*`) {
|
||||
re = re[:len(re)-len(`/.*`)] + `(/.*)?`
|
||||
}
|
||||
reg := regexp.MustCompile(`^` + re + `$`)
|
||||
return func(name string) bool {
|
||||
return reg.MatchString(name)
|
||||
}
|
||||
}
|
||||
|
|
@ -1,195 +0,0 @@
|
|||
package main
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"go/build"
|
||||
"log"
|
||||
"os"
|
||||
"path/filepath"
|
||||
|
||||
"golang.org/x/tools/go/vcs"
|
||||
)
|
||||
|
||||
var cmdRestore = &Command{
|
||||
Name: "restore",
|
||||
Short: "check out listed dependency versions in GOPATH",
|
||||
Long: `
|
||||
Restore checks out the Godeps-specified version of each package in GOPATH.
|
||||
|
||||
NOTE: restore leaves git repositories in a detached state. go1.6+ no longer
|
||||
checks out the master branch when doing a "go get", see:
|
||||
https://github.com/golang/go/commit/42206598671a44111c8f726ad33dc7b265bdf669.
|
||||
|
||||
`,
|
||||
Run: runRestore,
|
||||
OnlyInGOPATH: true,
|
||||
}
|
||||
|
||||
// Three phases:
|
||||
// 1. Download all deps
|
||||
// 2. Restore all deps (checkout the recorded rev)
|
||||
// 3. Attempt to load all deps as a simple consistency check
|
||||
func runRestore(cmd *Command, args []string) {
|
||||
if len(build.Default.GOPATH) == 0 {
|
||||
log.Println("Error restore requires GOPATH but it is empty.")
|
||||
os.Exit(1)
|
||||
}
|
||||
|
||||
var hadError bool
|
||||
checkErr := func(s string) {
|
||||
if hadError {
|
||||
log.Println(s)
|
||||
os.Exit(1)
|
||||
}
|
||||
}
|
||||
|
||||
g, err := loadDefaultGodepsFile()
|
||||
if err != nil {
|
||||
log.Fatalln(err)
|
||||
}
|
||||
for i, dep := range g.Deps {
|
||||
verboseln("Downloading dependency (if needed):", dep.ImportPath)
|
||||
err := download(&dep)
|
||||
if err != nil {
|
||||
log.Printf("error downloading dep (%s): %s\n", dep.ImportPath, err)
|
||||
hadError = true
|
||||
}
|
||||
g.Deps[i] = dep
|
||||
}
|
||||
checkErr("Error downloading some deps. Aborting restore and check.")
|
||||
for _, dep := range g.Deps {
|
||||
verboseln("Restoring dependency (if needed):", dep.ImportPath)
|
||||
err := restore(dep)
|
||||
if err != nil {
|
||||
log.Printf("error restoring dep (%s): %s\n", dep.ImportPath, err)
|
||||
hadError = true
|
||||
}
|
||||
}
|
||||
checkErr("Error restoring some deps. Aborting check.")
|
||||
for _, dep := range g.Deps {
|
||||
verboseln("Checking dependency:", dep.ImportPath)
|
||||
_, err := LoadPackages(dep.ImportPath)
|
||||
if err != nil {
|
||||
log.Printf("Dep (%s) restored, but was unable to load it with error:\n\t%s\n", dep.ImportPath, err)
|
||||
if me, ok := err.(errorMissingDep); ok {
|
||||
log.Println("\tThis may be because the dependencies were saved with an older version of godep (< v33).")
|
||||
log.Printf("\tTry `go get %s`. Then `godep save` to update deps.\n", me.i)
|
||||
}
|
||||
hadError = true
|
||||
}
|
||||
}
|
||||
checkErr("Error checking some deps.")
|
||||
}
|
||||
|
||||
var downloaded = make(map[string]bool)
|
||||
|
||||
// download the given dependency.
|
||||
// 2 Passes: 1) go get -d <pkg>, 2) git pull (if necessary)
|
||||
func download(dep *Dependency) error {
|
||||
|
||||
rr, err := vcs.RepoRootForImportPath(dep.ImportPath, debug)
|
||||
if err != nil {
|
||||
debugln("Error determining repo root for", dep.ImportPath)
|
||||
return err
|
||||
}
|
||||
ppln("rr", rr)
|
||||
|
||||
dep.vcs = cmd[rr.VCS]
|
||||
|
||||
// try to find an existing directory in the GOPATHs
|
||||
for _, gp := range filepath.SplitList(build.Default.GOPATH) {
|
||||
t := filepath.Join(gp, "src", rr.Root)
|
||||
fi, err := os.Stat(t)
|
||||
if err != nil {
|
||||
continue
|
||||
}
|
||||
if fi.IsDir() {
|
||||
dep.root = t
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
// If none found, just pick the first GOPATH entry (AFAICT that's what go get does)
|
||||
if dep.root == "" {
|
||||
dep.root = filepath.Join(filepath.SplitList(build.Default.GOPATH)[0], "src", rr.Root)
|
||||
}
|
||||
ppln("dep", dep)
|
||||
|
||||
if downloaded[rr.Repo] {
|
||||
verboseln("Skipping already downloaded repo", rr.Repo)
|
||||
return nil
|
||||
}
|
||||
|
||||
fi, err := os.Stat(dep.root)
|
||||
if err != nil {
|
||||
if os.IsNotExist(err) {
|
||||
if err := os.MkdirAll(filepath.Dir(dep.root), os.ModePerm); err != nil {
|
||||
debugln("Error creating base dir of", dep.root)
|
||||
return err
|
||||
}
|
||||
err := rr.VCS.CreateAtRev(dep.root, rr.Repo, dep.Rev)
|
||||
debugln("CreatedAtRev", dep.root, rr.Repo, dep.Rev)
|
||||
if err != nil {
|
||||
debugln("CreateAtRev error", err)
|
||||
return err
|
||||
}
|
||||
downloaded[rr.Repo] = true
|
||||
return nil
|
||||
}
|
||||
debugln("Error checking repo root for", dep.ImportPath, "at", dep.root, ":", err)
|
||||
return err
|
||||
}
|
||||
|
||||
if !fi.IsDir() {
|
||||
return errors.New("repo root src dir exists, but isn't a directory for " + dep.ImportPath + " at " + dep.root)
|
||||
}
|
||||
|
||||
if !dep.vcs.exists(dep.root, dep.Rev) {
|
||||
debugln("Updating existing", dep.root)
|
||||
if dep.vcs == vcsGit {
|
||||
detached, err := gitDetached(dep.root)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if detached {
|
||||
db, err := gitDefaultBranch(dep.root)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if err := gitCheckout(dep.root, db); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
dep.vcs.vcs.Download(dep.root)
|
||||
downloaded[rr.Repo] = true
|
||||
}
|
||||
|
||||
debugln("Nothing to download")
|
||||
return nil
|
||||
}
|
||||
|
||||
var restored = make(map[string]string) // dep.root -> dep.Rev
|
||||
|
||||
// restore checks out the given revision.
|
||||
func restore(dep Dependency) error {
|
||||
rev, ok := restored[dep.root]
|
||||
debugln(rev)
|
||||
debugln(ok)
|
||||
debugln(dep.root)
|
||||
if ok {
|
||||
if rev != dep.Rev {
|
||||
return errors.New("Wanted to restore rev " + dep.Rev + ", already restored rev " + rev + " for another package in the repo")
|
||||
}
|
||||
verboseln("Skipping already restored repo")
|
||||
return nil
|
||||
}
|
||||
|
||||
debugln("Restoring:", dep.ImportPath, dep.Rev)
|
||||
err := dep.vcs.RevSync(dep.root, dep.Rev)
|
||||
if err == nil {
|
||||
restored[dep.root] = dep.Rev
|
||||
}
|
||||
return err
|
||||
}
|
||||
|
|
@ -1,171 +0,0 @@
|
|||
package main
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"log"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"strconv"
|
||||
"strings"
|
||||
|
||||
"go/ast"
|
||||
"go/parser"
|
||||
"go/printer"
|
||||
"go/token"
|
||||
|
||||
"github.com/kr/fs"
|
||||
)
|
||||
|
||||
// rewrite visits the go files in pkgs, plus all go files
|
||||
// in the directory tree Godeps, rewriting import statements
|
||||
// according to the rules for func qualify.
|
||||
func rewrite(pkgs []*Package, qual string, paths []string) error {
|
||||
for _, path := range pkgFiles(pkgs) {
|
||||
debugln("rewrite", path)
|
||||
err := rewriteTree(path, qual, paths)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
return rewriteTree("Godeps", qual, paths)
|
||||
}
|
||||
|
||||
// pkgFiles returns the full filesystem path to all go files in pkgs.
|
||||
func pkgFiles(pkgs []*Package) []string {
|
||||
var a []string
|
||||
for _, pkg := range pkgs {
|
||||
for _, s := range pkg.allGoFiles() {
|
||||
a = append(a, filepath.Join(pkg.Dir, s))
|
||||
}
|
||||
}
|
||||
return a
|
||||
}
|
||||
|
||||
// rewriteTree recursively visits the go files in path, rewriting
|
||||
// import statements according to the rules for func qualify.
|
||||
// This function ignores the 'testdata' directory.
|
||||
func rewriteTree(path, qual string, paths []string) error {
|
||||
w := fs.Walk(path)
|
||||
for w.Step() {
|
||||
if w.Err() != nil {
|
||||
log.Println("rewrite:", w.Err())
|
||||
continue
|
||||
}
|
||||
s := w.Stat()
|
||||
if s.IsDir() && s.Name() == "testdata" {
|
||||
w.SkipDir()
|
||||
continue
|
||||
}
|
||||
if strings.HasSuffix(w.Path(), ".go") {
|
||||
err := rewriteGoFile(w.Path(), qual, paths)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// rewriteGoFile rewrites import statements in the named file
|
||||
// according to the rules for func qualify.
|
||||
func rewriteGoFile(name, qual string, paths []string) error {
|
||||
debugln("rewriteGoFile", name, ",", qual, ",", paths)
|
||||
printerConfig := &printer.Config{Mode: printer.TabIndent | printer.UseSpaces, Tabwidth: 8}
|
||||
fset := token.NewFileSet()
|
||||
f, err := parser.ParseFile(fset, name, nil, parser.ParseComments)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
var changed bool
|
||||
for _, s := range f.Imports {
|
||||
name, err := strconv.Unquote(s.Path.Value)
|
||||
if err != nil {
|
||||
return err // can't happen
|
||||
}
|
||||
q := qualify(unqualify(name), qual, paths)
|
||||
if q != name {
|
||||
s.Path.Value = strconv.Quote(q)
|
||||
changed = true
|
||||
}
|
||||
}
|
||||
if !changed {
|
||||
return nil
|
||||
}
|
||||
var buffer bytes.Buffer
|
||||
if err = printerConfig.Fprint(&buffer, fset, f); err != nil {
|
||||
return err
|
||||
}
|
||||
fset = token.NewFileSet()
|
||||
f, err = parser.ParseFile(fset, name, &buffer, parser.ParseComments)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
ast.SortImports(fset, f)
|
||||
tpath := name + ".temp"
|
||||
t, err := os.Create(tpath)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if err = printerConfig.Fprint(t, fset, f); err != nil {
|
||||
return err
|
||||
}
|
||||
if err = t.Close(); err != nil {
|
||||
return err
|
||||
}
|
||||
// This is required before the rename on windows.
|
||||
if err = os.Remove(name); err != nil {
|
||||
return err
|
||||
}
|
||||
return os.Rename(tpath, name)
|
||||
}
|
||||
|
||||
func defaultSep(experiment bool) string {
|
||||
if experiment {
|
||||
return "/vendor/"
|
||||
}
|
||||
return "/Godeps/_workspace/src/"
|
||||
}
|
||||
|
||||
func relativeVendorTarget(experiment bool) string {
|
||||
full := defaultSep(experiment)
|
||||
if full[0] == '/' {
|
||||
full = full[1:]
|
||||
}
|
||||
return filepath.FromSlash(full)
|
||||
}
|
||||
|
||||
// unqualify returns the part of importPath after the last
|
||||
// occurrence of the signature path elements
|
||||
// (Godeps/_workspace/src) that always precede imported
|
||||
// packages in rewritten import paths.
|
||||
//
|
||||
// For example,
|
||||
// unqualify(C) = C
|
||||
// unqualify(D/Godeps/_workspace/src/C) = C
|
||||
func unqualify(importPath string) string {
|
||||
if i := strings.LastIndex(importPath, sep); i != -1 {
|
||||
importPath = importPath[i+len(sep):]
|
||||
}
|
||||
return importPath
|
||||
}
|
||||
|
||||
// qualify qualifies importPath with its corresponding import
|
||||
// path in the Godeps src copy of package pkg. If importPath
|
||||
// is a directory lexically contained in a path in paths,
|
||||
// it will be qualified with package pkg; otherwise, it will
|
||||
// be returned unchanged.
|
||||
//
|
||||
// For example, given paths {D, T} and pkg C,
|
||||
// importPath returns
|
||||
// C C
|
||||
// fmt fmt
|
||||
// D C/Godeps/_workspace/src/D
|
||||
// D/P C/Godeps/_workspace/src/D/P
|
||||
// T C/Godeps/_workspace/src/T
|
||||
func qualify(importPath, pkg string, paths []string) string {
|
||||
if containsPathPrefix(paths, importPath) {
|
||||
return pkg + sep + importPath
|
||||
}
|
||||
return importPath
|
||||
}
|
||||
|
|
@ -1,613 +0,0 @@
|
|||
package main
|
||||
|
||||
import (
|
||||
"bufio"
|
||||
"bytes"
|
||||
"errors"
|
||||
"fmt"
|
||||
"go/build"
|
||||
"io"
|
||||
"io/ioutil"
|
||||
"log"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"regexp"
|
||||
"strings"
|
||||
|
||||
"github.com/kr/fs"
|
||||
)
|
||||
|
||||
var cmdSave = &Command{
|
||||
Name: "save",
|
||||
Args: "[-r] [-t] [packages]",
|
||||
Short: "list and copy dependencies into Godeps",
|
||||
Long: `
|
||||
|
||||
Save writes a list of the named packages and their dependencies along
|
||||
with the exact source control revision of each package, and copies
|
||||
their source code into a subdirectory. Packages inside "." are excluded
|
||||
from the list to be copied.
|
||||
|
||||
The list is written to Godeps/Godeps.json, and source code for all
|
||||
dependencies is copied into either Godeps/_workspace or, if the vendor
|
||||
experiment is turned on, vendor/.
|
||||
|
||||
The dependency list is a JSON document with the following structure:
|
||||
|
||||
type Godeps struct {
|
||||
ImportPath string
|
||||
GoVersion string // Abridged output of 'go version'.
|
||||
Packages []string // Arguments to godep save, if any.
|
||||
Deps []struct {
|
||||
ImportPath string
|
||||
Comment string // Tag or description of commit.
|
||||
Rev string // VCS-specific commit ID.
|
||||
}
|
||||
}
|
||||
|
||||
Any packages already present in the list will be left unchanged.
|
||||
To update a dependency to a newer revision, use 'godep update'.
|
||||
|
||||
If -r is given, import statements will be rewritten to refer directly
|
||||
to the copied source code. This is not compatible with the vendor
|
||||
experiment. Note that this will not rewrite the statements in the
|
||||
files outside the project.
|
||||
|
||||
If -t is given, test files (*_test.go files + testdata directories) are
|
||||
also saved.
|
||||
|
||||
For more about specifying packages, see 'go help packages'.
|
||||
`,
|
||||
Run: runSave,
|
||||
OnlyInGOPATH: true,
|
||||
}
|
||||
|
||||
var (
|
||||
saveR, saveT bool
|
||||
ignorePackages string
|
||||
)
|
||||
|
||||
func init() {
|
||||
cmdSave.Flag.BoolVar(&saveR, "r", false, "rewrite import paths")
|
||||
cmdSave.Flag.BoolVar(&saveT, "t", false, "save test files")
|
||||
cmdSave.Flag.StringVar(&ignorePackages, "i", "", "list of packages to ignore separated by commas")
|
||||
}
|
||||
|
||||
func runSave(cmd *Command, args []string) {
|
||||
if VendorExperiment && saveR {
|
||||
log.Println("flag -r is incompatible with the vendoring experiment")
|
||||
cmd.UsageExit()
|
||||
}
|
||||
err := save(args)
|
||||
if err != nil {
|
||||
log.Fatalln(err)
|
||||
}
|
||||
}
|
||||
|
||||
func dotPackage() (*build.Package, error) {
|
||||
dir, err := filepath.Abs(".")
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return build.ImportDir(dir, build.FindOnly)
|
||||
}
|
||||
|
||||
func projectPackages(dDir string, a []*Package) []*Package {
|
||||
var projPkgs []*Package
|
||||
dotDir := fmt.Sprintf("%s%c", dDir, filepath.Separator)
|
||||
for _, p := range a {
|
||||
pkgDir := fmt.Sprintf("%s%c", p.Dir, filepath.Separator)
|
||||
if strings.HasPrefix(pkgDir, dotDir) {
|
||||
projPkgs = append(projPkgs, p)
|
||||
}
|
||||
}
|
||||
return projPkgs
|
||||
}
|
||||
|
||||
func save(pkgs []string) error {
|
||||
var err error
|
||||
dp, err := dotPackage()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
debugln("dotPackageImportPath:", dp.ImportPath)
|
||||
debugln("dotPackageDir:", dp.Dir)
|
||||
|
||||
cv, err := goVersion()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
verboseln("Go Version:", cv)
|
||||
|
||||
gold, err := loadDefaultGodepsFile()
|
||||
if err != nil {
|
||||
if !os.IsNotExist(err) {
|
||||
return err
|
||||
}
|
||||
verboseln("No old Godeps.json found.")
|
||||
gold.GoVersion = cv
|
||||
}
|
||||
|
||||
printVersionWarnings(gold.GoVersion)
|
||||
if len(gold.GoVersion) == 0 {
|
||||
gold.GoVersion = majorGoVersion
|
||||
} else {
|
||||
majorGoVersion, err = trimGoVersion(gold.GoVersion)
|
||||
if err != nil {
|
||||
log.Fatalf("Unable to determine go major version from value specified in %s: %s\n", gold.file(), gold.GoVersion)
|
||||
}
|
||||
}
|
||||
|
||||
gnew := &Godeps{
|
||||
ImportPath: dp.ImportPath,
|
||||
GoVersion: gold.GoVersion,
|
||||
}
|
||||
|
||||
switch len(pkgs) {
|
||||
case 0:
|
||||
pkgs = []string{"."}
|
||||
default:
|
||||
gnew.Packages = pkgs
|
||||
}
|
||||
|
||||
verboseln("Finding dependencies for", pkgs)
|
||||
a, err := LoadPackages(pkgs...)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
for _, p := range a {
|
||||
verboseln("Found package:", p.ImportPath)
|
||||
verboseln("\tDeps:", strings.Join(p.Deps, " "))
|
||||
}
|
||||
ppln(a)
|
||||
|
||||
projA := projectPackages(dp.Dir, a)
|
||||
debugln("Filtered projectPackages")
|
||||
ppln(projA)
|
||||
|
||||
verboseln("Computing new Godeps.json file")
|
||||
err = gnew.fill(a, dp.ImportPath)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
debugln("New Godeps Filled")
|
||||
ppln(gnew)
|
||||
|
||||
if gnew.Deps == nil {
|
||||
gnew.Deps = make([]Dependency, 0) // produce json [], not null
|
||||
}
|
||||
gdisk := gnew.copy()
|
||||
err = carryVersions(&gold, gnew)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
if gold.isOldFile {
|
||||
// If we are migrating from an old format file,
|
||||
// we require that the listed version of every
|
||||
// dependency must be installed in GOPATH, so it's
|
||||
// available to copy.
|
||||
if !eqDeps(gnew.Deps, gdisk.Deps) {
|
||||
return errors.New(strings.TrimSpace(needRestore))
|
||||
}
|
||||
gold = Godeps{}
|
||||
}
|
||||
os.Remove("Godeps") // remove regular file if present; ignore error
|
||||
readme := filepath.Join("Godeps", "Readme")
|
||||
err = writeFile(readme, strings.TrimSpace(Readme)+"\n")
|
||||
if err != nil {
|
||||
log.Println(err)
|
||||
}
|
||||
_, err = gnew.save()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
verboseln("Computing diff between old and new deps")
|
||||
// We use a name starting with "_" so the go tool
|
||||
// ignores this directory when traversing packages
|
||||
// starting at the project's root. For example,
|
||||
// godep go list ./...
|
||||
srcdir := filepath.FromSlash(strings.Trim(sep, "/"))
|
||||
rem := subDeps(gold.Deps, gnew.Deps)
|
||||
ppln(rem)
|
||||
add := subDeps(gnew.Deps, gold.Deps)
|
||||
ppln(add)
|
||||
if len(rem) > 0 {
|
||||
verboseln("Deps to remove:")
|
||||
for _, r := range rem {
|
||||
verboseln("\t", r.ImportPath)
|
||||
}
|
||||
verboseln("Removing unused dependencies")
|
||||
err = removeSrc(srcdir, rem)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
if len(add) > 0 {
|
||||
verboseln("Deps to add:")
|
||||
for _, a := range add {
|
||||
verboseln("\t", a.ImportPath)
|
||||
}
|
||||
verboseln("Adding new dependencies")
|
||||
err = copySrc(srcdir, add)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
if !VendorExperiment {
|
||||
f, _ := filepath.Split(srcdir)
|
||||
writeVCSIgnore(f)
|
||||
}
|
||||
var rewritePaths []string
|
||||
if saveR {
|
||||
for _, dep := range gnew.Deps {
|
||||
rewritePaths = append(rewritePaths, dep.ImportPath)
|
||||
}
|
||||
}
|
||||
verboseln("Rewriting paths (if necessary)")
|
||||
ppln(rewritePaths)
|
||||
return rewrite(projA, dp.ImportPath, rewritePaths)
|
||||
}
|
||||
|
||||
func printVersionWarnings(ov string) {
|
||||
var warning bool
|
||||
cv, err := goVersion()
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
// Trim the old version because we may have saved it w/o trimming it
|
||||
// cv is already trimmed by goVersion()
|
||||
tov, err := trimGoVersion(ov)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
|
||||
if tov != ov {
|
||||
log.Printf("WARNING: Recorded go version (%s) with minor version string found.\n", ov)
|
||||
warning = true
|
||||
}
|
||||
if cv != tov {
|
||||
log.Printf("WARNING: Recorded major go version (%s) and in-use major go version (%s) differ.\n", tov, cv)
|
||||
warning = true
|
||||
}
|
||||
if warning {
|
||||
log.Println("To record current major go version run `godep update -goversion`.")
|
||||
}
|
||||
}
|
||||
|
||||
type revError struct {
|
||||
ImportPath string
|
||||
WantRev string
|
||||
HavePath string
|
||||
HaveRev string
|
||||
}
|
||||
|
||||
func (v *revError) Error() string {
|
||||
return fmt.Sprintf("cannot save %s at revision %s: already have %s at revision %s.\n"+
|
||||
"Run `godep update %s' first.", v.ImportPath, v.WantRev, v.HavePath, v.HaveRev, v.HavePath)
|
||||
}
|
||||
|
||||
// carryVersions copies Rev and Comment from a to b for
|
||||
// each dependency with an identical ImportPath. For any
|
||||
// dependency in b that appears to be from the same repo
|
||||
// as one in a (for example, a parent or child directory),
|
||||
// the Rev must already match - otherwise it is an error.
|
||||
func carryVersions(a, b *Godeps) error {
|
||||
for i := range b.Deps {
|
||||
err := carryVersion(a, &b.Deps[i])
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func carryVersion(a *Godeps, db *Dependency) error {
|
||||
// First see if this exact package is already in the list.
|
||||
for _, da := range a.Deps {
|
||||
if db.ImportPath == da.ImportPath {
|
||||
db.Rev = da.Rev
|
||||
db.Comment = da.Comment
|
||||
return nil
|
||||
}
|
||||
}
|
||||
// No exact match, check for child or sibling package.
|
||||
// We can't handle mismatched versions for packages in
|
||||
// the same repo, so report that as an error.
|
||||
for _, da := range a.Deps {
|
||||
if strings.HasPrefix(db.ImportPath, da.ImportPath+"/") ||
|
||||
strings.HasPrefix(da.ImportPath, db.root+"/") {
|
||||
if da.Rev != db.Rev {
|
||||
return &revError{
|
||||
ImportPath: db.ImportPath,
|
||||
WantRev: db.Rev,
|
||||
HavePath: da.ImportPath,
|
||||
HaveRev: da.Rev,
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
// No related package in the list, must be a new repo.
|
||||
return nil
|
||||
}
|
||||
|
||||
// subDeps returns a - b, using ImportPath for equality.
|
||||
func subDeps(a, b []Dependency) (diff []Dependency) {
|
||||
Diff:
|
||||
for _, da := range a {
|
||||
for _, db := range b {
|
||||
if da.ImportPath == db.ImportPath {
|
||||
continue Diff
|
||||
}
|
||||
}
|
||||
diff = append(diff, da)
|
||||
}
|
||||
return diff
|
||||
}
|
||||
|
||||
func removeSrc(srcdir string, deps []Dependency) error {
|
||||
for _, dep := range deps {
|
||||
path := filepath.FromSlash(dep.ImportPath)
|
||||
err := os.RemoveAll(filepath.Join(srcdir, path))
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func copySrc(dir string, deps []Dependency) error {
|
||||
// mapping to see if we visited a parent directory already
|
||||
visited := make(map[string]bool)
|
||||
ok := true
|
||||
for _, dep := range deps {
|
||||
debugln("copySrc for", dep.ImportPath)
|
||||
srcdir := filepath.Join(dep.ws, "src")
|
||||
rel, err := filepath.Rel(srcdir, dep.dir)
|
||||
debugln("srcdir", srcdir)
|
||||
debugln("rel", rel)
|
||||
debugln("err", err)
|
||||
if err != nil { // this should never happen
|
||||
return err
|
||||
}
|
||||
dstpkgroot := filepath.Join(dir, rel)
|
||||
err = os.RemoveAll(dstpkgroot)
|
||||
if err != nil {
|
||||
log.Println(err)
|
||||
ok = false
|
||||
}
|
||||
|
||||
// copy actual dependency
|
||||
vf := dep.vcs.listFiles(dep.dir)
|
||||
debugln("vf", vf)
|
||||
w := fs.Walk(dep.dir)
|
||||
for w.Step() {
|
||||
err = copyPkgFile(vf, dir, srcdir, w)
|
||||
if err != nil {
|
||||
log.Println(err)
|
||||
ok = false
|
||||
}
|
||||
}
|
||||
|
||||
// Look for legal files in root
|
||||
// some packages are imports as a sub-package but license info
|
||||
// is at root: exampleorg/common has license file in exampleorg
|
||||
//
|
||||
if dep.ImportPath == dep.root {
|
||||
// we are already at root
|
||||
continue
|
||||
}
|
||||
|
||||
// prevent copying twice This could happen if we have
|
||||
// two subpackages listed someorg/common and
|
||||
// someorg/anotherpack which has their license in
|
||||
// the parent dir of someorg
|
||||
rootdir := filepath.Join(srcdir, filepath.FromSlash(dep.root))
|
||||
if visited[rootdir] {
|
||||
continue
|
||||
}
|
||||
visited[rootdir] = true
|
||||
vf = dep.vcs.listFiles(rootdir)
|
||||
w = fs.Walk(rootdir)
|
||||
for w.Step() {
|
||||
fname := filepath.Base(w.Path())
|
||||
if IsLegalFile(fname) && !strings.Contains(w.Path(), sep) {
|
||||
err = copyPkgFile(vf, dir, srcdir, w)
|
||||
if err != nil {
|
||||
log.Println(err)
|
||||
ok = false
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if !ok {
|
||||
return errorCopyingSourceCode
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func copyPkgFile(vf vcsFiles, dstroot, srcroot string, w *fs.Walker) error {
|
||||
if w.Err() != nil {
|
||||
return w.Err()
|
||||
}
|
||||
name := w.Stat().Name()
|
||||
if w.Stat().IsDir() {
|
||||
if name[0] == '.' || name[0] == '_' || (!saveT && name == "testdata") {
|
||||
// Skip directories starting with '.' or '_' or
|
||||
// 'testdata' (last is only skipped if saveT is false)
|
||||
w.SkipDir()
|
||||
}
|
||||
return nil
|
||||
}
|
||||
rel, err := filepath.Rel(srcroot, w.Path())
|
||||
if err != nil { // this should never happen
|
||||
return err
|
||||
}
|
||||
if !saveT && strings.HasSuffix(name, "_test.go") {
|
||||
if verbose {
|
||||
log.Printf("save: skipping test file: %s", w.Path())
|
||||
}
|
||||
return nil
|
||||
}
|
||||
if !vf.Contains(w.Path()) {
|
||||
if verbose {
|
||||
log.Printf("save: skipping untracked file: %s", w.Path())
|
||||
}
|
||||
return nil
|
||||
}
|
||||
return copyFile(filepath.Join(dstroot, rel), w.Path())
|
||||
}
|
||||
|
||||
// copyFile copies a regular file from src to dst.
|
||||
// dst is opened with os.Create.
|
||||
// If the file name ends with .go,
|
||||
// copyFile strips canonical import path annotations.
|
||||
// These are comments of the form:
|
||||
// package foo // import "bar/foo"
|
||||
// package foo /* import "bar/foo" */
|
||||
func copyFile(dst, src string) error {
|
||||
err := os.MkdirAll(filepath.Dir(dst), 0777)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
linkDst, err := os.Readlink(src)
|
||||
if err == nil {
|
||||
return os.Symlink(linkDst, dst)
|
||||
}
|
||||
|
||||
si, err := stat(src)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
r, err := os.Open(src)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
defer r.Close()
|
||||
|
||||
w, err := os.Create(dst)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if err := os.Chmod(dst, si.Mode()); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
if strings.HasSuffix(dst, ".go") {
|
||||
debugln("Copy Without Import Comment", w, r)
|
||||
err = copyWithoutImportComment(w, r)
|
||||
} else {
|
||||
debugln("Copy (plain)", w, r)
|
||||
_, err = io.Copy(w, r)
|
||||
}
|
||||
err1 := w.Close()
|
||||
if err == nil {
|
||||
err = err1
|
||||
}
|
||||
|
||||
return err
|
||||
}
|
||||
|
||||
func copyWithoutImportComment(w io.Writer, r io.Reader) error {
|
||||
b := bufio.NewReader(r)
|
||||
for {
|
||||
l, err := b.ReadBytes('\n')
|
||||
eof := err == io.EOF
|
||||
if err != nil && err != io.EOF {
|
||||
return err
|
||||
}
|
||||
|
||||
// If we have data then write it out...
|
||||
if len(l) > 0 {
|
||||
// Strip off \n if it exists because stripImportComment
|
||||
_, err := w.Write(append(stripImportComment(bytes.TrimRight(l, "\n")), '\n'))
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
|
||||
if eof {
|
||||
return nil
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
const (
|
||||
importAnnotation = `import\s+(?:"[^"]*"|` + "`[^`]*`" + `)`
|
||||
importComment = `(?://\s*` + importAnnotation + `\s*$|/\*\s*` + importAnnotation + `\s*\*/)`
|
||||
)
|
||||
|
||||
var (
|
||||
importCommentRE = regexp.MustCompile(`^\s*(package\s+\w+)\s+` + importComment + `(.*)`)
|
||||
pkgPrefix = []byte("package ")
|
||||
)
|
||||
|
||||
// stripImportComment returns line with its import comment removed.
|
||||
// If s is not a package statement containing an import comment,
|
||||
// it is returned unaltered.
|
||||
// FIXME: expects lines w/o a \n at the end
|
||||
// See also http://golang.org/s/go14customimport.
|
||||
func stripImportComment(line []byte) []byte {
|
||||
if !bytes.HasPrefix(line, pkgPrefix) {
|
||||
// Fast path; this will skip all but one line in the file.
|
||||
// This assumes there is no whitespace before the keyword.
|
||||
return line
|
||||
}
|
||||
if m := importCommentRE.FindSubmatch(line); m != nil {
|
||||
return append(m[1], m[2]...)
|
||||
}
|
||||
return line
|
||||
}
|
||||
|
||||
// Func writeVCSIgnore writes "ignore" files inside dir for known VCSs,
|
||||
// so that dir/pkg and dir/bin don't accidentally get committed.
|
||||
// It logs any errors it encounters.
|
||||
func writeVCSIgnore(dir string) {
|
||||
// Currently git is the only VCS for which we know how to do this.
|
||||
// Mercurial and Bazaar have similar mechanisms, but they apparently
|
||||
// require writing files outside of dir.
|
||||
const ignore = "/pkg\n/bin\n"
|
||||
name := filepath.Join(dir, ".gitignore")
|
||||
err := writeFile(name, ignore)
|
||||
if err != nil {
|
||||
log.Println(err)
|
||||
}
|
||||
}
|
||||
|
||||
// writeFile is like ioutil.WriteFile but it creates
|
||||
// intermediate directories with os.MkdirAll.
|
||||
func writeFile(name, body string) error {
|
||||
err := os.MkdirAll(filepath.Dir(name), 0777)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
return ioutil.WriteFile(name, []byte(body), 0666)
|
||||
}
|
||||
|
||||
const (
|
||||
// Readme contains the README text.
|
||||
Readme = `
|
||||
This directory tree is generated automatically by godep.
|
||||
|
||||
Please do not edit.
|
||||
|
||||
See https://github.com/tools/godep for more information.
|
||||
`
|
||||
needRestore = `
|
||||
mismatched versions while migrating
|
||||
|
||||
It looks like you are switching from the old Godeps format
|
||||
(from flag -copy=false). The old format is just a file; it
|
||||
doesn't contain source code. For this migration, godep needs
|
||||
the appropriate version of each dependency to be installed in
|
||||
GOPATH, so that the source code is available to copy.
|
||||
|
||||
To fix this, run 'godep restore'.
|
||||
`
|
||||
)
|
||||
|
|
@ -1,292 +0,0 @@
|
|||
package main
|
||||
|
||||
import (
|
||||
"go/parser"
|
||||
"go/token"
|
||||
"log"
|
||||
"os"
|
||||
"path"
|
||||
"path/filepath"
|
||||
"strconv"
|
||||
"strings"
|
||||
)
|
||||
|
||||
var cmdUpdate = &Command{
|
||||
Name: "update",
|
||||
Args: "[-goversion] [packages]",
|
||||
Short: "update selected packages or the go version",
|
||||
Long: `
|
||||
Update changes the named dependency packages to use the
|
||||
revision of each currently installed in GOPATH. New code will
|
||||
be copied into the Godeps workspace or vendor folder and the
|
||||
new revision will be written to the manifest.
|
||||
|
||||
If -goversion is specified, update the recorded go version.
|
||||
|
||||
For more about specifying packages, see 'go help packages'.
|
||||
`,
|
||||
Run: runUpdate,
|
||||
OnlyInGOPATH: true,
|
||||
}
|
||||
|
||||
var (
|
||||
updateGoVer bool
|
||||
)
|
||||
|
||||
func init() {
|
||||
cmdUpdate.Flag.BoolVar(&saveT, "t", false, "save test files during update")
|
||||
cmdUpdate.Flag.BoolVar(&updateGoVer, "goversion", false, "update the recorded go version")
|
||||
}
|
||||
|
||||
func runUpdate(cmd *Command, args []string) {
|
||||
if updateGoVer {
|
||||
err := updateGoVersion()
|
||||
if err != nil {
|
||||
log.Fatalln(err)
|
||||
}
|
||||
}
|
||||
if len(args) > 0 {
|
||||
err := update(args)
|
||||
if err != nil {
|
||||
log.Fatalln(err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func updateGoVersion() error {
|
||||
gold, err := loadDefaultGodepsFile()
|
||||
if err != nil {
|
||||
if !os.IsNotExist(err) {
|
||||
return err
|
||||
}
|
||||
}
|
||||
cv, err := goVersion()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
gv := gold.GoVersion
|
||||
gold.GoVersion = cv
|
||||
_, err = gold.save()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
if gv != cv {
|
||||
log.Println("Updated major go version to", cv)
|
||||
}
|
||||
return nil
|
||||
|
||||
}
|
||||
|
||||
func update(args []string) error {
|
||||
if len(args) == 0 {
|
||||
args = []string{"."}
|
||||
}
|
||||
g, err := loadDefaultGodepsFile()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
for _, arg := range args {
|
||||
arg := path.Clean(arg)
|
||||
any := markMatches(arg, g.Deps)
|
||||
if !any {
|
||||
log.Println("not in manifest:", arg)
|
||||
}
|
||||
}
|
||||
deps, rdeps, err := LoadVCSAndUpdate(g.Deps)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if len(deps) == 0 {
|
||||
return errorNoPackagesUpdatable
|
||||
}
|
||||
g.addOrUpdateDeps(deps)
|
||||
g.removeDeps(rdeps)
|
||||
if _, err = g.save(); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
srcdir := relativeVendorTarget(VendorExperiment)
|
||||
if err := removeSrc(filepath.FromSlash(strings.Trim(sep, "/")), rdeps); err != nil {
|
||||
return err
|
||||
}
|
||||
copySrc(srcdir, deps)
|
||||
|
||||
ok, err := needRewrite(g.Packages)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
var rewritePaths []string
|
||||
if ok {
|
||||
for _, dep := range g.Deps {
|
||||
rewritePaths = append(rewritePaths, dep.ImportPath)
|
||||
}
|
||||
}
|
||||
return rewrite(nil, g.ImportPath, rewritePaths)
|
||||
}
|
||||
|
||||
func needRewrite(importPaths []string) (bool, error) {
|
||||
if len(importPaths) == 0 {
|
||||
importPaths = []string{"."}
|
||||
}
|
||||
a, err := LoadPackages(importPaths...)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
for _, p := range a {
|
||||
for _, name := range p.allGoFiles() {
|
||||
path := filepath.Join(p.Dir, name)
|
||||
hasSep, err := hasRewrittenImportStatement(path)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
if hasSep {
|
||||
return true, nil
|
||||
}
|
||||
}
|
||||
}
|
||||
return false, nil
|
||||
}
|
||||
|
||||
func hasRewrittenImportStatement(path string) (bool, error) {
|
||||
fset := token.NewFileSet()
|
||||
f, err := parser.ParseFile(fset, path, nil, 0)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
for _, s := range f.Imports {
|
||||
name, _ := strconv.Unquote(s.Path.Value)
|
||||
if strings.Contains(name, sep) {
|
||||
return true, nil
|
||||
}
|
||||
}
|
||||
return false, nil
|
||||
}
|
||||
|
||||
// markMatches marks each entry in deps with an import path that
|
||||
// matches pat. It returns whether any matches occurred.
|
||||
func markMatches(pat string, deps []Dependency) (matched bool) {
|
||||
f := matchPattern(pat)
|
||||
for i, dep := range deps {
|
||||
if f(dep.ImportPath) {
|
||||
deps[i].matched = true
|
||||
matched = true
|
||||
}
|
||||
}
|
||||
return matched
|
||||
}
|
||||
|
||||
func fillDeps(deps []Dependency) ([]Dependency, error) {
|
||||
for i := range deps {
|
||||
if deps[i].pkg != nil {
|
||||
continue
|
||||
}
|
||||
ps, err := LoadPackages(deps[i].ImportPath)
|
||||
if err != nil {
|
||||
if _, ok := err.(errPackageNotFound); ok {
|
||||
deps[i].missing = true
|
||||
continue
|
||||
}
|
||||
return nil, err
|
||||
}
|
||||
if len(ps) > 1 {
|
||||
panic("More than one package found for " + deps[i].ImportPath)
|
||||
}
|
||||
p := ps[0]
|
||||
deps[i].pkg = p
|
||||
deps[i].dir = p.Dir
|
||||
deps[i].ws = p.Root
|
||||
|
||||
vcs, reporoot, err := VCSFromDir(p.Dir, filepath.Join(p.Root, "src"))
|
||||
if err != nil {
|
||||
return nil, errorLoadingDeps
|
||||
}
|
||||
deps[i].root = filepath.ToSlash(reporoot)
|
||||
deps[i].vcs = vcs
|
||||
}
|
||||
|
||||
return deps, nil
|
||||
}
|
||||
|
||||
// LoadVCSAndUpdate loads and updates a set of dependencies.
|
||||
func LoadVCSAndUpdate(deps []Dependency) ([]Dependency, []Dependency, error) {
|
||||
var err1 error
|
||||
|
||||
deps, err := fillDeps(deps)
|
||||
if err != nil {
|
||||
return nil, nil, err
|
||||
}
|
||||
|
||||
repoMask := make(map[string]bool)
|
||||
for i := range deps {
|
||||
if !deps[i].matched {
|
||||
repoMask[deps[i].root] = true
|
||||
}
|
||||
}
|
||||
|
||||
// Determine if we need any new packages because of new transitive imports
|
||||
for _, dep := range deps {
|
||||
if !dep.matched || dep.missing {
|
||||
continue
|
||||
}
|
||||
for _, dp := range dep.pkg.Dependencies {
|
||||
if dp.Goroot {
|
||||
continue
|
||||
}
|
||||
var have bool
|
||||
for _, d := range deps {
|
||||
if d.ImportPath == dp.ImportPath {
|
||||
have = true
|
||||
break
|
||||
}
|
||||
}
|
||||
if !have {
|
||||
deps = append(deps, Dependency{ImportPath: dp.ImportPath, matched: true})
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
deps, err = fillDeps(deps)
|
||||
if err != nil {
|
||||
return nil, nil, err
|
||||
}
|
||||
|
||||
var toUpdate, toRemove []Dependency
|
||||
for _, d := range deps {
|
||||
if !d.matched || repoMask[d.root] {
|
||||
continue
|
||||
}
|
||||
if d.missing {
|
||||
toRemove = append(toRemove, d)
|
||||
continue
|
||||
}
|
||||
toUpdate = append(toUpdate, d)
|
||||
}
|
||||
|
||||
debugln("toUpdate")
|
||||
ppln(toUpdate)
|
||||
|
||||
var toCopy []Dependency
|
||||
for _, d := range toUpdate {
|
||||
id, err := d.vcs.identify(d.dir)
|
||||
if err != nil {
|
||||
log.Println(err)
|
||||
err1 = errorLoadingDeps
|
||||
continue
|
||||
}
|
||||
if d.vcs.isDirty(d.dir, id) {
|
||||
log.Println("dirty working tree (please commit changes):", d.dir)
|
||||
}
|
||||
d.Rev = id
|
||||
d.Comment = d.vcs.describe(d.dir, id)
|
||||
toCopy = append(toCopy, d)
|
||||
}
|
||||
debugln("toCopy")
|
||||
ppln(toCopy)
|
||||
|
||||
if err1 != nil {
|
||||
return nil, nil, err1
|
||||
}
|
||||
return toCopy, toRemove, nil
|
||||
}
|
||||
|
|
@ -1,36 +0,0 @@
|
|||
package main
|
||||
|
||||
import (
|
||||
"path/filepath"
|
||||
"runtime"
|
||||
"strings"
|
||||
)
|
||||
|
||||
// driveLetterToUpper converts Windows path's drive letters to uppercase. This
|
||||
// is needed when comparing 2 paths with different drive letter case.
|
||||
func driveLetterToUpper(path string) string {
|
||||
if runtime.GOOS != "windows" || path == "" {
|
||||
return path
|
||||
}
|
||||
|
||||
p := path
|
||||
|
||||
// If path's drive letter is lowercase, change it to uppercase.
|
||||
if len(p) >= 2 && p[1] == ':' && 'a' <= p[0] && p[0] <= 'z' {
|
||||
p = string(p[0]+'A'-'a') + p[1:]
|
||||
}
|
||||
|
||||
return p
|
||||
}
|
||||
|
||||
// clean the path and ensure that a drive letter is upper case (if it exists).
|
||||
func cleanPath(path string) string {
|
||||
return driveLetterToUpper(filepath.Clean(path))
|
||||
}
|
||||
|
||||
// deal with case insensitive filesystems and other weirdness
|
||||
func pathEqual(a, b string) bool {
|
||||
a = cleanPath(a)
|
||||
b = cleanPath(b)
|
||||
return strings.EqualFold(a, b)
|
||||
}
|
||||
|
|
@ -1,293 +0,0 @@
|
|||
package main
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"errors"
|
||||
"fmt"
|
||||
"os"
|
||||
"os/exec"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
|
||||
"golang.org/x/tools/go/vcs"
|
||||
)
|
||||
|
||||
// VCS represents a version control system.
|
||||
type VCS struct {
|
||||
vcs *vcs.Cmd
|
||||
|
||||
IdentifyCmd string
|
||||
DescribeCmd string
|
||||
DiffCmd string
|
||||
ListCmd string
|
||||
RootCmd string
|
||||
|
||||
// run in sandbox repos
|
||||
ExistsCmd string
|
||||
}
|
||||
|
||||
var vcsBzr = &VCS{
|
||||
vcs: vcs.ByCmd("bzr"),
|
||||
|
||||
IdentifyCmd: "version-info --custom --template {revision_id}",
|
||||
DescribeCmd: "revno", // TODO(kr): find tag names if possible
|
||||
DiffCmd: "diff -r {rev}",
|
||||
ListCmd: "ls --from-root -R",
|
||||
RootCmd: "root",
|
||||
}
|
||||
|
||||
var vcsGit = &VCS{
|
||||
vcs: vcs.ByCmd("git"),
|
||||
|
||||
IdentifyCmd: "rev-parse HEAD",
|
||||
DescribeCmd: "describe --tags --abbrev=14",
|
||||
DiffCmd: "diff {rev}",
|
||||
ListCmd: "ls-files --full-name",
|
||||
RootCmd: "rev-parse --show-cdup",
|
||||
|
||||
ExistsCmd: "cat-file -e {rev}",
|
||||
}
|
||||
|
||||
var vcsHg = &VCS{
|
||||
vcs: vcs.ByCmd("hg"),
|
||||
|
||||
IdentifyCmd: "parents --template {node}",
|
||||
DescribeCmd: "log -r . --template {latesttag}-{latesttagdistance}",
|
||||
DiffCmd: "diff -r {rev}",
|
||||
ListCmd: "status --all --no-status",
|
||||
RootCmd: "root",
|
||||
|
||||
ExistsCmd: "cat -r {rev} .",
|
||||
}
|
||||
|
||||
var cmd = map[*vcs.Cmd]*VCS{
|
||||
vcsBzr.vcs: vcsBzr,
|
||||
vcsGit.vcs: vcsGit,
|
||||
vcsHg.vcs: vcsHg,
|
||||
}
|
||||
|
||||
// VCSFromDir returns a VCS value from a directory.
|
||||
func VCSFromDir(dir, srcRoot string) (*VCS, string, error) {
|
||||
vcscmd, reporoot, err := vcs.FromDir(dir, srcRoot)
|
||||
if err != nil {
|
||||
return nil, "", fmt.Errorf("error while inspecting %q: %v", dir, err)
|
||||
}
|
||||
vcsext := cmd[vcscmd]
|
||||
if vcsext == nil {
|
||||
return nil, "", fmt.Errorf("%s is unsupported: %s", vcscmd.Name, dir)
|
||||
}
|
||||
return vcsext, reporoot, nil
|
||||
}
|
||||
|
||||
func (v *VCS) identify(dir string) (string, error) {
|
||||
out, err := v.runOutput(dir, v.IdentifyCmd)
|
||||
return string(bytes.TrimSpace(out)), err
|
||||
}
|
||||
|
||||
func absRoot(dir, out string) string {
|
||||
if filepath.IsAbs(out) {
|
||||
return filepath.Clean(out)
|
||||
}
|
||||
return filepath.Join(dir, out)
|
||||
}
|
||||
|
||||
func (v *VCS) root(dir string) (string, error) {
|
||||
out, err := v.runOutput(dir, v.RootCmd)
|
||||
return absRoot(dir, string(bytes.TrimSpace(out))), err
|
||||
}
|
||||
|
||||
func (v *VCS) describe(dir, rev string) string {
|
||||
out, err := v.runOutputVerboseOnly(dir, v.DescribeCmd, "rev", rev)
|
||||
if err != nil {
|
||||
return ""
|
||||
}
|
||||
return string(bytes.TrimSpace(out))
|
||||
}
|
||||
|
||||
func (v *VCS) isDirty(dir, rev string) bool {
|
||||
out, err := v.runOutput(dir, v.DiffCmd, "rev", rev)
|
||||
return err != nil || len(out) != 0
|
||||
}
|
||||
|
||||
type vcsFiles map[string]bool
|
||||
|
||||
func (vf vcsFiles) Contains(path string) bool {
|
||||
// Fast path, we have the path
|
||||
if vf[path] {
|
||||
return true
|
||||
}
|
||||
|
||||
// Slow path for case insensitive filesystems
|
||||
// See #310
|
||||
for f := range vf {
|
||||
if pathEqual(f, path) {
|
||||
return true
|
||||
}
|
||||
// git's root command (maybe other vcs as well) resolve symlinks, so try that too
|
||||
// FIXME: rev-parse --show-cdup + extra logic will fix this for git but also need to validate the other vcs commands. This is maybe temporary.
|
||||
p, err := filepath.EvalSymlinks(path)
|
||||
if err != nil {
|
||||
return false
|
||||
}
|
||||
if pathEqual(f, p) {
|
||||
return true
|
||||
}
|
||||
}
|
||||
|
||||
// No matches by either method
|
||||
return false
|
||||
}
|
||||
|
||||
// listFiles tracked by the VCS in the repo that contains dir, converted to absolute path.
|
||||
func (v *VCS) listFiles(dir string) vcsFiles {
|
||||
root, err := v.root(dir)
|
||||
debugln("vcs dir", dir)
|
||||
debugln("vcs root", root)
|
||||
ppln(v)
|
||||
if err != nil {
|
||||
return nil
|
||||
}
|
||||
out, err := v.runOutput(dir, v.ListCmd)
|
||||
if err != nil {
|
||||
return nil
|
||||
}
|
||||
files := make(vcsFiles)
|
||||
for _, file := range bytes.Split(out, []byte{'\n'}) {
|
||||
if len(file) > 0 {
|
||||
path, err := filepath.Abs(filepath.Join(root, string(file)))
|
||||
if err != nil {
|
||||
panic(err) // this should not happen
|
||||
}
|
||||
|
||||
if pathEqual(filepath.Dir(path), dir) {
|
||||
files[path] = true
|
||||
}
|
||||
}
|
||||
}
|
||||
return files
|
||||
}
|
||||
|
||||
func (v *VCS) exists(dir, rev string) bool {
|
||||
err := v.runVerboseOnly(dir, v.ExistsCmd, "rev", rev)
|
||||
return err == nil
|
||||
}
|
||||
|
||||
// RevSync checks out the revision given by rev in dir.
|
||||
// The dir must exist and rev must be a valid revision.
|
||||
func (v *VCS) RevSync(dir, rev string) error {
|
||||
return v.run(dir, v.vcs.TagSyncCmd, "tag", rev)
|
||||
}
|
||||
|
||||
// run runs the command line cmd in the given directory.
|
||||
// keyval is a list of key, value pairs. run expands
|
||||
// instances of {key} in cmd into value, but only after
|
||||
// splitting cmd into individual arguments.
|
||||
// If an error occurs, run prints the command line and the
|
||||
// command's combined stdout+stderr to standard error.
|
||||
// Otherwise run discards the command's output.
|
||||
func (v *VCS) run(dir string, cmdline string, kv ...string) error {
|
||||
_, err := v.run1(dir, cmdline, kv, true)
|
||||
return err
|
||||
}
|
||||
|
||||
// runVerboseOnly is like run but only generates error output to standard error in verbose mode.
|
||||
func (v *VCS) runVerboseOnly(dir string, cmdline string, kv ...string) error {
|
||||
_, err := v.run1(dir, cmdline, kv, false)
|
||||
return err
|
||||
}
|
||||
|
||||
// runOutput is like run but returns the output of the command.
|
||||
func (v *VCS) runOutput(dir string, cmdline string, kv ...string) ([]byte, error) {
|
||||
return v.run1(dir, cmdline, kv, true)
|
||||
}
|
||||
|
||||
// runOutputVerboseOnly is like runOutput but only generates error output to standard error in verbose mode.
|
||||
func (v *VCS) runOutputVerboseOnly(dir string, cmdline string, kv ...string) ([]byte, error) {
|
||||
return v.run1(dir, cmdline, kv, false)
|
||||
}
|
||||
|
||||
// run1 is the generalized implementation of run and runOutput.
|
||||
func (v *VCS) run1(dir string, cmdline string, kv []string, verbose bool) ([]byte, error) {
|
||||
m := make(map[string]string)
|
||||
for i := 0; i < len(kv); i += 2 {
|
||||
m[kv[i]] = kv[i+1]
|
||||
}
|
||||
args := strings.Fields(cmdline)
|
||||
for i, arg := range args {
|
||||
args[i] = expand(m, arg)
|
||||
}
|
||||
|
||||
_, err := exec.LookPath(v.vcs.Cmd)
|
||||
if err != nil {
|
||||
fmt.Fprintf(os.Stderr, "godep: missing %s command.\n", v.vcs.Name)
|
||||
return nil, err
|
||||
}
|
||||
|
||||
cmd := exec.Command(v.vcs.Cmd, args...)
|
||||
cmd.Dir = dir
|
||||
var buf bytes.Buffer
|
||||
cmd.Stdout = &buf
|
||||
cmd.Stderr = &buf
|
||||
err = cmd.Run()
|
||||
out := buf.Bytes()
|
||||
if err != nil {
|
||||
if verbose {
|
||||
fmt.Fprintf(os.Stderr, "# cd %s; %s %s\n", dir, v.vcs.Cmd, strings.Join(args, " "))
|
||||
os.Stderr.Write(out)
|
||||
}
|
||||
return nil, err
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
func expand(m map[string]string, s string) string {
|
||||
for k, v := range m {
|
||||
s = strings.Replace(s, "{"+k+"}", v, -1)
|
||||
}
|
||||
return s
|
||||
}
|
||||
|
||||
func gitDetached(r string) (bool, error) {
|
||||
o, err := vcsGit.runOutput(r, "status")
|
||||
if err != nil {
|
||||
return false, errors.New("unable to determine git status " + err.Error())
|
||||
}
|
||||
return bytes.Contains(o, []byte("HEAD detached at")), nil
|
||||
}
|
||||
|
||||
func gitDefaultBranch(r string) (string, error) {
|
||||
o, err := vcsGit.runOutput(r, "remote show origin")
|
||||
if err != nil {
|
||||
return "", errors.New("Running git remote show origin errored with: " + err.Error())
|
||||
}
|
||||
return gitDetermineDefaultBranch(r, string(o))
|
||||
}
|
||||
|
||||
func gitDetermineDefaultBranch(r, o string) (string, error) {
|
||||
e := "Unable to determine HEAD branch: "
|
||||
hb := "HEAD branch:"
|
||||
lbcfgp := "Local branch configured for 'git pull':"
|
||||
s := strings.Index(o, hb)
|
||||
if s < 0 {
|
||||
b := strings.Index(o, lbcfgp)
|
||||
if b < 0 {
|
||||
return "", errors.New(e + "Remote HEAD is ambiguous. Before godep can pull new commits you will need to:" + `
|
||||
cd ` + r + `
|
||||
git checkout <a HEAD branch>
|
||||
Here is what was reported:
|
||||
` + o)
|
||||
}
|
||||
s = b + len(lbcfgp)
|
||||
} else {
|
||||
s += len(hb)
|
||||
}
|
||||
f := strings.Fields(o[s:])
|
||||
if len(f) < 3 {
|
||||
return "", errors.New(e + "git output too short")
|
||||
}
|
||||
return f[0], nil
|
||||
}
|
||||
|
||||
func gitCheckout(r, b string) error {
|
||||
return vcsGit.run(r, "checkout "+b)
|
||||
}
|
||||
|
|
@ -1,63 +0,0 @@
|
|||
package main
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"log"
|
||||
"runtime"
|
||||
"strconv"
|
||||
"strings"
|
||||
)
|
||||
|
||||
const version = "80-k8s-r1"
|
||||
|
||||
var cmdVersion = &Command{
|
||||
Name: "version",
|
||||
Short: "show version info",
|
||||
Long: `
|
||||
|
||||
Displays the version of godep as well as the target OS, architecture and go runtime version.
|
||||
`,
|
||||
Run: runVersion,
|
||||
}
|
||||
|
||||
func versionString() string {
|
||||
return fmt.Sprintf("godep v%s (%s/%s/%s)", version, runtime.GOOS, runtime.GOARCH, runtime.Version())
|
||||
}
|
||||
|
||||
func runVersion(cmd *Command, args []string) {
|
||||
fmt.Printf("%s\n", versionString())
|
||||
}
|
||||
|
||||
func GoVersionFields(c rune) bool {
|
||||
return c == 'g' || c == 'o' || c == '.'
|
||||
}
|
||||
|
||||
// isSameOrNewer go version (goA.B)
|
||||
// go1.6 >= go1.6 == true
|
||||
// go1.5 >= go1.6 == false
|
||||
func isSameOrNewer(base, check string) bool {
|
||||
if base == check {
|
||||
return true
|
||||
}
|
||||
if strings.HasPrefix(check, "devel-") {
|
||||
return true
|
||||
}
|
||||
bp := strings.FieldsFunc(base, GoVersionFields)
|
||||
cp := strings.FieldsFunc(check, GoVersionFields)
|
||||
if len(bp) < 2 || len(cp) < 2 {
|
||||
log.Fatalf("Error comparing %s to %s\n", base, check)
|
||||
}
|
||||
if bp[0] == cp[0] { // We only have go version 1 right now
|
||||
bm, err := strconv.Atoi(bp[1])
|
||||
// These errors are unlikely and there is nothing nice to do here anyway
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
cm, err := strconv.Atoi(cp[1])
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
return cm >= bm
|
||||
}
|
||||
return false
|
||||
}
|
||||
Loading…
Reference in New Issue