dep

package module
v0.0.0-...-0230f72 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Mar 1, 2019 License: BSD-3-Clause Imports: 20 Imported by: 0

README

Build Status Windows Build Status

Dep

dep is a prototype dependency management tool for Go. It requires Go 1.9 or newer to compile. dep is safe for production use.

dep is the official experiment, but not yet the official tool. Check out the Roadmap for more on what this means!

For guides and reference materials about dep, see the documentation.

Installation

It is strongly recommended that you use a released version. Release binaries are available on the releases page.

On MacOS you can install or upgrade to the latest released version with Homebrew:

$ brew install dep
$ brew upgrade dep

On other platforms you can use the install.sh script:

$ curl https://raw.githubusercontent.com/gwaylib/godep/master/install.sh | sh

It will install into your $GOPATH/bin directory by default or any other directory you specify using the INSTALL_DIRECTORY environment variable.

If your platform is not supported, you'll need to build it manually or let the team know and we'll consider adding your platform to the release builds.

If you're interested in hacking on dep, you can install via go get:

go get -u github.com/gwaylib/godep/cmd/dep

Feedback

Feedback is greatly appreciated. At this stage, the maintainers are most interested in feedback centered on the user experience (UX) of the tool. Do you have workflows that the tool supports well, or doesn't support at all? Do any of the commands have surprising effects, output, or results? Let us know by filing an issue, describing what you did or wanted to do, what you expected to happen, and what actually happened.

Contributing

Contributions are greatly appreciated. The maintainers actively manage the issues list, and try to highlight issues suitable for newcomers. The project follows the typical GitHub pull request model. See CONTRIBUTING.md for more details. Before starting any work, please either comment on an existing issue, or file a new one.

Documentation

Overview

Package dep is a prototype dependency management library.

Index

Constants

View Source 
const LockName = "Gopkg.lock"

LockName is the lock file name used by dep.

View Source 
const ManifestName = "Gopkg.toml"

ManifestName is the manifest file name used by dep.

Variables

This section is empty.

Functions

func BackupVendor 

func BackupVendor(vpath, suffix string) (string, error)

BackupVendor looks for existing vendor directory and if it's not empty, creates a backup of it to a new directory with the provided suffix.

func ValidateProjectRoots 

func ValidateProjectRoots(c *Ctx, m *Manifest, sm gps.SourceManager) error

ValidateProjectRoots validates the project roots present in manifest.

Types

type Analyzer 

type Analyzer struct{}

Analyzer implements gps.ProjectAnalyzer.

func (Analyzer) DeriveManifestAndLock 

func (a Analyzer) DeriveManifestAndLock(path string, n gps.ProjectRoot) (gps.Manifest, gps.Lock, error)

DeriveManifestAndLock reads and returns the manifest at path/ManifestName or nil if one is not found. The Lock is always nil for now.

func (Analyzer) HasDepMetadata 

func (a Analyzer) HasDepMetadata(path string) bool

HasDepMetadata determines if a dep manifest exists at the specified path.

func (Analyzer) Info 

func (a Analyzer) Info() gps.ProjectAnalyzerInfo

Info returns Analyzer's name and version info.

type Ctx 

type Ctx struct {
	WorkingDir     string        // Where to execute.
	GOPATH         string        // Selected Go path, containing WorkingDir.
	GOPATHs        []string      // Other Go paths.
	Out, Err       *log.Logger   // Required loggers.
	Verbose        bool          // Enables more verbose logging.
	DisableLocking bool          // When set, no lock file will be created to protect against simultaneous dep processes.
	Cachedir       string        // Cache directory loaded from environment.
	CacheAge       time.Duration // Maximum valid age of cached source data. <=0: Don't cache.
}

Ctx defines the supporting context of dep.

A properly initialized Ctx has a GOPATH containing the project root and non-nil Loggers. 

ctx := &dep.Ctx{
	WorkingDir: GOPATH + "/src/project/root",
	GOPATH: GOPATH,
	Out: log.New(os.Stdout, "", 0),
	Err: log.New(os.Stderr, "", 0),
}

Ctx.DetectProjectGOPATH() helps with setting the containing GOPATH. 

ctx.GOPATH, err := Ctx.DetectProjectGOPATH(project)
if err != nil {
	// Could not determine which GOPATH to use for the project.
}

func (*Ctx) AbsForImport 

func (c *Ctx) AbsForImport(path string) (string, error)

AbsForImport returns the absolute path for the project root including the $GOPATH. This will not work with stdlib packages and the package directory needs to exist.

func (*Ctx) DetectProjectGOPATH 

func (c *Ctx) DetectProjectGOPATH(p *Project) (string, error)

DetectProjectGOPATH attempt to find the GOPATH containing the project. 

If p.AbsRoot is not a symlink and is within a GOPATH, the GOPATH containing p.AbsRoot is returned.
If p.AbsRoot is a symlink and is not within any known GOPATH, the GOPATH containing p.ResolvedAbsRoot is returned.

p.AbsRoot is assumed to be a symlink if it is not the same as p.ResolvedAbsRoot.

DetectProjectGOPATH will return an error in the following cases: 

If p.AbsRoot is not a symlink and is not within any known GOPATH.
If neither p.AbsRoot nor p.ResolvedAbsRoot are within a known GOPATH.
If both p.AbsRoot and p.ResolvedAbsRoot are within the same GOPATH.
If p.AbsRoot and p.ResolvedAbsRoot are each within a different GOPATH.

func (*Ctx) ImportForAbs 

func (c *Ctx) ImportForAbs(path string) (string, error)

ImportForAbs returns the import path for an absolute project path by trimming the `$GOPATH/src/` prefix. Returns an error for paths equal to, or without this prefix.

func (*Ctx) LoadProject 

func (c *Ctx) LoadProject() (*Project, error)

LoadProject starts from the current working directory and searches up the directory tree for a project root. The search stops when a file with the name ManifestName (Gopkg.toml, by default) is located.

The Project contains the parsed manifest as well as a parsed lock file, if present. The import path is calculated as the remaining path segment below Ctx.GOPATH/src.

func (*Ctx) SetPaths 

func (c *Ctx) SetPaths(wd string, GOPATHs ...string) error

SetPaths sets the WorkingDir and GOPATHs fields. If GOPATHs is empty, then the GOPATH environment variable (or the default GOPATH) is used instead.

func (*Ctx) SourceManager 

func (c *Ctx) SourceManager() (*gps.SourceMgr, error)

SourceManager produces an instance of gps's built-in SourceManager initialized to log to the receiver's logger.

func (*Ctx) ValidateParams 

func (c *Ctx) ValidateParams(sm gps.SourceManager, params gps.SolveParameters) error

ValidateParams ensure that solving can be completed with the specified params.

type Lock 

type Lock struct {
	SolveMeta SolveMeta
	P         []gps.LockedProject
}

Lock holds lock file data and implements gps.Lock.

func LockFromSolution 

func LockFromSolution(in gps.Solution) *Lock

LockFromSolution converts a gps.Solution to dep's representation of a lock.

Data is defensively copied wherever necessary to ensure the resulting *lock shares no memory with the original lock.

func (*Lock) HasProjectWithRoot 

func (l *Lock) HasProjectWithRoot(root gps.ProjectRoot) bool

HasProjectWithRoot checks if the lock contains a project with the provided ProjectRoot.

This check is O(n) in the number of projects.

func (*Lock) InputsDigest 

func (l *Lock) InputsDigest() []byte

InputsDigest returns the hash of inputs which produced this lock data.

func (*Lock) MarshalTOML 

func (l *Lock) MarshalTOML() ([]byte, error)

MarshalTOML serializes this lock into TOML via an intermediate raw form.

func (*Lock) Projects 

func (l *Lock) Projects() []gps.LockedProject

Projects returns the list of LockedProjects contained in the lock data.

type Manifest 

type Manifest struct {
	Constraints gps.ProjectConstraints
	Ovr         gps.ProjectConstraints

	Ignored  []string
	Required []string

	PruneOptions gps.CascadingPruneOptions
}

Manifest holds manifest file data and implements gps.RootManifest.

func NewManifest 

func NewManifest() *Manifest

NewManifest instantites a new manifest.

func (*Manifest) DependencyConstraints 

func (m *Manifest) DependencyConstraints() gps.ProjectConstraints

DependencyConstraints returns a list of project-level constraints.

func (*Manifest) HasConstraintsOn 

func (m *Manifest) HasConstraintsOn(root gps.ProjectRoot) bool

HasConstraintsOn checks if the manifest contains either constraints or overrides on the provided ProjectRoot.

func (*Manifest) IgnoredPackages 

func (m *Manifest) IgnoredPackages() *pkgtree.IgnoredRuleset

IgnoredPackages returns a set of import paths to ignore.

func (*Manifest) MarshalTOML 

func (m *Manifest) MarshalTOML() ([]byte, error)

MarshalTOML serializes this manifest into TOML via an intermediate raw form.

func (*Manifest) Overrides 

func (m *Manifest) Overrides() gps.ProjectConstraints

Overrides returns a list of project-level override constraints.

func (*Manifest) RequiredPackages 

func (m *Manifest) RequiredPackages() map[string]bool

RequiredPackages returns a set of import paths to require.

type Project 

type Project struct {
	// AbsRoot is the absolute path to the root directory of the project.
	AbsRoot string
	// ResolvedAbsRoot is the resolved absolute path to the root directory of the project.
	// If AbsRoot is not a symlink, then ResolvedAbsRoot should equal AbsRoot.
	ResolvedAbsRoot string
	// ImportRoot is the import path of the project's root directory.
	ImportRoot      gps.ProjectRoot
	Manifest        *Manifest
	Lock            *Lock // Optional
	RootPackageTree pkgtree.PackageTree
}

A Project holds a Manifest and optional Lock for a project.

func (*Project) FindIneffectualConstraints 

func (p *Project) FindIneffectualConstraints(sm gps.SourceManager) []gps.ProjectRoot

FindIneffectualConstraints looks for constraint rules expressed in the manifest that will have no effect during solving, as they are specified for projects that are not direct dependencies of the Project.

"Direct dependency" here is as implemented by GetDirectDependencyNames(); it correctly incorporates all "ignored" and "required" rules.

func (*Project) GetDirectDependencyNames 

func (p *Project) GetDirectDependencyNames(sm gps.SourceManager) (pkgtree.PackageTree, map[gps.ProjectRoot]bool, error)

GetDirectDependencyNames returns the set of unique Project Roots that are the direct dependencies of this Project.

A project is considered a direct dependency if at least one of packages in it is named in either this Project's required list, or if there is at least one non-ignored import statement from a non-ignored package in the current project's package tree.

The returned map of Project Roots contains only boolean true values; this makes a "false" value always indicate an absent key, which makes conditional checks against the map more ergonomic.

This function will correctly utilize ignores and requireds from an existing manifest, if one is present, but will also do the right thing without a manifest.

func (*Project) MakeParams 

func (p *Project) MakeParams() gps.SolveParameters

MakeParams is a simple helper to create a gps.SolveParameters without setting any nils incorrectly.

func (*Project) ParseRootPackageTree 

func (p *Project) ParseRootPackageTree() (pkgtree.PackageTree, error)

ParseRootPackageTree analyzes the root project's disk contents to create a PackageTree, trimming out packages that are not relevant for root projects along the way.

The resulting tree is cached internally at p.RootPackageTree.

func (*Project) SetRoot 

func (p *Project) SetRoot(root string) error

SetRoot sets the project AbsRoot and ResolvedAbsRoot. If root is not a symlink, ResolvedAbsRoot will be set to root.

type SafeWriter 

type SafeWriter struct {
	Manifest *Manifest
	// contains filtered or unexported fields
}

SafeWriter transactionalizes writes of manifest, lock, and vendor dir, both individually and in any combination, into a pseudo-atomic action with transactional rollback.

It is not impervious to errors (writing to disk is hard), but it should guard against non-arcane failure conditions.

func NewSafeWriter 

func NewSafeWriter(manifest *Manifest, oldLock, newLock *Lock, vendor VendorBehavior, prune gps.CascadingPruneOptions) (*SafeWriter, error)

NewSafeWriter sets up a SafeWriter to write a set of manifest, lock, and vendor tree.

- If manifest is provided, it will be written to the standard manifest file name beneath root.

- If newLock is provided, it will be written to the standard lock file name beneath root.

- If vendor is VendorAlways, or is VendorOnChanged and the locks are different, the vendor directory will be written beneath root based on newLock.

- If oldLock is provided without newLock, error.

- If vendor is VendorAlways without a newLock, error.

func (*SafeWriter) HasLock 

func (sw *SafeWriter) HasLock() bool

HasLock checks if a Lock is present in the SafeWriter

func (*SafeWriter) HasManifest 

func (sw *SafeWriter) HasManifest() bool

HasManifest checks if a Manifest is present in the SafeWriter

func (*SafeWriter) PrintPreparedActions 

func (sw *SafeWriter) PrintPreparedActions(output *log.Logger, verbose bool) error

PrintPreparedActions logs the actions a call to Write would perform.

func (*SafeWriter) Write 

func (sw *SafeWriter) Write(root string, sm gps.SourceManager, examples bool, logger *log.Logger) error

Write saves some combination of config yaml, lock, and a vendor tree. root is the absolute path of root dir in which to write. sm is only required if vendor is being written.

It first writes to a temp dir, then moves them in place if and only if all the write operations succeeded. It also does its best to roll back if any moves fail. This mostly guarantees that dep cannot exit with a partial write that would leave an undefined state on disk.

If logger is not nil, progress will be logged after each project write.

type SolveMeta 

type SolveMeta struct {
	InputsDigest    []byte
	AnalyzerName    string
	AnalyzerVersion int
	SolverName      string
	SolverVersion   int
}

SolveMeta holds solver meta data.

type VendorBehavior 

type VendorBehavior int

VendorBehavior defines when the vendor directory should be written. 

const (
	// VendorOnChanged indicates that the vendor directory should be written when the lock is new or changed.
	VendorOnChanged VendorBehavior = iota
	// VendorAlways forces the vendor directory to always be written.
	VendorAlways
	// VendorNever indicates the vendor directory should never be written.
	VendorNever
)

Source Files

View all Source files

Directories

Path Synopsis
cmd
godep
Dep is a tool for managing dependencies for Go projects Usage: "dep [command]" Commands: init Initialize a new project with manifest and lock files status Report the status of the project's dependencies ensure Ensure a dependency is safely vendored in the project prune Prune the vendor tree of unused packages version Show the dep version information Examples: dep init set up a new project dep ensure install the project's dependencies dep ensure -update update the locked versions of all dependencies dep ensure -add github.com/pkg/errors add a dependency to the project Use "dep help [command]" for more information about a command.
 Dep is a tool for managing dependencies for Go projects Usage: "dep [command]" Commands: init Initialize a new project with manifest and lock files status Report the status of the project's dependencies ensure Ensure a dependency is safely vendored in the project prune Prune the vendor tree of unused packages version Show the dep version information Examples: dep init set up a new project dep ensure install the project's dependencies dep ensure -update update the locked versions of all dependencies dep ensure -add github.com/pkg/errors add a dependency to the project Use "dep help [command]" for more information about a command.
gps
Package gps is a Go packaging solver library.
 Package gps is a Go packaging solver library.
_testdata/cmd/echosleep
_testdata/cmd/stdout_stderr
_testdata/digest/github.com/alice/match
_testdata/digest/github.com/alice/mismatch
_testdata/digest/github.com/alice/notInLock
_testdata/digest/github.com/bob/emptyDigest
_testdata/digest/github.com/bob/match
_testdata/digest/launchpad.net/match
_testdata/src/buildtag
_testdata/src/canon_confl
_testdata/src/canonical
_testdata/src/canonical/sub
_testdata/src/cycle
_testdata/src/cycle/one
_testdata/src/cycle/two
_testdata/src/disallow
_testdata/src/dotgodir/foo.go
_testdata/src/doublenest
_testdata/src/doublenest/namemismatch
_testdata/src/doublenest/namemismatch/m1p
_testdata/src/github.com/example/varied
_testdata/src/github.com/example/varied/m1p
_testdata/src/github.com/example/varied/namemismatch
_testdata/src/github.com/example/varied/simple
_testdata/src/github.com/example/varied/simple/another
_testdata/src/igmain
_testdata/src/igmainfirst
_testdata/src/igmainlong
_testdata/src/igmaint
_testdata/src/m1p
_testdata/src/missing
_testdata/src/missing/m1p
_testdata/src/nest
_testdata/src/nest/m1p
_testdata/src/relimport
_testdata/src/relimport/dot
_testdata/src/relimport/dotdot
_testdata/src/relimport/dotdotslash
_testdata/src/relimport/dotslash
_testdata/src/ren/m1p
_testdata/src/ren/simple
_testdata/src/simple
_testdata/src/simpleallt
_testdata/src/simplet
_testdata/src/simplext
_testdata/src/skip_
_testdata/src/varied
_testdata/src/varied/m1p
_testdata/src/varied/namemismatch
_testdata/src/varied/simple
_testdata/src/varied/simple/another
_testdata/src/varied_hidden
_testdata/src/varied_hidden/_frommain
_testdata/src/varied_hidden/_never
_testdata/src/varied_hidden/_secondorder
_testdata/src/varied_hidden/dotdotslash
_testdata/src/varied_hidden/simple
internal/pb
Package pb provides generated Protocol Buffers for cache serialization.
 Package pb provides generated Protocol Buffers for cache serialization.
paths
pkgtree
hack
licenseok
Checks if all files have the license header, a lot of this is based off https://github.com/google/addlicense.
 Checks if all files have the license header, a lot of this is based off https://github.com/google/addlicense.
internal
feedback
fs
importers
importers/base
importers/glide
importers/glock
importers/godep
importers/govend
importers/govendor
importers/gvt
importers/importertest
importers/vndr
test
test/integration

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.