// 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 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 }