Finish command gen

.gopmfile

@@ -2,10 +2,10 @@
 path = github.com/gpmgo/gopm
 
 [deps]
-github.com/codegangsta/cli = 
 github.com/Unknwon/com = 
 github.com/Unknwon/goconfig = 
 github.com/aybabtme/color = 
+github.com/codegangsta/cli = 
 github.com/Unknwon/cae = 
 
 [res]

cmd/bin.go

@@ -139,7 +139,7 @@ func runBin(ctx *cli.Context) {
 		return
 	}
 
-	gf, target, _, err := genGopmfile()
+	gf, target, _, err := genGopmfile(ctx)
 	if err != nil {
 		errors.SetError(err)
 		return

cmd/cmd.go

@@ -71,7 +71,7 @@ func setup(ctx *cli.Context) (err error) {
 
 	if !ctx.Bool("remote") {
 		if ctx.Bool("local") {
-			gf, _, _, err := genGopmfile()
+			gf, _, _, err := genGopmfile(ctx)
 			if err != nil {
 				return err
 			}
@@ -275,8 +275,7 @@ func getDepPkgs(
 		if _, ok := depPkgs[pkg.RootPath]; !ok {
 			var newPath string
 			if !build.IsLocalImport(name) && pkg.Type != doc.LOCAL {
-				pkgPath := strings.Replace(
-					pkg.ImportPath, pkg.RootPath, pkg.RootPath+pkg.ValSuffix(), 1)
+				pkgPath := pkg.RootPath + pkg.ValSuffix()
 				newPath = path.Join(setting.InstallRepoPath, pkgPath)
 				if len(pkg.ValSuffix()) == 0 && !ctx.Bool("remote") &&
 					com.IsDir(path.Join(setting.InstallGopath, pkgPath)) {
@@ -287,6 +286,7 @@ func getDepPkgs(
 				} else {
 					if !com.IsExist(newPath) || ctx.Bool("update") {
 						node := doc.NewNode(pkg.ImportPath, pkg.Type, pkg.Value, true)
+						node.IsGetDeps = false
 						if err = downloadPackages(target, ctx, []*doc.Node{node}); err != nil {
 							return err
 						}
@@ -303,7 +303,18 @@ func getDepPkgs(
 				}
 			}
 			depPkgs[pkg.RootPath] = pkg
-			if err = getDepPkgs(gf, ctx, pkg.ImportPath, newPath, depPkgs, false); err != nil {
+
+			curPath = path.Join(doc.VENDOR, "src", pkg.RootPath)
+			log.Log("Linking %s", pkg.RootPath+pkg.ValSuffix())
+			if err := autoLink(newPath, curPath); err != nil {
+				if setting.LibraryMode {
+					return fmt.Errorf("Fail to make link dependency: %v", err)
+				}
+				log.Error("", "Fail to make link dependency:")
+				log.Fatal("", "\t"+err.Error())
+			}
+
+			if err = getDepPkgs(gf, ctx, pkg.ImportPath, curPath, depPkgs, false); err != nil {
 				return err
 			}
 		}
@@ -319,84 +330,32 @@ func autoLink(oldPath, newPath string) error {
 func genNewGopath(ctx *cli.Context, isTest bool) (string, string, string, error) {
 	log.Trace("Work directory: %s", setting.WorkDir)
 
-	gf, target, _, err := genGopmfile()
+	gf, err := loadGopmfile(setting.GOPMFILE)
 	if err != nil {
 		return "", "", "", err
 	}
+
+	// Check dependencies.
+	target := doc.ParseTarget(gf.MustValue("target", "path"))
 	if target == "." {
 		_, target = filepath.Split(setting.WorkDir)
 	}
 
-	// Check and loads dependency pakcages.
-	depPkgs := make(map[string]*doc.Pkg)
-	if err := getDepPkgs(gf, ctx, target, setting.WorkDir, depPkgs, isTest); err != nil {
-		if setting.LibraryMode {
-			return "", "", "", fmt.Errorf("Fail to get dependency pakcages: %v", err)
-		}
-		log.Error("", "Fail to get dependency pakcages:")
-		log.Fatal("", "\t"+err.Error())
-	}
-
 	// Clean old files.
 	newGopath := path.Join(setting.WorkDir, doc.VENDOR)
 	newGopathSrc := path.Join(newGopath, "src")
 	os.RemoveAll(newGopathSrc)
 	os.MkdirAll(newGopathSrc, os.ModePerm)
 
-	for name, pkg := range depPkgs {
-		var oldPath string
-		if pkg.Type == doc.LOCAL {
-			oldPath, _ = filepath.Abs(pkg.Value)
-		} else {
-			oldPath = path.Join(setting.InstallRepoPath, name) + pkg.ValSuffix()
-		}
-
-		newPath := path.Join(newGopathSrc, name)
-		paths := strings.Split(name, "/")
-		var isExist, isCurChild bool
-		if name == target {
-			continue
-		}
-
-		for i := 0; i < len(paths)-1; i++ {
-			pName := strings.Join(paths[:len(paths)-1-i], "/")
-			if _, ok := depPkgs[pName]; ok {
-				isExist = true
-				break
-			}
-			if target == pName {
-				isCurChild = true
-				break
-			}
-		}
-		if isCurChild {
-			continue
-		}
-
-		if !isExist && (!pkg.IsEmptyVal() || ctx.Bool("remote") ||
-			!com.IsDir(path.Join(setting.InstallGopath, pkg.ImportPath))) {
-
-			log.Log("Linking %s", name+pkg.ValSuffix())
-			if err := autoLink(oldPath, newPath); err != nil {
-				if setting.LibraryMode {
-					return "", "", "", fmt.Errorf("Fail to make link dependency: %v", err)
-				}
-				log.Error("", "Fail to make link dependency:")
-				log.Fatal("", "\t"+err.Error())
-			}
-		}
-	}
-
+	// Link self.
 	targetRoot := doc.GetRootPath(target)
-	newCurPath := path.Join(newGopathSrc, target)
 	log.Log("Linking %s", targetRoot)
 	if setting.Debug {
 		fmt.Println(target)
 		fmt.Println(path.Join(strings.TrimSuffix(setting.WorkDir, target), targetRoot))
 		fmt.Println(path.Join(newGopathSrc, targetRoot))
 	}
-	if err := autoLink(path.Join(
-		strings.TrimSuffix(setting.WorkDir, target), targetRoot),
+	if err := autoLink(path.Join(strings.TrimSuffix(setting.WorkDir, target), targetRoot),
 		path.Join(newGopathSrc, targetRoot)); err != nil &&
 		!strings.Contains(err.Error(), "file exists") {
 		if setting.LibraryMode {
@@ -405,6 +364,18 @@ func genNewGopath(ctx *cli.Context, isTest bool) (string, string, string, error)
 		log.Error("", "Fail to make link self:")
 		log.Fatal("", "\t"+err.Error())
 	}
+
+	// Check and loads dependency pakcages.
+	depPkgs := make(map[string]*doc.Pkg)
+	if err := getDepPkgs(gf, ctx, target, setting.WorkDir, depPkgs, isTest); err != nil {
+		if setting.LibraryMode {
+			return "", "", "", fmt.Errorf("Fail to get dependency pakcages: %v", err)
+		}
+		log.Error("", "Fail to get dependency pakcages:")
+		log.Fatal("", "\t"+err.Error())
+	}
+
+	newCurPath := path.Join(newGopathSrc, target)
 	return target, newGopath, newCurPath, nil
 }
 

cmd/gen.go

@@ -17,7 +17,6 @@ package cmd
 import (
 	"os"
 	"path"
-	"path/filepath"
 	"sort"
 	"strings"
 
@@ -52,7 +51,7 @@ func runGen(ctx *cli.Context) {
 		return
 	}
 
-	gf, _, _, err := genGopmfile()
+	gf, _, _, err := genGopmfile(ctx)
 	if err != nil {
 		errors.SetError(err)
 		return
@@ -78,39 +77,26 @@ func runGen(ctx *cli.Context) {
 
 // genGopmfile generates gopmfile and returns it,
 // along with target and dependencies.
-func genGopmfile() (*goconfig.ConfigFile, string, []string, error) {
+func genGopmfile(ctx *cli.Context) (*goconfig.ConfigFile, string, []string, error) {
 	if !com.IsExist(setting.GOPMFILE) {
 		os.Create(setting.GOPMFILE)
 	}
+
+	if com.IsSliceContainsStr([]string{"gen", "list"}, ctx.Command.Name) {
+		os.RemoveAll(doc.VENDOR)
+		if !setting.Debug {
+			defer os.RemoveAll(doc.VENDOR)
+		}
+	}
 	gf, err := loadGopmfile(setting.GOPMFILE)
 	if err != nil {
 		return nil, "", nil, err
 	}
-
-	// Check dependencies.
-	target := doc.ParseTarget(gf.MustValue("target", "path"))
-	rootPath := doc.GetRootPath(target)
-
-	oldGopath := os.Getenv("GOPATH")
-	if len(oldGopath) == 0 || !com.IsExist(path.Join(oldGopath, "src", rootPath)) {
-		tmpPath := path.Join(setting.InstallRepoPath, rootPath)
-		os.RemoveAll(tmpPath)
-		os.MkdirAll(path.Dir(tmpPath), os.ModePerm)
-
-		relPath, err := filepath.Rel(target, rootPath)
-		if err != nil {
-			log.Error("", "Fail to get relative path of target")
-			log.Fatal("", "\t"+err.Error())
-		}
-		absPath, _ := filepath.Abs(relPath)
-		if setting.IsWindows {
-			com.CopyDir(absPath, tmpPath, func(filePath string) bool {
-				return !strings.Contains(filePath, ".git")
-			})
-		} else {
-			os.Symlink(absPath, tmpPath)
-		}
+	target, _, _, err := genNewGopath(ctx, false)
+	if err != nil {
+		return nil, "", nil, err
 	}
+	rootPath := doc.GetRootPath(target)
 
 	imports, err := doc.GetImports(target, rootPath, setting.WorkDir, false)
 	if err != nil {

cmd/get.go

@@ -1,4 +1,4 @@
-// Copyright 2014 Unknown
+// Copyright 2014 Unknwon
 //
 // Licensed under the Apache License, Version 2.0 (the "License"): you may
 // not use this file except in compliance with the License. You may obtain
@@ -139,8 +139,11 @@ func downloadPackage(ctx *cli.Context, n *doc.Node) (*doc.Node, []string, error)
 
 	if !n.IsGetDeps {
 		imports = nil
+	} else {
+		fmt.Println(n.InstallPath, n.ValSuffix())
+		// err=autoLink(n.InstallPath, newPath)
 	}
-	return n, imports, nil
+	return n, imports, err
 }
 
 // downloadPackages downloads packages with certain commit,
@@ -285,7 +288,7 @@ func getPackages(target string, ctx *cli.Context, nodes []*doc.Node) (err error)
 
 func getByGopmfile(ctx *cli.Context) error {
 	// Make sure gopmfile exists and up-to-date.
-	gf, target, imports, err := genGopmfile()
+	gf, target, imports, err := genGopmfile(ctx)
 	if err != nil {
 		return err
 	}

cmd/install.go

@@ -53,7 +53,7 @@ func runInstall(ctx *cli.Context) {
 	var target, srcPath string
 	switch len(ctx.Args()) {
 	case 0:
-		_, target, _, err = genGopmfile()
+		_, target, _, err = genGopmfile(ctx)
 		if err != nil {
 			errors.SetError(err)
 			return

cmd/list.go

@@ -54,7 +54,7 @@ func runList(ctx *cli.Context) {
 		return
 	}
 
-	gf, _, imports, err := genGopmfile()
+	gf, _, imports, err := genGopmfile(ctx)
 	if err != nil {
 		errors.SetError(err)
 		return

gopm.go

@@ -1,6 +1,4 @@
-// +build go1.2
-
-// Copyright 2014 Unknown
+// Copyright 2014 Unknwon
 //
 // Licensed under the Apache License, Version 2.0 (the "License"): you may
 // not use this file except in compliance with the License. You may obtain

gopm/gopm.go

@@ -1,6 +1,6 @@
 // +build go1.2
 
-// Copyright 2014 Unknown
+// Copyright 2014 Unknwon
 //
 // Licensed under the Apache License, Version 2.0 (the "License"): you may
 // not use this file except in compliance with the License. You may obtain
@@ -28,7 +28,7 @@ import (
 	"github.com/gpmgo/gopm/modules/setting"
 )
 
-const APP_VER = "0.7.1.0613 Beta"
+const APP_VER = "0.7.2.0727 Beta"
 
 func init() {
 	runtime.GOMAXPROCS(runtime.NumCPU())
@@ -41,17 +41,17 @@ func Run(args []string) *setting.Error {
 	app.Usage = "Go Package Manager"
 	app.Version = APP_VER
 	app.Commands = []cli.Command{
-		cmd.CmdBin,
-		cmd.CmdGen,
+		// cmd.CmdBin,
+		// cmd.CmdGen,
 		cmd.CmdGet,
-		cmd.CmdList,
-		cmd.CmdConfig,
-		cmd.CmdRun,
-		cmd.CmdTest,
-		cmd.CmdBuild,
-		cmd.CmdInstall,
-		cmd.CmdClean,
-		cmd.CmdUpdate,
+		// cmd.CmdList,
+		// cmd.CmdConfig,
+		// cmd.CmdRun,
+		// cmd.CmdTest,
+		// cmd.CmdBuild,
+		// cmd.CmdInstall,
+		// cmd.CmdClean,
+		// cmd.CmdUpdate,
 		// CmdSearch,
 	}
 	app.Flags = append(app.Flags, []cli.Flag{

modules/doc/utils.go

@@ -19,7 +19,6 @@ import (
 	"go/build"
 	"os"
 	"path"
-	"path/filepath"
 	"regexp"
 	"runtime"
 	"strings"
@@ -91,18 +90,6 @@ func IsGoRepoPath(name string) bool {
 
 // GetImports returns package denpendencies.
 func GetImports(importPath, rootPath, srcPath string, isTest bool) ([]string, error) {
-	tmpGopath := setting.InstallRepoPath
-	if setting.IsWindows {
-		// Windows's local repository path has "/src" suffix.
-		tmpGopath = path.Dir(tmpGopath)
-	} else {
-		if !com.IsExist(path.Join(setting.InstallRepoPath, "src")) {
-			if err := os.Symlink(setting.InstallRepoPath, path.Join(setting.InstallRepoPath, "src")); err != nil {
-				log.Error("", "Fail to setting symlink:")
-				log.Fatal("", "\t"+err.Error())
-			}
-		}
-	}
 	oldGopath := os.Getenv("GOPATH")
 
 	sep := ":"
@@ -111,7 +98,7 @@ func GetImports(importPath, rootPath, srcPath string, isTest bool) ([]string, er
 	}
 
 	ctxt := build.Default
-	ctxt.GOPATH = tmpGopath + sep + oldGopath
+	ctxt.GOPATH = VENDOR + sep + oldGopath
 	pkg, err := ctxt.Import(importPath, srcPath, build.AllowBinary)
 	if err != nil {
 		if _, ok := err.(*build.NoGoError); !ok {
@@ -134,12 +121,7 @@ func GetImports(importPath, rootPath, srcPath string, isTest bool) ([]string, er
 		if IsGoRepoPath(name) {
 			continue
 		} else if strings.HasPrefix(name, rootPath) {
-			relPath, err := filepath.Rel(importPath, name)
-			if err != nil {
-				log.Error("", "Fail to get relative path of import")
-				log.Fatal("", "\t"+err.Error())
-			}
-			moreImports, err := GetImports(name, rootPath, "./"+relPath, isTest)
+			moreImports, err := GetImports(name, rootPath, name, isTest)
 			if err != nil {
 				return nil, err
 			}