Merge pull request #9 from tamada/issue/add_repository_to_multiple_gr…

…oups

ref #7 update add subcommand for adding a repository to the multiple groups

add/add.go

@@ -38,7 +38,38 @@ func (add *AddCommand) createGroupIfNeeded(db *common.Database, groupName string
 	return fmt.Errorf("%s: group not found", groupName)
 }
 
-func (add *AddCommand) addRepositoriesToGroup(db *common.Database, args []string, groupName string) []error {
+func checkDuplication(db *common.Database, repoID string, path string) error {
+	var repo = db.FindRepository(repoID)
+	if repo != nil && repo.Path != path {
+		return fmt.Errorf("%s: duplicate repository id", repoID)
+	}
+	return nil
+}
+
+func (add *AddCommand) addRepositoryToGroup(db *common.Database, groupName string, path string, list []error) []error {
+	var absPath, _ = filepath.Abs(path)
+	var id = filepath.Base(absPath)
+	if err1 := add.isExistAndGitRepository(absPath, path); err1 != nil {
+		return append(list, err1)
+	}
+	var repoPath = common.NormalizePath(absPath)
+	if err1 := checkDuplication(db, id, absPath); err1 != nil {
+		return append(list, err1)
+	} else {
+		var remotes, err2 = FindRemotes(absPath)
+		if err2 != nil {
+			return append(list, err2)
+		}
+		db.CreateRepository(id, repoPath, remotes)
+	}
+	var err = db.Relate(groupName, id)
+	if err != nil {
+		return append(list, fmt.Errorf("%s: cannot create relation to group %s", id, groupName))
+	}
+	return list
+}
+
+func (add *AddCommand) AddRepositoriesToGroup(db *common.Database, args []string, groupName string) []error {
 	var err = add.createGroupIfNeeded(db, groupName)
 	if err != nil {
 		return []error{err}
@@ -70,27 +101,3 @@ func FindRemotes(path string) ([]common.Remote, error) {
 	}
 	return crs, nil
 }
-
-func (add *AddCommand) addRepositoryToGroup(db *common.Database, groupName string, path string, list []error) []error {
-	var absPath, _ = filepath.Abs(path)
-	var id = filepath.Base(absPath)
-	if err1 := add.isExistAndGitRepository(absPath, path); err1 != nil {
-		return append(list, err1)
-	}
-	var repoPath = common.NormalizePath(absPath)
-	if !db.HasRepository(id) {
-		var remotes, err2 = FindRemotes(absPath)
-		if err2 != nil {
-			return append(list, err2)
-		}
-		var _, err = db.CreateRepository(id, repoPath, remotes)
-		if err != nil {
-			return append(list, err)
-		}
-	}
-	var err = db.Relate(groupName, id)
-	if err != nil {
-		return append(list, fmt.Errorf("%s: cannot create relation to group %s", id, groupName))
-	}
-	return list
-}

add/add_cmd.go

@@ -44,7 +44,7 @@ func (add *AddCommand) showError(errorlist []error, onError string) {
 func (add *AddCommand) perform(db *common.Database, args []string, groupName string) int {
 	var onError = db.Config.GetValue(common.RrhOnError)
 
-	var errorlist = add.addRepositoriesToGroup(db, args, groupName)
+	var errorlist = add.AddRepositoriesToGroup(db, args, groupName)
 
 	add.showError(errorlist, onError)
 
@@ -73,7 +73,7 @@ func (add *AddCommand) Run(args []string) int {
 	var db, err2 = common.Open(config)
 	if err2 != nil {
 		fmt.Println(err2.Error())
-		return 1
+		return 2
 	}
 	return add.perform(db, opt.args, opt.group)
 }
@@ -85,17 +85,15 @@ type addOptions struct {
 
 func (add *AddCommand) parse(args []string, config *common.Config) (*addOptions, error) {
 	var opt = addOptions{}
+	var defaultGroup = config.GetValue(common.RrhDefaultGroupName)
 	flags := flag.NewFlagSet("add", flag.ContinueOnError)
 	flags.Usage = func() { fmt.Println(add.Help()) }
-	flags.StringVar(&opt.group, "g", config.GetValue(common.RrhDefaultGroupName), "target group")
-	flags.StringVar(&opt.group, "group", config.GetValue(common.RrhDefaultGroupName), "target group")
+	flags.StringVar(&opt.group, "g", defaultGroup, "target group")
+	flags.StringVar(&opt.group, "group", defaultGroup, "target group")
 	if err := flags.Parse(args); err != nil {
 		return nil, err
 	}
 	opt.args = flags.Args()
-	if opt.group == "" {
-		opt.group = config.GetValue(common.RrhDefaultGroupName)
-	}
 
 	return &opt, nil
 }

add/add_test.go

@@ -15,6 +15,16 @@ func rollback(f func()) {
 	f()
 }
 
+func TestInvalidOptions(t *testing.T) {
+	common.CaptureStdout(func() {
+		var command, _ = AddCommandFactory()
+		var flag = command.Run([]string{"--invalid-option"})
+		if flag != 1 {
+			t.Errorf("parse option failed.")
+		}
+	})
+}
+
 func TestHelpAndSynopsis(t *testing.T) {
 	var command, _ = AddCommandFactory()
 	if command.Synopsis() != "add repositories on the local path to RRH" {
@@ -70,3 +80,53 @@ func TestAddCommand_Run(t *testing.T) {
 		}
 	})
 }
+
+func TestAddToDifferentGroup(t *testing.T) {
+	os.Setenv(common.RrhConfigPath, "../testdata/config.json")
+	os.Setenv(common.RrhDatabasePath, "../testdata/tmp.json")
+	rollback(func() {
+		var command, _ = AddCommandFactory()
+		command.Run([]string{"../testdata/fibonacci"})
+		command.Run([]string{"-g", "group1", "../testdata/fibonacci"})
+
+		var config = common.OpenConfig()
+		var db, _ = common.Open(config)
+		if !db.HasGroup("no-group") {
+			t.Error("no-group: group not found")
+		}
+		if !db.HasRepository("fibonacci") {
+			t.Error("fibonacci: repository not found")
+		}
+		if !db.HasRelation("no-group", "fibonacci") {
+			t.Error("no-group, and fibonacci: the relation not found")
+		}
+		if !db.HasRelation("group1", "fibonacci") {
+			t.Error("group1 and fibonacci: the relation not found")
+		}
+	})
+}
+
+func TestAddFailed(t *testing.T) {
+	os.Setenv(common.RrhConfigPath, "../testdata/nulldb.json")
+	os.Setenv(common.RrhDatabasePath, "../testdata/tmp.json")
+	os.Setenv(common.RrhAutoCreateGroup, "false")
+
+	var add = AddCommand{}
+	var config = common.OpenConfig()
+	var db, _ = common.Open(config)
+
+	var data = []struct {
+		args      []string
+		groupName string
+	}{
+		{[]string{"../not-exist-dir"}, "no-group"},
+		{[]string{"../testdata/fibonacci"}, "not-exist-group"},
+	}
+
+	for _, datum := range data {
+		var list = add.AddRepositoriesToGroup(db, datum.args, datum.groupName)
+		if len(list) == 0 {
+			t.Errorf("successfully add in invalid data: %v", datum)
+		}
+	}
+}

clone/clone.go

@@ -17,8 +17,7 @@ func (clone *CloneCommand) toDir(db *common.Database, url string, dest string, r
 	var cmd = exec.Command("git", "clone", url, dest)
 	var err = cmd.Run()
 	if err != nil {
-		fmt.Printf("clone error: %s\n", err.Error())
-		return nil, err
+		return nil, fmt.Errorf("%s: clone error (%s)", url, err.Error())
 	}
 
 	path, err := filepath.Abs(dest)

clone/clone_cmd.go

@@ -64,7 +64,7 @@ func (clone *CloneCommand) Run(args []string) int {
 	db, err := common.Open(config)
 	if err != nil {
 		fmt.Println(err.Error())
-		return 1
+		return 2
 	}
 	return clone.perform(db, arguments)
 }
@@ -79,15 +79,21 @@ func (clone *CloneCommand) perform(db *common.Database, arguments []string) int
 		}
 	}
 	db.StoreAndClose()
-	if count == 1 {
-		fmt.Printf("a repository cloned into %s and registered to group %s\n", clone.Options.dest, clone.Options.group)
-	} else {
-		fmt.Printf("%d repositories cloned into %s and registered to group %s\n", count, clone.Options.dest, clone.Options.group)
-	}
-
+	printResult(count, clone.Options.dest, clone.Options.group)
 	return 0
 }
 
+func printResult(count int, dest string, group string) {
+	switch count {
+	case 0:
+		fmt.Println("no repositories cloned")
+	case 1:
+		fmt.Printf("a repository cloned into %s and registered to group %s\n", dest, group)
+	default:
+		fmt.Printf("%d repositories cloned into %s and registered to group %s\n", count, dest, group)
+	}
+}
+
 func (clone *CloneCommand) parse(args []string, config *common.Config) ([]string, error) {
 	var defaultGroup = config.GetDefaultValue(common.RrhDefaultGroupName)
 	var options = cloneOptions{defaultGroup, ".", false}

clone/clone_test.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
+	"strings"
 	"testing"
 
 	"github.com/tamada/rrh/common"
@@ -122,6 +123,34 @@ func TestCloneCommand_SpecifyingId(t *testing.T) {
 	})
 }
 
+func TestUnknownOption(t *testing.T) {
+	os.Setenv(common.RrhConfigPath, "../testdata/config.json")
+	os.Setenv(common.RrhDatabasePath, "../testdata/tmp.json")
+	var output, _ = common.CaptureStdout(func() {
+		var clone, _ = CloneCommandFactory()
+		clone.Run([]string{})
+	})
+	var cm = CloneCommand{}
+	if output != cm.Help() {
+		t.Error("no arguments were allowed")
+	}
+}
+
+func TestCloneNotGitRepository(t *testing.T) {
+	os.Setenv(common.RrhConfigPath, "../testdata/config.json")
+	os.Setenv(common.RrhDatabasePath, "../testdata/tmp.json")
+	os.Setenv(common.RrhOnError, "FAIL")
+	var output, _ = common.CaptureStdout(func() {
+		var clone, _ = CloneCommandFactory()
+		clone.Run([]string{"../testdata"})
+	})
+	output = strings.TrimSpace(output)
+	var message = "../testdata: clone error (exit status 128)"
+	if output != message {
+		t.Errorf("wont: %s, got: %s", message, output)
+	}
+}
+
 func TestHelpAndSynopsis(t *testing.T) {
 	var helpMessage = `rrh clone [OPTIONS] <REMOTE_REPOS...>
 OPTIONS