Implement package installation

3 files changed, 151 insertions, 19 deletions

diff --git a/env.go b/env.go
index 3f8f6eb..0cf0c0e 100644
--- a/env.go
+++ b/env.go
@@ -306,6 +306,8 @@ func (env *Env) Save(file string) (err error) {
 		}
 	}
 
+	fmt.Println(">>> Saving db", file)
+
 	dir := filepath.Dir(file)
 
 	err = os.MkdirAll(dir, 0700)
@@ -371,6 +373,20 @@ func (env *Env) String() string {
 	return buf.String()
 }
 
+//
+// install a package.
+//
+func (env *Env) install(pkg *Package) (ok bool, err error) {
+	err = pkg.Install()
+	if err != nil {
+		return
+	}
+
+	ok = true
+
+	return
+}
+
 func (env *Env) update(curPkg, newPkg *Package) (ok bool, err error) {
 	err = curPkg.Fetch()
 	if err != nil {
@@ -388,6 +404,7 @@ func (env *Env) update(curPkg, newPkg *Package) (ok bool, err error) {
 
 	if curPkg.IsEqual(newPkg) {
 		fmt.Printf("Nothing to update.\n")
+		ok = true
 		return
 	}
 
@@ -411,15 +428,13 @@ func (env *Env) update(curPkg, newPkg *Package) (ok bool, err error) {
 	return
 }
 
-func (env *Env) install(pkg *Package) (ok bool, err error) {
-	return
-}
-
 //
 // updateMissing will remove missing package if it's already provided by new
 // package and add it as one of package dependencies.
 //
 func (env *Env) updateMissing(newPkg *Package) {
+	fmt.Println(">>> Update missing ...")
+
 	for x := 0; x < len(env.pkgs); x++ {
 		env.pkgs[x].UpdateMissingDep(newPkg)
 	}
@@ -490,6 +505,10 @@ func (env *Env) Sync(pkgName, importPath string) (err error) {
 	if !ok {
 		return
 	}
+	if curPkg == nil {
+		curPkg = newPkg
+		env.addPackage(newPkg)
+	}
 
 	err = env.postSync(curPkg, newPkg)
 
@@ -519,9 +538,7 @@ func (env *Env) postSync(curPkg, newPkg *Package) (err error) {
 		}
 	}
 
-	if Debug >= DebugL1 {
-		log.Printf("Package installed:\n%s", curPkg)
-	}
+	fmt.Println(">>> Package installed:\n", curPkg)
 
 	return
 }
diff --git a/package.go b/package.go
index ed6b9b0..d9fcf1b 100644
--- a/package.go
+++ b/package.go
@@ -81,6 +81,23 @@ func (pkg *Package) Fetch() (err error) {
 }
 
 //
+// Install a package. Clone package to GOPATH/src, set to the latest tag if
+// exist or to the latest commit, and scan dependencies.
+//
+func (pkg *Package) Install() (err error) {
+	switch pkg.vcs {
+	case VCSModeGit:
+		err = pkg.gitInstall()
+	}
+
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+//
 // IsEqual will return true if current package have the same import path,
 // remote name, remote URL, and version with other package; otherwise it will
 // return false.
@@ -129,6 +146,8 @@ func (pkg *Package) Scan() (err error) {
 // only external dependencies.
 //
 func (pkg *Package) ScanDeps(env *Env) (err error) {
+	fmt.Println(">>> Scanning dependencies ...")
+
 	imports, err := pkg.GetRecursiveImports()
 	if err != nil {
 		return
@@ -152,9 +171,12 @@ func (pkg *Package) ScanDeps(env *Env) (err error) {
 func (pkg *Package) GetRecursiveImports() (
 	imports []string, err error,
 ) {
-	cmd := exec.Command("go", "list", "-f", `{{ join .Deps "\n"}}`,
-		"./...")
+	//nolint: gas
+	cmd := exec.Command("go", "list", "-e", "-f", `{{ join .Deps "\n"}}`, "./...")
+	fmt.Println(">>>", cmd.Args)
+
 	cmd.Dir = pkg.FullPath
+	cmd.Stderr = defStderr
 
 	out, err := cmd.Output()
 	if err != nil {
@@ -291,6 +313,7 @@ func (pkg *Package) load(sec *ini.Section) {
 func (pkg *Package) RunGoInstall(isVerbose bool) (err error) {
 	fmt.Println(">>> Running go install ...")
 
+	//nolint:gas
 	cmd := exec.Command("go", "install")
 
 	if isVerbose {
@@ -298,8 +321,9 @@ func (pkg *Package) RunGoInstall(isVerbose bool) (err error) {
 	}
 
 	cmd.Args = append(cmd.Args, "./...")
-	cmd.Env = append(cmd.Env, "GOPATH="+build.Default.GOPATH)
+	fmt.Println(">>>", cmd.Args)
 
+	cmd.Env = append(cmd.Env, "GOPATH="+build.Default.GOPATH)
 	cmd.Dir = pkg.FullPath
 	cmd.Stdout = defStdout
 	cmd.Stderr = defStderr
diff --git a/package_git.go b/package_git.go
index 1f4c1a0..8865ebf 100644
--- a/package_git.go
+++ b/package_git.go
@@ -4,16 +4,65 @@ import (
 	"bytes"
 	"fmt"
 	"log"
+	"os"
 	"os/exec"
 
 	"github.com/shuLhan/share/lib/ini"
 )
 
 //
+// gitCheckoutVersion will set the HEAD to version stated in package.
+//
+func (pkg *Package) gitCheckoutVersion(version string) (err error) {
+	//nolint:gas
+	cmd := exec.Command("git", "checkout", "-q", version)
+	fmt.Println(">>>", cmd.Args)
+	cmd.Dir = pkg.FullPath
+	cmd.Stdout = defStdout
+	cmd.Stderr = defStderr
+
+	err = cmd.Run()
+	if err != nil {
+		err = fmt.Errorf("gitCheckoutVersion: %s", err)
+		return
+	}
+
+	return
+}
+
+//
+// gitClone the package into "$GOPATH/src/{ImportPath}".
+//
+func (pkg *Package) gitClone() (err error) {
+	err = os.MkdirAll(pkg.FullPath, 0700)
+	if err != nil {
+		err = fmt.Errorf("gitClone: %s", err)
+		return
+	}
+
+	//nolint:gas
+	cmd := exec.Command("git", "clone", pkg.RemoteURL, ".")
+	fmt.Println(">>>", cmd.Args)
+	cmd.Dir = pkg.FullPath
+	cmd.Stdout = defStdout
+	cmd.Stderr = defStderr
+
+	err = cmd.Run()
+	if err != nil {
+		err = fmt.Errorf("gitClone: %s", err)
+		return
+	}
+
+	return
+}
+
+//
 // gitCompareVersion compare the version of current package with new package.
 //
 func (pkg *Package) gitCompareVersion(newPkg *Package) (err error) {
+	//nolint:gas
 	cmd := exec.Command("git", "log", "--oneline", pkg.Version+"..."+newPkg.Version)
+	fmt.Println(">>>", cmd.Args)
 	cmd.Dir = pkg.FullPath
 	cmd.Stdout = defStdout
 	cmd.Stderr = defStderr
@@ -33,7 +82,9 @@ func (pkg *Package) gitCompareVersion(newPkg *Package) (err error) {
 // to latest commit otherwise.
 //
 func (pkg *Package) gitFetch() (err error) {
+	//nolint:gas
 	cmd := exec.Command("git", "fetch", "--all")
+	fmt.Println(">>>", cmd.Args)
 	cmd.Dir = pkg.FullPath
 	cmd.Stdout = defStdout
 	cmd.Stderr = defStderr
@@ -59,7 +110,9 @@ func (pkg *Package) gitFetch() (err error) {
 // (origin/master).
 //
 func (pkg *Package) gitGetCommit(ref string) (commit string, err error) {
+	//nolint:gas
 	cmd := exec.Command("git", "rev-parse", "--short", ref)
+	fmt.Println(">>>", cmd.Args)
 	cmd.Dir = pkg.FullPath
 
 	bcommit, err := cmd.Output()
@@ -77,7 +130,9 @@ func (pkg *Package) gitGetCommit(ref string) (commit string, err error) {
 // gitGetTag will try to get the current tag from HEAD.
 //
 func (pkg *Package) gitGetTag() (tag string, err error) {
+	//nolint:gas
 	cmd := exec.Command("git", "describe", "--tags", "--exact-match")
+	fmt.Println(">>>", cmd.Args)
 	cmd.Dir = pkg.FullPath
 
 	btag, err := cmd.Output()
@@ -92,7 +147,9 @@ func (pkg *Package) gitGetTag() (tag string, err error) {
 }
 
 func (pkg *Package) gitGetTagLatest() (tag string, err error) {
+	//nolint:gas
 	cmd := exec.Command("git", "rev-list", "--tags", "--max-count=1")
+	fmt.Println(">>>", cmd.Args)
 	cmd.Dir = pkg.FullPath
 
 	bout, err := cmd.Output()
@@ -103,7 +160,9 @@ func (pkg *Package) gitGetTagLatest() (tag string, err error) {
 
 	out := string(bytes.TrimSpace(bout))
 
+	//nolint:gas
 	cmd = exec.Command("git", "describe", "--tags", "--abbrev=0", out)
+	fmt.Println(">>>", cmd.Args)
 	cmd.Dir = pkg.FullPath
 
 	bout, err = cmd.Output()
@@ -118,12 +177,49 @@ func (pkg *Package) gitGetTagLatest() (tag string, err error) {
 }
 
 //
+// gitInstall the package into GOPATH source directory.
+//
+func (pkg *Package) gitInstall() (err error) {
+	err = pkg.gitClone()
+	if err != nil {
+		err = fmt.Errorf("gitInstall: %s", err)
+		return
+	}
+
+	var rev string
+	if len(pkg.Version) == 0 {
+		rev, err = pkg.gitGetTagLatest()
+		if err == nil {
+			pkg.Version = rev
+			pkg.isTag = IsTagVersion(rev)
+		} else {
+			rev, err = pkg.gitGetCommit(gitRefHEAD)
+			if err != nil {
+				err = fmt.Errorf("gitInstall: %s", err)
+				return
+			}
+
+			pkg.Version = rev
+		}
+	}
+
+	err = pkg.gitCheckoutVersion(pkg.Version)
+	if err != nil {
+		err = fmt.Errorf("gitInstall: %s", err)
+		return
+	}
+
+	return
+}
+
+//
 // gitRemoteChange current package remote name (e.g. "origin") or URL to new
 // package remote-name or url.
 //
 func (pkg *Package) gitRemoteChange(newPkg *Package) (err error) {
-	fmt.Println(">>> git remote remove", pkg.RemoteName)
+	//nolint:gas
 	cmd := exec.Command("git", "remote", "remove", pkg.RemoteName)
+	fmt.Println(">>>", cmd.Args)
 	cmd.Dir = pkg.FullPath
 	cmd.Stdout = defStdout
 	cmd.Stderr = defStderr
@@ -133,8 +229,9 @@ func (pkg *Package) gitRemoteChange(newPkg *Package) (err error) {
 		log.Println("gitRemoteChange:", err)
 	}
 
-	fmt.Println(">>> git remote add", newPkg.RemoteName, newPkg.RemoteURL)
+	//nolint:gas
 	cmd = exec.Command("git", "remote", "add", newPkg.RemoteName, newPkg.RemoteURL)
+	fmt.Println(">>>", cmd.Args)
 	cmd.Dir = pkg.FullPath
 	cmd.Stdout = defStdout
 	cmd.Stderr = defStderr
@@ -220,13 +317,7 @@ func (pkg *Package) gitUpdate(newPkg *Package) (err error) {
 		return
 	}
 
-	fmt.Println(">>> git checkout -q", newPkg.Version)
-	cmd := exec.Command("git", "checkout", "-q", newPkg.Version)
-	cmd.Dir = newPkg.FullPath
-	cmd.Stdout = defStdout
-	cmd.Stderr = defStderr
-
-	err = cmd.Run()
+	err = pkg.gitCheckoutVersion(newPkg.Version)
 	if err != nil {
 		err = fmt.Errorf("gitUpdate: %s", err)
 		return