dependency

Documentation

Index

• Variables
• func IsSrcDir(fi os.FileInfo) bool
• func IterativeScan(path string) ([]string, []string, error)
• type DefaultMissingPackageHandler
  • func (d *DefaultMissingPackageHandler) InVendor(pkg string, addTest bool) error
  • func (d *DefaultMissingPackageHandler) NotFound(pkg string, addTest bool) (bool, error)
  • func (d *DefaultMissingPackageHandler) OnGopath(pkg string, addTest bool) (bool, error)
  • func (d *DefaultMissingPackageHandler) PkgPath(pkg string) string
• type DefaultVersionHandler
  • func (d *DefaultVersionHandler) Process(pkg string) error
  • func (d *DefaultVersionHandler) SetVersion(pkg string, testDep bool) error
• type MissingPackageHandler
• type PkgInfo
• type PkgLoc
• type Resolver
  • func NewResolver(basedir string) (*Resolver, error)
  • func (r *Resolver) FindPkg(name string) *PkgInfo
  • func (r *Resolver) Resolve(pkg, basepath string) ([]string, error)
  • func (r *Resolver) ResolveAll(deps []*cfg.Dependency, addTest bool) ([]string, error)
  • func (r *Resolver) ResolveLocal(deep bool) ([]string, []string, error)
  • func (r *Resolver) Stripv(str string) string
• type VersionHandler

Variables

var PackagesAddedToStdlib = map[string]struct{}{

	"context":            struct{}{},
	"net/http/httptrace": struct{}{},

	"math/bits": struct{}{},

	"crypto/ed25519": struct{}{},
}

PackagesAddedToStdlib is the list of packages added to the go standard lib at various points.

Functions

func IsSrcDir

func IsSrcDir(fi os.FileInfo) bool

IsSrcDir returns true if this is a directory that could have source code, false otherwise.

Directories with _ or . prefixes are skipped, as are testdata and vendor.

func IterativeScan

func IterativeScan(path string) ([]string, []string, error)

IterativeScan attempts to obtain a list of imported dependencies from a package. This scanning is different from ImportDir as part of the go/build package. It looks over different permutations of the supported OS/Arch to try and find all imports. This is different from setting UseAllFiles to true on the build Context. It scopes down to just the supported OS/Arch.

Note, there are cases where multiple packages are in the same directory. This usually happens with an example that has a main package and a +build tag of ignore. This is a bit of a hack. It causes UseAllFiles to have errors.

Types

type DefaultMissingPackageHandler

type DefaultMissingPackageHandler struct {
	Missing []string
	Gopath  []string
	Prefix  string
}

DefaultMissingPackageHandler is the default handler for missing packages.

When asked to handle a missing package, it will report the miss as a warning, and then store the package in the Missing slice for later access.

func (*DefaultMissingPackageHandler) InVendor

func (d *DefaultMissingPackageHandler) InVendor(pkg string, addTest bool) error

InVendor is run when a package is found in the vendor/ folder

func (*DefaultMissingPackageHandler) NotFound

func (d *DefaultMissingPackageHandler) NotFound(pkg string, addTest bool) (bool, error)

NotFound prints a warning and then stores the package name in Missing.

It never returns an error, and it always returns false.

func (*DefaultMissingPackageHandler) OnGopath

func (d *DefaultMissingPackageHandler) OnGopath(pkg string, addTest bool) (bool, error)

OnGopath is run when a package is missing from vendor/ but found in the GOPATH

func (*DefaultMissingPackageHandler) PkgPath

func (d *DefaultMissingPackageHandler) PkgPath(pkg string) string

PkgPath returns the path to the package

type DefaultVersionHandler

type DefaultVersionHandler struct{}

DefaultVersionHandler is the default handler for setting the version.

The default handler leaves the current version and skips setting a version. For a handler that alters the version see the handler included in the repo package as part of the installer.

func (*DefaultVersionHandler) Process

func (d *DefaultVersionHandler) Process(pkg string) error

Process a package to aide in version setting.

func (*DefaultVersionHandler) SetVersion

func (d *DefaultVersionHandler) SetVersion(pkg string, testDep bool) error

SetVersion here sends a message when a package is found noting that it did not set the version.

type MissingPackageHandler

type MissingPackageHandler interface {
	// NotFound is called when the Resolver fails to find a package with the given name.
	//
	// NotFound returns true when the resolver should attempt to re-resole the
	// dependency (e.g. when NotFound has gone and fetched the missing package).
	//
	// When NotFound returns false, the Resolver does not try to do any additional
	// work on the missing package.
	//
	// NotFound only returns errors when it fails to perform its internal goals.
	// When it returns false with no error, this indicates that the handler did
	// its job, but the resolver should not do any additional work on the
	// package.
	NotFound(pkg string, addTest bool) (bool, error)

	// OnGopath is called when the Resolver finds a dependency, but it's only on GOPATH.
	//
	// OnGopath provides an opportunity to copy, move, warn, or ignore cases like this.
	//
	// OnGopath returns true when the resolver should attempt to re-resolve the
	// dependency (e.g. when the dependency is copied to a new location).
	//
	// When OnGopath returns false, the Resolver does not try to do any additional
	// work on the package.
	//
	// An error indicates that OnGopath cannot complete its intended operation.
	// Not all false results are errors.
	OnGopath(pkg string, addTest bool) (bool, error)

	// InVendor is called when the Resolver finds a dependency in the vendor/ directory.
	//
	// This can be used update a project found in the vendor/ folder.
	InVendor(pkg string, addTest bool) error

	// PkgPath is called to find the location locally to scan. This gives the
	// handler to do things such as use a cached location.
	PkgPath(pkg string) string
}

MissingPackageHandler handles the case where a package is missing during scanning.

It returns true if the package can be passed to the resolver, false otherwise. False may be returned even if error is nil.

type PkgInfo

type PkgInfo struct {
	Name, Path string
	Vendored   bool
	Loc        PkgLoc
}

PkgInfo represents metadata about a package found by the resolver.

type PkgLoc

type PkgLoc uint8

PkgLoc describes the location of the package.

const (
	// LocUnknown indicates the package location is unknown (probably not present)
	LocUnknown PkgLoc = iota
	// LocLocal inidcates that the package is in a local dir, not GOPATH or GOROOT.
	LocLocal
	// LocVendor indicates that the package is in a vendor/ dir
	LocVendor
	// LocGopath inidcates that the package is in GOPATH
	LocGopath
	// LocGoroot indicates that the package is in GOROOT
	LocGoroot
	// LocCgo indicates that the package is a a CGO package
	LocCgo
	// LocAppengine indicates the package is part of the appengine SDK. It's a
	// special build mode. https://blog.golang.org/the-app-engine-sdk-and-workspaces-gopath
	// Why does a Google product get a special case build mode with a local
	// package?
	LocAppengine
	// LocRelative indicates the package is a relative directory
	LocRelative
)

type Resolver

type Resolver struct {
	Handler        MissingPackageHandler
	VersionHandler VersionHandler
	VendorDir      string
	BuildContext   *util.BuildCtxt
	Config         *cfg.Config

	// ResolveAllFiles toggles deep scanning.
	// If this is true, resolve by scanning all files, not by walking the
	// import tree.
	ResolveAllFiles bool

	// ResolveTest sets if test dependencies should be resolved.
	ResolveTest bool
	// contains filtered or unexported fields
}

Resolver resolves a dependency tree.

It operates in two modes:

• local resolution (ResolveLocal) determines the dependencies of the local project.
• vendor resolving (Resolve, ResolveAll) determines the dependencies of vendored projects.

Local resolution is for guessing initial dependencies. Vendor resolution is for determining vendored dependencies.

func NewResolver

func NewResolver(basedir string) (*Resolver, error)

NewResolver returns a new Resolver initialized with the DefaultMissingPackageHandler.

This will return an error if the given path does not meet the basic criteria for a Go source project. For example, basedir must have a vendor subdirectory.

The BuildContext uses the "go/build".Default to resolve dependencies.

func (*Resolver) FindPkg

func (r *Resolver) FindPkg(name string) *PkgInfo

FindPkg takes a package name and attempts to find it on the filesystem

The resulting PkgInfo will indicate where it was found.

func (*Resolver) Resolve

func (r *Resolver) Resolve(pkg, basepath string) ([]string, error)

Resolve takes a package name and returns all of the imported package names.

If a package is not found, this calls the Fetcher. If the Fetcher returns true, it will re-try traversing that package for dependencies. Otherwise it will add that package to the deps array and continue on without trying it. And if the Fetcher returns an error, this will stop resolution and return the error.

If basepath is set to $GOPATH, this will start from that package's root there. If basepath is set to a project's vendor path, the scanning will begin from there.

func (*Resolver) ResolveAll

func (r *Resolver) ResolveAll(deps []*cfg.Dependency, addTest bool) ([]string, error)

ResolveAll takes a list of packages and returns an inclusive list of all vendored dependencies.

While this will scan all of the source code it can find, it will only return packages that were either explicitly passed in as deps, or were explicitly imported by the code.

Packages that are either CGO or on GOROOT are ignored. Packages that are on GOPATH, but not vendored currently generate a warning.

If one of the passed in packages does not exist in the vendor directory, an error is returned.

func (*Resolver) ResolveLocal

func (r *Resolver) ResolveLocal(deep bool) ([]string, []string, error)

ResolveLocal resolves dependencies for the current project.

This begins with the project, builds up a list of external dependencies.

If the deep flag is set to true, this will then resolve all of the dependencies of the dependencies it has found. If not, it will return just the packages that the base project relies upon.

func (*Resolver) Stripv

func (r *Resolver) Stripv(str string) string

Stripv strips the vendor/ prefix from vendored packages.

type VersionHandler

type VersionHandler interface {

	// Process provides an opportunity to process the codebase for version setting.
	Process(pkg string) error

	// SetVersion sets the version for a package. An error is returned if there
	// was a problem setting the version.
	SetVersion(pkg string, testDep bool) error
}

VersionHandler sets the version for a package when found while scanning.

When a package if found it needs to be on the correct version before scanning its contents to be sure to pick up the right elements for that version.