documentation

README.md

@@ -15,6 +15,7 @@ This application still in experiment, any change could happen, but it doesn't af
 
 - Download packages from popular project hosting with/without version control tools.
 - Remove packages from local file system.
+- Check package dependencies and download missing ones.
 - More specific examples, see [Quick Start](docs/Quick_Start.md).
 
 ## Main commands
@@ -28,12 +29,12 @@ This application still in experiment, any change could happen, but it doesn't af
 ## Known issues
 
 - When you use commands like `gpm install -p bitbucket.org/zombiezen/gopdf` where is project root path but the directory doesn't contain any source files, you will get error in the installation step, you have to use `gpm install -p bitbucket.org/zombiezen/gopdf/pdf` in order to go through all steps correctly.
+- Cannot remove `.git` with error `access is denied`.
 
 ## Todo
 
 ### v0.2.*
 
-- Add template projects for testing commands.
 - Add feature auto-catch if run under GOPATH/bin.
 
 ### Future

check.go

@@ -64,7 +64,7 @@ func runCheck(cmd *Command, args []string) {
 
 	for _, v := range imports {
 		// Make sure it doesn't belong to same project.
-		if !strings.HasPrefix(v, importPath) {
+		if utils.GetProjectPath(v) != utils.GetProjectPath(importPath) {
 			for _, p := range paths {
 				if utils.IsExist(p + "/src/" + v + "/") {
 					isInstalled = true

conf/gpm.toml

@@ -1,9 +1,9 @@
 # This is a configuration file for gpm with toml format.
 
 title = "gpm(Go Package Manager)"
-version = "v0.2.0 Build 0523"
-#user_language = "en-US"
-user_language = "zh-CN"
+version = "v0.2.1 Build 0524"
+user_language = "en-US"
+#user_language = "zh-CN"
 auto_backup = true
 
 [account]
@@ -12,5 +12,5 @@ password = ""
 github_access_token = ""
 
 [auto_enable]
-build = ["v", "r"]
-install = ["p"]
+build = []
+install = []

doc/bitbucket.go

@@ -139,6 +139,8 @@ func GetBitbucketDoc(client *http.Client, match map[string]string, installGOPATH
 
 		if isCodeOnly && !utils.IsDocFile(path.Base(absPath)) {
 			continue
+		} else if strings.HasPrefix(fn, ".") {
+			continue
 		}
 
 		// Get data from archive.

doc/github.go

@@ -127,15 +127,21 @@ func GetGithubDoc(client *http.Client, match map[string]string, installGOPATH st
 		// Create diretory before create file.
 		os.MkdirAll(path.Dir(absPath)+"/", os.ModePerm)
 
+	compareDir:
 		switch {
 		case strings.HasSuffix(absPath, "/"): // Directory.
 			// Check if current directory is example.
 			if !(!cmdFlags["-e"] && strings.Contains(absPath, "example")) {
+				for _, d := range dirs {
+					if d == absPath {
+						break compareDir
+					}
+				}
 				dirs = append(dirs, absPath)
 			}
 		case isCodeOnly && !utils.IsDocFile(path.Base(absPath)):
 			continue
-		default:
+		case !strings.HasPrefix(f.FileInfo().Name(), "."):
 			// Get file from archive.
 			rc, err := f.Open()
 			if err != nil {

doc/google.go

@@ -99,6 +99,8 @@ func GetGoogleDoc(client *http.Client, match map[string]string, installGOPATH st
 		fname := strings.Split(string(m[1]), "?")[0]
 		if isCodeOnly && !utils.IsDocFile(fname) {
 			continue
+		} else if strings.HasPrefix(fname, ".") {
+			continue
 		}
 
 		files = append(files, &source{

doc/launchpad.go

@@ -101,7 +101,7 @@ func GetLaunchpadDoc(client *http.Client, match map[string]string, installGOPATH
 			}
 		case isCodeOnly && !utils.IsDocFile(path.Base(absPath)):
 			continue
-		default:
+		case !strings.HasPrefix(fn, "."):
 			// Create diretory before create file.
 			os.MkdirAll(path.Dir(absPath)+"/", os.ModePerm)
 

doc/walker.go

@@ -127,7 +127,8 @@ func (w *walker) build(srcs []*source) ([]string, error) {
 	var imports []string
 	for _, v := range bpkg.Imports {
 		// Skip strandard library.
-		if !utils.IsGoRepoPath(v) && !strings.HasPrefix(v, w.ImportPath) {
+		if !utils.IsGoRepoPath(v) &&
+			(utils.GetProjectPath(v) != utils.GetProjectPath(w.ImportPath)) {
 			imports = append(imports, v)
 		}
 	}

docs/Quick_Start.md

@@ -2,37 +2,44 @@
 
 **Attention** Features like bundle and snapshot have NOT been published for users.
 
-Full documentation please visit [GPMGo Documentation]().
+Full documentation please visit [GPMGo Documentation]()(Haven't done yet!).
 
 ## Index
 
 - [When and why](#when-and-why)
 - [Installation](#installation)
-- [ **Build** your first project](#build-your-first-project)
-- [ Download and **install** package, or packages](#download-and-install-package,-or-packages)
-- [ **Remove** package, or packages](#remove-package,-or-packages)
+- [ **install** package, or packages](#install-package-or-packages)
+- [ **Build** and run it](#build-and-run-it)
+- [ **Remove** package, or packages](#remove-package-or-packages)
+- [ Use **check** to check dependencies](#use-check-to-check-dependencies)
 
 ## When and why
 
-- No version control tool are installed, too lazy to have it? 
+### Lightweight version control
+
+Unlike large version control system like git, hg, or svn, you don't have to install any version control tool for using gpm; you are still able to download and install packages that you prefer to.
+
+### Not only project, but dependencies!
 	
-	Go get gpm!
+With gpm, it's much easier to control dependencies version of your packages specifically. All you need to do is that indicate version either by tag, branch or commit of your dependencies, and leave rest of work to gpm!
 
-- Killer feature over `go get`? 
+### Killer feature over `go get`? 
 
-	There is almost nothing better than `go get` until we make feature bundle and snapshot be available to you.
+`go get` gives great advantages of package installation in Go, but the only thing it's missing is version control of dependencies.
 
-	
+### How's configuration file looks like?
+
+In gpm, we call `bundle` for this kind of files, here is an example of a [bundle](https://github.com/GPMGo/gpm/blob/master/repo/bundles/test_bundle.json), don't get it? It's fine, we'll talk about it more just one second.
 
 ## Installation
 
-You can install either from source or download binary. 
+You can install gpm either from source or download binary. 
 
 ### Install from source
 
 - gpm is a `go get` able project: execute command `go get github.com/GPMGo/gpm` to download and install.
 - Run test: switch work directory to gpm project, and execute command `go test` to build and test commands automatically(for now, tested commands are `gpm install`, `gpm remove`).
-- Add gpm project path to your environment variable `PATH` in order to execute it from other directories.
+- Add gpm project path to your environment variable `PATH` in order to execute it in other directories.
 
 ### Download binary
 
@@ -49,37 +56,63 @@ Because we don't have all kinds of operating systems, we need your help to compl
 
 **Attention** Because we use API to get information of packages that are hosted on github.com, but it limits 60 requests per hour, so you may get errors if you download too much(more than 50 packages per hour). We do not provider access token for security reason, but we do have configure option `github_access_token` in configuration file `conf/gpm.toml`, so you can go to [here](https://github.com/settings/applications) and create your personal access token(up to 5000 request per hour), and set it in `gpm.toml`.
 
-## Build your first project
+## Download and install package, or packages
+
+Command `install` downloads and installs packages along with all dependencies(except when you use bundle or snapshot).
+
+Suppose you want to install package `github.com/GPMGoTest/install_test`, here two ways to do it:
+
+### Install like `go get`
+
+- Execute command `gpm install -p github.com/GPMGoTest/install_test`, flag `-p` means **pure download** (download packages without version control), so you do not need to install version control tool. In case you want to, `gpm install github.com/GPMGoTest/install_test` calls `go get` in underlying.
+
+### Install through bundle
+
+- It's still not cool enough to download and install packages with import path, let's try execute command `gpm install -p test.b`, see what happens? 
+- Where is the `test.b` comes from? We actually created a bundle for you in directory `repo/bundles/`, and all bundles should be put there. 
+- This is how bundle works, you can open it and see what's inside, it includes import path, type, value and dependencies.
+- The `test.b` means the bundle whose name is `test`, if you want to use bundle, you have to add suffix `.b`. You may notice that our file name is `install_test.json`, why is `test`? Because we use `bundle_name` inside file, file name doesn't mean anything unless you leave `bundle_name` blank, then the file name becomes bundle name automatically, but be sure that all bundle file name should use JSON and suffix `.json`.
+- For `code.google.com`, `launchpad.net`, type is **ALWAYS** `commit`, and you can leave value blank which means up-to-date, or give it a certain value and you will download the same version of the package no matter how many times.
+- For `github.com`, `bitbucket.org`, type can be either `commit`, `branch` or `tag`, and give it corresponding value.
+- Now, you should have two packages which are `github.com/GPMGoTest/install_test` and `github.com/GPMGoTest/install_test2` in your computer.
+
+## Build and run it
 
 Command `build` compiles and installs packages along with all dependencies.
 
-Suppose you have a project called `github.com/GPMGo/gpm`.
+Let's switch work directory to package `github.com/GPMGoTest/install_test`.
 
-- Switch to corresponding directory: `cd $GOPATH/src/github.com/GPMGo/gpm`.
-- Execute command `gpm build`.
-- Then, gpm calls `go install` in underlying, so you should have binary `$GOPATH/bin/gpm`.
-- gpm moves binary from corresponding GOPATH to current which is `$GOPATH/src/github.com/GPMGo/` in this case, now just run your application.
+- Execute command `gpm build -r`.
+- After built, you should see string `Welcome to use gpm(Go Package Manager)!` was printed on the screen.
+- Then, gpm calls `go install` in underlying, so you should have binary `$GOPATH/bin/install_test`, then gpm moves it to current directory.
+- Flag `-r` means run after built, so you saw the string was printed.
 
 ### Why we do this?
 
-In some cases like building web applications, we use relative path to access static files, and `go build` compiles packages without saving, so it's a shortcut for `go install` + `go build`, and you don't need to compile packages which have not changed again.
+In some cases like building web applications, we use relative path to access static files, and `go build` compiles packages without saving, so it's a shortcut for `go install` + `go build` + `go run`, and you don't need to compile packages again for those have not changed.
 
-Also, you can use all flags that are used for `go install`.
+## Remove package, or packages
 
-## Download and install package, or packages
+Command `remove` removes packages from your local file system.
 
-Command `install` downloads and installs packages along with all dependencies(except when you use bundle or snapshot).
+Suppose you want to remove package `github.com/GPMGoTest/install_test2/subpkg`.
 
-Suppose you want to install package `bitbucket.org/zombiezen/gopdf/pdf`.
+- Execute command `gpm remove github.com/GPMGoTest/install_test2/subpkg`, gpm finds this project in all paths in your GOPATH environment.
+- You may notice this is not project path, it's OK because gpm knows it, and deletes directory `$GOPATH/src/github.com/GPMGoTest/install_test2/`, this command delete files in `$GOPATH/bin` and `$GOPATH/pkg` as well.
+- You can also use `gpm remove test.b` to remove all packages are included in bundle, but we don't need here because we have one more cool stuff to try.
 
-- Execute command `gpm install -p bitbucket.org/zombiezen/gopdf/pdf`, flag `-p` means **pure download** (download packages without version control), so you do not need to install version control tool. In case you want to, `gpm install bitbucket.org/zombiezen/gopdf/pdf` calls `go get` in underlying.
-- gpm tells your which GOPATH will be used for saving packages, and it checks your current execute path to get best matched path in your GOPATH environment variable.
+## Use check to check dependencies
 
-## Remove package, or packages
+Command `check` checks package dependencies and installs missing ones.
+
+Suppose you want to check package `github.com/GPMGoTest/install_test`.
 
-Command `remove` removes packages from your local file system(except when you use bundle or snapshot).
+- Switch work directory to package path.
+- Execute command `gpm check`.
 
-Suppose you want to remove package `bitbucket.org/zombiezen/gopdf/pdf`.
+## Go further
 
-- Execute command `gpm remove bitbucket.org/zombiezen/gopdf/pdf`, gpm finds this project in all paths in your GOPATH environment.
-- You may notice this is not project path, it's OK because gpm knows it, and deletes directory `$GOPATH/src/bitbucket.org/zombiezen/gopdf/`.
+- Online full documentation is still working, I'm sorry about that. 
+- Give us your feedback, these things matters.
+- Join us and get better together.
+- Contact: [gpmgo.com@gmail.com](mailto:gpmgo.com@gmail.com).

gpm_test.go

@@ -7,26 +7,33 @@ package main
 import (
 	"fmt"
 	"testing"
+	"time"
 )
 
 func TestGPM(t *testing.T) {
-	fmt.Println("gpm v0.1.5 Build 0523")
+	fmt.Println("gpm v0.2.0 Build 0524")
 
+	fmt.Println("\nBuilding gpm application...")
 	// Build application.
 	var args []string
 	args = append(args, "build")
 	executeCommand("go", args)
 
-	fmt.Println("Start testing command Install...")
+	fmt.Println("\nStart testing command Install...")
+	fmt.Println("This package depends on `install_test2`.")
+	time.Sleep(2 * time.Second)
 	args = make([]string, 0)
 	args = append(args, "install")
 	args = append(args, "-p")
-	args = append(args, "bitbucket.org/zombiezen/gopdf/pdf")
+	args = append(args, "github.com/GPMGoTest/install_test")
 	executeCommand("gpm", args)
 
-	fmt.Println("Start testing command Remove...")
+	fmt.Println("\nStart testing command Remove...")
+	fmt.Println("Let's remove `install_test` and `install_test2`.")
+	time.Sleep(2 * time.Second)
 	args = make([]string, 0)
 	args = append(args, "remove")
-	args = append(args, "bitbucket.org/zombiezen/gopdf/pdf")
+	args = append(args, "github.com/GPMGoTest/install_test")
+	args = append(args, "github.com/GPMGoTest/install_test2")
 	executeCommand("gpm", args)
 }

install.go

@@ -298,6 +298,7 @@ func downloadPackage(node *doc.Node) (*doc.Node, []string) {
 		downloadCache[node.ImportPath] = true
 
 		imports, err := pureDownload(node)
+
 		if err != nil {
 			fmt.Printf(fmt.Sprintf("%s\n", promptMsg["DownloadError"]), node.ImportPath, err)
 			return nil, nil

remove.go

@@ -58,8 +58,6 @@ func runRemove(cmd *Command, args []string) {
 		return
 	}
 	fw.Write(fbytes)
-
-	fmt.Println("Well done.")
 }
 
 // removePackages removes packages from local file system.

repo/bundles/install_test.json

@@ -0,0 +1,22 @@
+{
+	"id": 0,
+    "user_id": 0,
+	"bundle_name": "test",
+	"comment": "just a test",
+	"timestamp": 0,
+	"nodes": [
+		{
+			"import_path": "github.com/GPMGoTest/install_test",
+			"type": "branch",
+			"value": "master",
+			"deps": [
+				{
+					"import_path": "github.com/GPMGoTest/install_test2",
+					"type": "branch",
+					"value": "master",
+					"deps": null
+				}
+			]
+		}
+	]
+}