niki/vendor/github.com/KyleBanks/depth/depth.go

130 lines
3.3 KiB
Go
Raw Permalink Normal View History

2024-05-14 13:07:09 +00:00
// Package depth provides the ability to traverse and retrieve Go source code dependencies in the form of
// internal and external packages.
//
// For example, the dependencies of the stdlib `strings` package can be resolved like so:
//
2024-06-14 08:41:36 +00:00
// import "github.com/KyleBanks/depth"
2024-05-14 13:07:09 +00:00
//
// var t depth.Tree
2024-06-14 08:41:36 +00:00
// err := t.Resolve("strings")
// if err != nil {
// log.Fatal(err)
// }
2024-05-14 13:07:09 +00:00
//
2024-06-14 08:41:36 +00:00
// // Output: "strings has 4 dependencies."
// log.Printf("%v has %v dependencies.", t.Root.Name, len(t.Root.Deps))
2024-05-14 13:07:09 +00:00
//
// For additional customization, simply set the appropriate flags on the `Tree` before resolving:
//
2024-06-14 08:41:36 +00:00
// import "github.com/KyleBanks/depth"
2024-05-14 13:07:09 +00:00
//
2024-06-14 08:41:36 +00:00
// t := depth.Tree {
// ResolveInternal: true,
// ResolveTest: true,
// MaxDepth: 10,
// }
// err := t.Resolve("strings")
2024-05-14 13:07:09 +00:00
package depth
import (
"errors"
"go/build"
"os"
)
// ErrRootPkgNotResolved is returned when the root Pkg of the Tree cannot be resolved,
// typically because it does not exist.
var ErrRootPkgNotResolved = errors.New("unable to resolve root package")
// Importer defines a type that can import a package and return its details.
type Importer interface {
Import(name, srcDir string, im build.ImportMode) (*build.Package, error)
}
// Tree represents the top level of a Pkg and the configuration used to
// initialize and represent its contents.
type Tree struct {
Root *Pkg
ResolveInternal bool
ResolveTest bool
MaxDepth int
Importer Importer
importCache map[string]struct{}
}
// Resolve recursively finds all dependencies for the root Pkg name provided,
// and the packages it depends on.
func (t *Tree) Resolve(name string) error {
pwd, err := os.Getwd()
if err != nil {
return err
}
t.Root = &Pkg{
Name: name,
Tree: t,
SrcDir: pwd,
Test: false,
}
// Reset the import cache each time to ensure a reused Tree doesn't
// reuse the same cache.
t.importCache = nil
// Allow custom importers, but use build.Default if none is provided.
if t.Importer == nil {
t.Importer = &build.Default
}
t.Root.Resolve(t.Importer)
if !t.Root.Resolved {
return ErrRootPkgNotResolved
}
return nil
}
// shouldResolveInternal determines if internal packages should be further resolved beyond the
// current parent.
//
// For example, if the parent Pkg is `github.com/foo/bar` and true is returned, all the
// internal dependencies it relies on will be resolved. If for example `strings` is one of those
// dependencies, and it is passed as the parent here, false may be returned and its internal
// dependencies will not be resolved.
func (t *Tree) shouldResolveInternal(parent *Pkg) bool {
if t.ResolveInternal {
return true
}
return parent == t.Root
}
// isAtMaxDepth returns true when the depth of the Pkg provided is at or beyond the maximum
// depth allowed by the tree.
//
// If the Tree has a MaxDepth of zero, true is never returned.
func (t *Tree) isAtMaxDepth(p *Pkg) bool {
if t.MaxDepth == 0 {
return false
}
return p.depth() >= t.MaxDepth
}
// hasSeenImport returns true if the import name provided has already been seen within the tree.
// This function only returns false for a name once.
func (t *Tree) hasSeenImport(name string) bool {
if t.importCache == nil {
t.importCache = make(map[string]struct{})
}
if _, ok := t.importCache[name]; ok {
return true
}
t.importCache[name] = struct{}{}
return false
}