Add support for forks

README.md

@@ -17,6 +17,10 @@ This design removes the need for any sort of server-side setup. As a result,
 this tool can work with any git hosting provider, and the only setup required
 is installing the client on your workstation.
 
+Additionally, code reviews can be conducted across multiple hosting providers.
+The list of forks of a repository is also stored in the repository as git
+objects, allowing code reviews to be pulled from every registered fork.
+
 ## Installation
 
 Assuming you have the [Go tools installed](https://golang.org/doc/install), run
@@ -80,8 +84,15 @@ Submitting the current review:
 
     git appraise submit [--merge | --rebase]
 
+Adding a fork:
+
+    git appraise fork add -o <contributor-email>[,<contributor-email>]* <name> <url>
+
 A more detailed getting started doc is available [here](docs/tutorial.md).
 
+Instructions for using `git-appraise` with multiple forks can be found
+[here](docs/forks.md).
+
 ## Metadata
 
 The code review data is stored in [git-notes](https://git-scm.com/docs/git-notes),

commands/commands.go

@@ -18,12 +18,17 @@ limitations under the License.
 package commands
 
 import (
+	"fmt"
+
 	"github.com/google/git-appraise/repository"
 )
 
-const notesRefPattern = "refs/notes/devtools/*"
-const archiveRefPattern = "refs/devtools/archives/*"
-const commentFilename = "APPRAISE_COMMENT_EDITMSG"
+const (
+	notesRefPattern    = "refs/notes/devtools/*"
+	devtoolsRefPattern = "refs/devtools/*"
+	archiveRefPattern  = "refs/devtools/archives/*"
+	commentFilename    = "APPRAISE_COMMENT_EDITMSG"
+)
 
 // Command represents the definition of a single command.
 type Command struct {
@@ -41,15 +46,41 @@ func (cmd *Command) Run(repo repository.Repo, args []string) error {
 
 // CommandMap defines all of the available (sub)commands.
 var CommandMap = map[string]*Command{
-	"abandon": abandonCmd,
-	"accept":  acceptCmd,
-	"comment": commentCmd,
-	"list":    listCmd,
-	"pull":    pullCmd,
-	"push":    pushCmd,
-	"rebase":  rebaseCmd,
-	"reject":  rejectCmd,
-	"request": requestCmd,
-	"show":    showCmd,
-	"submit":  submitCmd,
+	"abandon":     abandonCmd,
+	"accept":      acceptCmd,
+	"comment":     commentCmd,
+	"fork add":    addForkCmd,
+	"fork list":   listForksCmd,
+	"fork remove": removeForkCmd,
+	"list":        listCmd,
+	"pull":        pullCmd,
+	"push":        pushCmd,
+	"rebase":      rebaseCmd,
+	"reject":      rejectCmd,
+	"request":     requestCmd,
+	"show":        showCmd,
+	"submit":      submitCmd,
+}
+
+// FindSubcommand parses the subcommand from the list of arguments.
+//
+// The args parameter is the list of command line args after the program name.
+//
+// The return result are the matching command (if found), whether or not the
+// command was found, and the list of remaining command line arguments that
+// followed the subcommand.
+func FindSubcommand(args []string) (*Command, bool, []string) {
+	if len(args) < 1 {
+		subcommand, ok := CommandMap["list"]
+		return subcommand, ok, []string{}
+	}
+	subcommand, ok := CommandMap[args[0]]
+	if ok {
+		return subcommand, ok, args[1:]
+	}
+	if len(args) > 1 {
+		subcommand, ok := CommandMap[fmt.Sprintf("%s %s", args[0], args[1])]
+		return subcommand, ok, args[2:]
+	}
+	return nil, false, []string{}
 }

commands/commands_test.go

@@ -0,0 +1,50 @@
+/*
+Copyright 2018 Google Inc. All rights reserved.
+
+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 a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package commands
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestFindSubcommandBuiltins(t *testing.T) {
+	for name, cmd := range CommandMap {
+		additionalArg := "foo"
+		matchingArgs := append(strings.Split(name, " "), additionalArg)
+		subcommand, ok, remainingArgs := FindSubcommand(matchingArgs)
+		if !ok {
+			t.Errorf("Failed to find the built-in subcommand %q", name)
+		} else if subcommand != cmd {
+			t.Errorf("Return the wrong subcommand for %q", name)
+		} else if len(remainingArgs) != 1 || remainingArgs[0] != additionalArg {
+			t.Errorf("Failed to return the remaining arguments for %q", name)
+		}
+	}
+}
+
+func TestFindSubcommandEmpty(t *testing.T) {
+	subcommand, ok, remaining := FindSubcommand([]string{})
+	if !ok {
+		t.Fatalf("Failed to return a default subcommand")
+	}
+	if subcommand != CommandMap["list"] {
+		t.Fatalf("Failed to return `list` as the default subcommand")
+	}
+	if len(remaining) != 0 {
+		t.Fatalf("Unexpected remaining arguments for an empty command: %q", remaining)
+	}
+}

commands/fork.go

@@ -0,0 +1,111 @@
+/*
+Copyright 2018 Google Inc. All rights reserved.
+
+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 a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package commands
+
+import (
+	"errors"
+	"flag"
+	"fmt"
+	"strings"
+
+	"github.com/google/git-appraise/commands/output"
+	"github.com/google/git-appraise/fork"
+	"github.com/google/git-appraise/repository"
+)
+
+var (
+	addForkFlagSet = flag.NewFlagSet("fork add", flag.ExitOnError)
+	addForkOwners  = addForkFlagSet.String("o", "", "Comma-separated list of owner email addresses")
+)
+
+// addFork updates the local git repository to include the specified fork.
+func addFork(repo repository.Repo, args []string) error {
+	addForkFlagSet.Parse(args)
+	args = addForkFlagSet.Args()
+
+	var owners []string
+	if len(*addForkOwners) > 0 {
+		for _, owner := range strings.Split(*addForkOwners, ",") {
+			owners = append(owners, strings.TrimSpace(owner))
+		}
+	}
+	if len(args) < 2 {
+		return errors.New("The name and URL of the fork must be specified.")
+	}
+	if len(args) > 2 {
+		return errors.New("Only the name and URL of the fork may be specified.")
+	}
+	if len(owners) == 0 {
+		return errors.New("You must specify at least one owner.")
+	}
+	name := args[0]
+	url := args[1]
+	return fork.Add(repo, fork.New(name, url, owners))
+}
+
+// listForks lists the forks registered in the local git repository.
+func listForks(repo repository.Repo, args []string) error {
+	forks, err := fork.List(repo)
+	if err != nil {
+		return err
+	}
+	output.PrintForks(forks)
+	return nil
+}
+
+// removeFork updates the local git repository to no longer include the specified fork.
+func removeFork(repo repository.Repo, args []string) error {
+	if len(args) < 1 {
+		return errors.New("The name of the fork must be specified.")
+	}
+	if len(args) > 1 {
+		return errors.New("Only the name of the fork may be specified.")
+	}
+	name := args[0]
+	return fork.Delete(repo, name)
+}
+
+// addForkCmd defines the `fork add` command.
+var addForkCmd = &Command{
+	Usage: func(arg0 string) {
+		fmt.Printf("Usage: %s fork add [<option>...] <name> <url>\n\nOptions:\n", arg0)
+		addForkFlagSet.PrintDefaults()
+	},
+	RunMethod: func(repo repository.Repo, args []string) error {
+		return addFork(repo, args)
+	},
+}
+
+// listForksCmd defines the `fork add` command.
+var listForksCmd = &Command{
+	Usage: func(arg0 string) {
+		fmt.Printf("Usage: %s fork list\n", arg0)
+	},
+	RunMethod: func(repo repository.Repo, args []string) error {
+		return listForks(repo, args)
+	},
+}
+
+// removeForkCmd defines the `fork add` command.
+var removeForkCmd = &Command{
+	Usage: func(arg0 string) {
+		fmt.Printf("Usage: %s fork remove <name>\n", arg0)
+	},
+	RunMethod: func(repo repository.Repo, args []string) error {
+		return removeFork(repo, args)
+	},
+}

commands/output/output.go

@@ -23,6 +23,7 @@ import (
 	"strings"
 	"time"
 
+	"github.com/google/git-appraise/fork"
 	"github.com/google/git-appraise/repository"
 	"github.com/google/git-appraise/review"
 )
@@ -61,6 +62,14 @@ status: %s
 `
 	// Number of lines of context to print for inline comments
 	contextLineCount = 5
+	// Template for printing the summary of the forks.
+	forksSummaryTemplate = `%d forks
+`
+	// Template for printing the summary of a code review.
+	forkTemplate = `%q
+  owners: %q
+  urls: %q
+`
 )
 
 // getStatusString returns a human friendly string encapsulating both the review's
@@ -256,3 +265,11 @@ func PrintDiff(r *review.Review, diffArgs ...string) error {
 	fmt.Println(diff)
 	return nil
 }
+
+// PrintForks prints the list of forks.
+func PrintForks(forks []*fork.Fork) {
+	fmt.Printf(forksSummaryTemplate, len(forks))
+	for _, f := range forks {
+		fmt.Printf(forkTemplate, f.Name, f.Owners, f.URLS)
+	}
+}

commands/pull.go

@@ -21,6 +21,7 @@ import (
 	"flag"
 	"fmt"
 
+	"github.com/google/git-appraise/fork"
 	"github.com/google/git-appraise/repository"
 	"github.com/google/git-appraise/review"
 )
@@ -29,6 +30,7 @@ var (
 	pullFlagSet = flag.NewFlagSet("pull", flag.ExitOnError)
 	pullVerify  = pullFlagSet.Bool("verify-signatures", false,
 		"verify the signatures of pulled reviews")
+	pullIncludeForks = pullFlagSet.Bool("include-forks", true, "Also pull reviews and comments from forks.")
 )
 
 // pull updates the local git-notes used for reviews with those from a remote
@@ -38,26 +40,28 @@ func pull(repo repository.Repo, args []string) error {
 	pullArgs := pullFlagSet.Args()
 
 	if len(pullArgs) > 1 {
-		return errors.New(
-			"Only pulling from one remote at a time is supported.")
+		return errors.New("Only pulling from one remote at a time is supported.")
 	}
 
 	remote := "origin"
 	if len(pullArgs) == 1 {
 		remote = pullArgs[0]
 	}
-	// This is the easy case. We're not checking signatures so just go the
-	// normal route.
+
+	if !*pullVerify && !*pullIncludeForks {
+		return repo.PullNotesAndArchive(remote, notesRefPattern, archiveRefPattern)
+	}
 	if !*pullVerify {
-		return repo.PullNotesAndArchive(remote, notesRefPattern,
-			archiveRefPattern)
+		if _, err := repo.PullNotesForksAndArchive(remote, notesRefPattern, fork.Ref, archiveRefPattern); err != nil {
+			return fmt.Errorf("failure pulling review metadata from the remote %q: %v", remote, err)
+		}
+		return fork.Pull(repo, *pullVerify)
 	}
 
-	// Otherwise, we collect the fetched reviewed revisions (their hashes), get
+	// We collect the fetched reviewed revisions (their hashes), get
 	// their reviews, and then one by one, verify them. If we make it through
 	// the set, _then_ we merge the remote reference into the local branch.
-	revisions, err := repo.FetchAndReturnNewReviewHashes(remote,
-		notesRefPattern, archiveRefPattern)
+	revisions, err := repo.FetchAndReturnNewReviewHashes(remote, notesRefPattern, archiveRefPattern)
 	if err != nil {
 		return err
 	}
@@ -74,17 +78,24 @@ func pull(repo repository.Repo, args []string) error {
 		}
 		fmt.Println("verified review:", revision)
 	}
-
-	err = repo.MergeNotes(remote, notesRefPattern)
-	if err != nil {
+	if err := repo.MergeNotes(remote, notesRefPattern); err != nil {
+		return err
+	}
+	if err := repo.MergeArchives(remote, archiveRefPattern); err != nil {
+		return err
+	}
+	if !*pullIncludeForks {
+		return nil
+	}
+	if err := repo.MergeForks(remote, fork.Ref); err != nil {
 		return err
 	}
-	return repo.MergeArchives(remote, archiveRefPattern)
+	return fork.Pull(repo, *pullVerify)
 }
 
 var pullCmd = &Command{
 	Usage: func(arg0 string) {
-		fmt.Printf("Usage: %s pull [<option>] [<remote>]\n\nOptions:\n", arg0)
+		fmt.Printf("Usage: %s pull [<option>...] [<remote>]\n\nOptions:\n", arg0)
 		pullFlagSet.PrintDefaults()
 	},
 	RunMethod: func(repo repository.Repo, args []string) error {