// getDepList gets list of dependencies in root path format and nature order.
func getDepList(ctx *cli.Context, target, pkgPath, vendor string) ([]string, error) {
vendorSrc := path.Join(vendor, "src")
rootPath := doc.GetRootPath(target)
// If work directory is not in GOPATH, then need to setup a vendor path.
if !setting.HasGOPATHSetting || !strings.HasPrefix(pkgPath, setting.InstallGopath) {
// Make link of self.
log.Debug("Linking %s...", rootPath)
from := pkgPath
to := path.Join(vendorSrc, rootPath)
if setting.Debug {
log.Debug("Linking from %s to %s", from, to)
}
if err := autoLink(from, to); err != nil {
return nil, err
}
}
imports, err := doc.ListImports(target, rootPath, vendor, pkgPath, ctx.String("tags"), ctx.Bool("test"))
if err != nil {
return nil, err
}
list := make([]string, 0, len(imports))
for _, name := range imports {
name = doc.GetRootPath(name)
if !base.IsSliceContainsStr(list, name) {
list = append(list, name)
}
}
sort.Strings(list)
return list, nil
}
func getByGopmfile(ctx *cli.Context) error {
// Make sure gopmfile exists and up-to-date.
gf, target, err := parseGopmfile(setting.GOPMFILE)
if err != nil {
return err
}
imports, err := getDepList(ctx, target, setting.WorkDir, setting.DefaultVendor)
if err != nil {
return err
}
// Check if dependency has version.
nodes := make([]*doc.Node, 0, len(imports))
for _, name := range imports {
name = doc.GetRootPath(name)
n := doc.NewNode(name, doc.BRANCH, "", !ctx.Bool("download"))
// Check if user specified the version.
if v := gf.MustValue("deps", name); len(v) > 0 {
n.Type, n.Value, err = validPkgInfo(v)
n = doc.NewNode(name, n.Type, n.Value, !ctx.Bool("download"))
}
nodes = append(nodes, n)
}
return getPackages(target, ctx, nodes)
}
func linkVendors(ctx *cli.Context, optTarget string) error {
gfPath := path.Join(setting.WorkDir, setting.GOPMFILE)
gf, target, err := parseGopmfile(gfPath)
if err != nil {
return fmt.Errorf("fail to parse gopmfile: %v", err)
}
if len(optTarget) > 0 {
target = optTarget
}
rootPath := doc.GetRootPath(target)
// TODO: local support.
// Make link of self.
log.Debug("Linking %s...", rootPath)
from := setting.WorkDir
to := path.Join(setting.DefaultVendorSrc, rootPath)
if setting.Debug {
log.Debug("Linking from %s to %s", from, to)
}
if err := autoLink(from, to); err != nil {
return fmt.Errorf("fail to link self: %v", err)
}
// Check and loads dependency packages.
log.Debug("Loading dependencies...")
imports, err := doc.ListImports(target, rootPath, setting.DefaultVendor, setting.WorkDir, ctx.String("tags"), ctx.Bool("test"))
if err != nil {
return fmt.Errorf("fail to list imports: %v", err)
}
stack := make([]*doc.Pkg, len(imports))
for i, name := range imports {
name := doc.GetRootPath(name)
tp, val, err := validPkgInfo(gf.MustValue("deps", name))
if err != nil {
return fmt.Errorf("fail to validate package(%s): %v", name, err)
}
stack[i] = doc.NewPkg(name, tp, val)
}
// FIXME: at least link once, need a set
lastIdx := len(stack) - 1
for lastIdx >= 0 {
pkg := stack[lastIdx]
linkPath := path.Join(setting.DefaultVendorSrc, pkg.RootPath)
if setting.Debug {
log.Debug("Import path: %s", pkg.ImportPath)
log.Debug("Linking path: %s", linkPath)
}
if base.IsExist(linkPath) {
stack = stack[:lastIdx]
lastIdx = len(stack) - 1
continue
}
if pkg.IsEmptyVal() && setting.HasGOPATHSetting &&
base.IsExist(path.Join(setting.InstallGopath, pkg.RootPath)) {
stack = stack[:lastIdx]
lastIdx = len(stack) - 1
continue
}
venderPath := path.Join(setting.InstallRepoPath, pkg.RootPath+pkg.ValSuffix())
if !base.IsExist(venderPath) {
return fmt.Errorf("package not installed: %s", pkg.RootPath+pkg.VerSuffix())
}
log.Debug("Linking %s...", pkg.RootPath+pkg.ValSuffix())
if err := autoLink(venderPath, linkPath); err != nil {
return fmt.Errorf("fail to link dependency(%s): %v", pkg.RootPath, err)
}
stack = stack[:lastIdx]
gf, target, err := parseGopmfile(path.Join(linkPath, setting.GOPMFILE))
if err != nil {
return fmt.Errorf("fail to parse gopmfile(%s): %v", linkPath, err)
}
// parseGopmfile only returns right target when parse work directory.
target = pkg.RootPath
rootPath := target
imports, err := doc.ListImports(target, rootPath, setting.DefaultVendor, linkPath, ctx.String("tags"), ctx.Bool("test"))
if err != nil {
errors.SetError(err)
}
for _, name := range imports {
if name == "C" {
continue
}
name := doc.GetRootPath(name)
tp, val, err := validPkgInfo(gf.MustValue("deps", name))
if err != nil {
return fmt.Errorf("fail to validate package(%s): %v", name, err)
}
stack = append(stack, doc.NewPkg(name, tp, val))
}
lastIdx = len(stack) - 1
}
return nil
}