feat(third_party): Check in git-appraise r/10

38 files changed, 7300 insertions, 0 deletions

diff --git a/third_party/go/git-appraise/.gitignore b/third_party/go/git-appraise/.gitignore
new file mode 100644
index 0000000000..385b6eee94
--- /dev/null
+++ b/third_party/go/git-appraise/.gitignore
@@ -0,0 +1,2 @@
+*~
+bin/
diff --git a/third_party/go/git-appraise/CONTRIBUTING.md b/third_party/go/git-appraise/CONTRIBUTING.md
new file mode 100644
index 0000000000..8532a3336e
--- /dev/null
+++ b/third_party/go/git-appraise/CONTRIBUTING.md
@@ -0,0 +1,24 @@
+Want to contribute? Great! First, read this page (including the small print at the end).
+
+### Before you contribute
+Before we can use your code, you must sign the
+[Google Individual Contributor License Agreement](https://developers.google.com/open-source/cla/individual?csw=1)
+(CLA), which you can do online. The CLA is necessary mainly because you own the
+copyright to your changes, even after your contribution becomes part of our
+codebase.  Therefore, we need your permission to use and distribute your code.
+We also need to be sure of various other things—for instance that you'll tell
+us if you know that your code infringes on other people's patents. You don't
+have to sign the CLA until after you've submitted your code for review and a
+member has approved it, but you must do it before we can put your code into our
+codebase. Before you start working on a larger contribution, you should get in
+touch with us first through the issue tracker with your idea so that we can
+help out and possibly guide you. Coordinating up front avoids frustrations later.
+
+### Code reviews
+All submissions, including submissions by project members, require review. You
+may use a Github pull request to start such a review, but the review itself
+will be conducted using this tool.
+
+### The small print
+Contributions made by corporations are covered by a different agreement than
+the one above, the Software Grant and Corporate Contributor License Agreement.
\ No newline at end of file
diff --git a/third_party/go/git-appraise/LICENSE b/third_party/go/git-appraise/LICENSE
new file mode 100644
index 0000000000..d645695673
--- /dev/null
+++ b/third_party/go/git-appraise/LICENSE
@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   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.
diff --git a/third_party/go/git-appraise/README.md b/third_party/go/git-appraise/README.md
new file mode 100644
index 0000000000..0227c41366
--- /dev/null
+++ b/third_party/go/git-appraise/README.md
@@ -0,0 +1,158 @@
+# Distributed Code Review For Git
+[![Build Status](https://travis-ci.org/google/git-appraise.svg?branch=master)](https://travis-ci.org/google/git-appraise)
+
+This repo contains a command line tool for performing code reviews on git
+repositories.
+
+## Overview
+
+This tool is a *distributed* code review system for git repos.
+
+By "distributed", we mean that code reviews are stored inside of the repository
+as git objects. Every developer on your team has their own copy of the review
+history that they can push or pull. When pulling, updates from the remote
+repo are automatically merged by the tool.
+
+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.
+
+## Installation
+
+Assuming you have the [Go tools installed](https://golang.org/doc/install), run
+the following command:
+
+    go get github.com/google/git-appraise/git-appraise
+
+Then, either make sure that `${GOPATH}/bin` is in your PATH, or explicitly add the
+"appraise" git alias by running the following command.
+
+    git config --global alias.appraise '!'"${GOPATH}/bin/git-appraise"
+
+#### Windows:
+
+    git config --global alias.appraise "!%GOPATH%/bin/git-appraise.exe"
+
+## Requirements
+
+This tool expects to run in an environment with the following attributes:
+
+1.  The git command line tool is installed, and included in the PATH.
+2.  The tool is run from within a git repo.
+3.  The git command line tool is configured with the credentials it needs to
+    push to and pull from the remote repos.
+
+## Usage
+
+Requesting a code review:
+
+    git appraise request
+
+Pushing code reviews to a remote:
+
+    git appraise push [<remote>]
+
+Pulling code reviews from a remote:
+
+    git appraise pull [<remote>]
+
+Listing open code reviews:
+
+    git appraise list
+
+Showing the status of the current review, including comments:
+
+    git appraise show
+
+Showing the diff of a review:
+
+    git appraise show --diff [--diff-opts "<diff-options>"] [<review-hash>]
+
+Commenting on a review:
+
+    git appraise comment -m "<message>" [-f <file> [-l <line>]] [<review-hash>]
+
+Accepting the changes in a review:
+
+    git appraise accept [-m "<message>"] [<review-hash>]
+
+Submitting the current review:
+
+    git appraise submit [--merge | --rebase]
+
+A more detailed getting started doc is available [here](docs/tutorial.md).
+
+## Metadata
+
+The code review data is stored in [git-notes](https://git-scm.com/docs/git-notes),
+using the formats described below. Each item stored is written as a single
+line of JSON, and is written with at most one such item per line. This allows
+the git notes to be automatically merged using the "cat\_sort\_uniq" strategy.
+
+Since these notes are not in a human-friendly form, all of the refs used to
+track them start with the prefix "refs/notes/devtools". This helps make it
+clear that these are meant to be read and written by automated tools.
+
+When a field named "v" appears in one of these notes, it is used to denote
+the version of the metadata format being used. If that field is missing, then
+it defaults to the value 0, which corresponds to this initial version of the
+formats.
+
+### Code Review Requests
+
+Code review requests are stored in the "refs/notes/devtools/reviews" ref, and
+annotate the first revision in a review. They must conform to the
+[request schema](schema/request.json).
+
+If there are multiple requests for a single commit, then they are sorted by
+timestamp and the final request is treated as the current one. This sorting
+should be done in a stable manner, so that if there are multiple requests
+with the same timestamp, then the last such request in the note is treated
+as the current one.
+
+This design allows a user to update a review request by re-running the
+`git appraise request` command.
+
+### Continuous Integration Status
+
+Continuous integration build and test results are stored in the
+"refs/notes/devtools/ci" ref, and annotate the revision that was built and
+tested. They must conform to the [ci schema](schema/ci.json).
+
+### Robot Comments
+
+Robot comments are comments generated by static analysis tools. These are
+stored in the "refs/notes/devtools/analyses" ref, and annotate the revision.
+They must conform to the [analysis schema](schema/analysis.json).
+
+### Review Comments
+
+Review comments are comments that were written by a person rather than by a
+machine. These are stored in the "refs/notes/devtools/discuss" ref, and
+annotate the first revision in the review. They must conform to the
+[comment schema](schema/comment.json).
+
+## Integrations
+
+### Libraries
+
+  - [Go (use git-appraise itself)](https://github.com/google/git-appraise/blob/master/review/review.go)
+  - [Rust](https://github.com/Nemo157/git-appraise-rs)
+
+### Graphical User Interfaces
+
+  - [Git-Appraise-Web](https://github.com/google/git-appraise-web)
+
+### Plugins
+
+  - [Eclipse](https://github.com/google/git-appraise-eclipse)
+  - [Jenkins](https://github.com/jenkinsci/google-git-notes-publisher-plugin)
+
+### Mirrors to other systems
+
+  - [GitHub Pull Requests](https://github.com/google/git-pull-request-mirror)
+  - [Phabricator Revisions](https://github.com/google/git-phabricator-mirror)
+
+## Contributing
+
+Please see [the CONTRIBUTING file](CONTRIBUTING.md) for information on contributing to Git Appraise.
diff --git a/third_party/go/git-appraise/commands/abandon.go b/third_party/go/git-appraise/commands/abandon.go
new file mode 100644
index 0000000000..6f408e1663
--- /dev/null
+++ b/third_party/go/git-appraise/commands/abandon.go
@@ -0,0 +1,139 @@
+/*
+Copyright 2015 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"
+
+	"github.com/google/git-appraise/commands/input"
+	"github.com/google/git-appraise/repository"
+	"github.com/google/git-appraise/review"
+	"github.com/google/git-appraise/review/comment"
+	"github.com/google/git-appraise/review/gpg"
+	"github.com/google/git-appraise/review/request"
+)
+
+var abandonFlagSet = flag.NewFlagSet("abandon", flag.ExitOnError)
+
+var (
+	abandonMessageFile = abandonFlagSet.String("F", "", "Take the comment from the given file. Use - to read the message from the standard input")
+	abandonMessage     = abandonFlagSet.String("m", "", "Message to attach to the review")
+
+	abandonSign = abandonFlagSet.Bool("S", false,
+		"Sign the contents of the abandonment")
+)
+
+// abandonReview adds an NMW comment to the current code review.
+func abandonReview(repo repository.Repo, args []string) error {
+	abandonFlagSet.Parse(args)
+	args = abandonFlagSet.Args()
+
+	var r *review.Review
+	var err error
+	if len(args) > 1 {
+		return errors.New("Only abandon a single review is supported.")
+	}
+
+	if len(args) == 1 {
+		r, err = review.Get(repo, args[0])
+	} else {
+		r, err = review.GetCurrent(repo)
+	}
+
+	if err != nil {
+		return fmt.Errorf("Failed to load the review: %v\n", err)
+	}
+	if r == nil {
+		return errors.New("There is no matching review.")
+	}
+
+	if *abandonMessageFile != "" && *abandonMessage == "" {
+		*abandonMessage, err = input.FromFile(*abandonMessageFile)
+		if err != nil {
+			return err
+		}
+	}
+	if *abandonMessageFile == "" && *abandonMessage == "" {
+		*abandonMessage, err = input.LaunchEditor(repo, commentFilename)
+		if err != nil {
+			return err
+		}
+	}
+
+	abandonedCommit, err := r.GetHeadCommit()
+	if err != nil {
+		return err
+	}
+	location := comment.Location{
+		Commit: abandonedCommit,
+	}
+	resolved := false
+	userEmail, err := repo.GetUserEmail()
+	if err != nil {
+		return err
+	}
+	c := comment.New(userEmail, *abandonMessage)
+	c.Location = &location
+	c.Resolved = &resolved
+
+	var key string
+	if *abandonSign {
+		key, err := repo.GetUserSigningKey()
+		if err != nil {
+			return err
+		}
+		err = gpg.Sign(key, &c)
+		if err != nil {
+			return err
+		}
+	}
+
+	err = r.AddComment(c)
+	if err != nil {
+		return err
+	}
+
+	// Empty target ref indicates that request was abandoned
+	r.Request.TargetRef = ""
+	// (re)sign the request after clearing out `TargetRef'.
+	if *abandonSign {
+		err = gpg.Sign(key, &r.Request)
+		if err != nil {
+			return err
+		}
+	}
+
+	note, err := r.Request.Write()
+	if err != nil {
+		return err
+	}
+
+	return repo.AppendNote(request.Ref, r.Revision, note)
+}
+
+// abandonCmd defines the "abandon" subcommand.
+var abandonCmd = &Command{
+	Usage: func(arg0 string) {
+		fmt.Printf("Usage: %s abandon [<option>...] [<commit>]\n\nOptions:\n", arg0)
+		abandonFlagSet.PrintDefaults()
+	},
+	RunMethod: func(repo repository.Repo, args []string) error {
+		return abandonReview(repo, args)
+	},
+}
diff --git a/third_party/go/git-appraise/commands/accept.go b/third_party/go/git-appraise/commands/accept.go
new file mode 100644
index 0000000000..b50f424c25
--- /dev/null
+++ b/third_party/go/git-appraise/commands/accept.go
@@ -0,0 +1,109 @@
+/*
+Copyright 2015 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"
+	"github.com/google/git-appraise/commands/input"
+	"github.com/google/git-appraise/repository"
+	"github.com/google/git-appraise/review"
+	"github.com/google/git-appraise/review/comment"
+	"github.com/google/git-appraise/review/gpg"
+)
+
+var acceptFlagSet = flag.NewFlagSet("accept", flag.ExitOnError)
+
+var (
+	acceptMessageFile = acceptFlagSet.String("F", "", "Take the comment from the given file. Use - to read the message from the standard input")
+	acceptMessage     = acceptFlagSet.String("m", "", "Message to attach to the review")
+
+	acceptSign = acceptFlagSet.Bool("S", false,
+		"sign the contents of the acceptance")
+)
+
+// acceptReview adds an LGTM comment to the current code review.
+func acceptReview(repo repository.Repo, args []string) error {
+	acceptFlagSet.Parse(args)
+	args = acceptFlagSet.Args()
+
+	var r *review.Review
+	var err error
+	if len(args) > 1 {
+		return errors.New("Only accepting a single review is supported.")
+	}
+
+	if len(args) == 1 {
+		r, err = review.Get(repo, args[0])
+	} else {
+		r, err = review.GetCurrent(repo)
+	}
+
+	if err != nil {
+		return fmt.Errorf("Failed to load the review: %v\n", err)
+	}
+	if r == nil {
+		return errors.New("There is no matching review.")
+	}
+
+	acceptedCommit, err := r.GetHeadCommit()
+	if err != nil {
+		return err
+	}
+	location := comment.Location{
+		Commit: acceptedCommit,
+	}
+	resolved := true
+	userEmail, err := repo.GetUserEmail()
+	if err != nil {
+		return err
+	}
+
+	if *acceptMessageFile != "" && *acceptMessage == "" {
+		*acceptMessage, err = input.FromFile(*acceptMessageFile)
+		if err != nil {
+			return err
+		}
+	}
+
+	c := comment.New(userEmail, *acceptMessage)
+	c.Location = &location
+	c.Resolved = &resolved
+	if *acceptSign {
+		key, err := repo.GetUserSigningKey()
+		if err != nil {
+			return err
+		}
+		err = gpg.Sign(key, &c)
+		if err != nil {
+			return err
+		}
+	}
+	return r.AddComment(c)
+}
+
+// acceptCmd defines the "accept" subcommand.
+var acceptCmd = &Command{
+	Usage: func(arg0 string) {
+		fmt.Printf("Usage: %s accept [<option>...] [<commit>]\n\nOptions:\n", arg0)
+		acceptFlagSet.PrintDefaults()
+	},
+	RunMethod: func(repo repository.Repo, args []string) error {
+		return acceptReview(repo, args)
+	},
+}
diff --git a/third_party/go/git-appraise/commands/commands.go b/third_party/go/git-appraise/commands/commands.go
new file mode 100644
index 0000000000..75b8c72d37
--- /dev/null
+++ b/third_party/go/git-appraise/commands/commands.go
@@ -0,0 +1,55 @@
+/*
+Copyright 2015 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 contains the assorted sub commands supported by the git-appraise tool.
+package commands
+
+import (
+	"github.com/google/git-appraise/repository"
+)
+
+const notesRefPattern = "refs/notes/devtools/*"
+const archiveRefPattern = "refs/devtools/archives/*"
+const commentFilename = "APPRAISE_COMMENT_EDITMSG"
+
+// Command represents the definition of a single command.
+type Command struct {
+	Usage     func(string)
+	RunMethod func(repository.Repo, []string) error
+}
+
+// Run executes a command, given its arguments.
+//
+// The args parameter is all of the command line args that followed the
+// subcommand.
+func (cmd *Command) Run(repo repository.Repo, args []string) error {
+	return cmd.RunMethod(repo, args)
+}
+
+// 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,
+}
diff --git a/third_party/go/git-appraise/commands/comment.go b/third_party/go/git-appraise/commands/comment.go
new file mode 100644
index 0000000000..554ac6dc78
--- /dev/null
+++ b/third_party/go/git-appraise/commands/comment.go
@@ -0,0 +1,165 @@
+/*
+Copyright 2015 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"
+
+	"github.com/google/git-appraise/commands/input"
+	"github.com/google/git-appraise/repository"
+	"github.com/google/git-appraise/review"
+	"github.com/google/git-appraise/review/comment"
+	"github.com/google/git-appraise/review/gpg"
+)
+
+var commentFlagSet = flag.NewFlagSet("comment", flag.ExitOnError)
+var commentLocation = comment.Range{}
+
+var (
+	commentMessageFile = commentFlagSet.String("F", "", "Take the comment from the given file. Use - to read the message from the standard input")
+	commentMessage     = commentFlagSet.String("m", "", "Message to attach to the review")
+	commentParent      = commentFlagSet.String("p", "", "Parent comment")
+	commentFile        = commentFlagSet.String("f", "", "File being commented upon")
+	commentLgtm        = commentFlagSet.Bool("lgtm", false, "'Looks Good To Me'. Set this to express your approval. This cannot be combined with nmw")
+	commentNmw         = commentFlagSet.Bool("nmw", false, "'Needs More Work'. Set this to express your disapproval. This cannot be combined with lgtm")
+	commentSign        = commentFlagSet.Bool("S", false,
+		"Sign the contents of the comment")
+)
+
+func init() {
+	commentFlagSet.Var(&commentLocation, "l",
+		`File location to be commented upon; requires that the -f flag also be set.
+Location follows the following format:
+    <START LINE>[+<START COLUMN>][:<END LINE>[+<END COLUMN>]]
+So, in order to comment starting on the 5th character of the 2nd line until (and
+including) the 4th character of the 7th line, use:
+    -l 2+5:7+4`)
+}
+
+// commentHashExists checks if the given comment hash exists in the given comment threads.
+func commentHashExists(hashToFind string, threads []review.CommentThread) bool {
+	for _, thread := range threads {
+		if thread.Hash == hashToFind {
+			return true
+		}
+		if commentHashExists(hashToFind, thread.Children) {
+			return true
+		}
+	}
+	return false
+}
+
+// commentOnReview adds a comment to the current code review.
+func commentOnReview(repo repository.Repo, args []string) error {
+	commentFlagSet.Parse(args)
+	args = commentFlagSet.Args()
+
+	var r *review.Review
+	var err error
+	if len(args) > 1 {
+		return errors.New("Only accepting a single review is supported.")
+	}
+
+	if len(args) == 1 {
+		r, err = review.Get(repo, args[0])
+	} else {
+		r, err = review.GetCurrent(repo)
+	}
+
+	if err != nil {
+		return fmt.Errorf("Failed to load the review: %v\n", err)
+	}
+	if r == nil {
+		return errors.New("There is no matching review.")
+	}
+
+	if *commentLgtm && *commentNmw {
+		return errors.New("You cannot combine the flags -lgtm and -nmw.")
+	}
+	if commentLocation != (comment.Range{}) && *commentFile == "" {
+		return errors.New("Specifying a line number with the -l flag requires that you also specify a file name with the -f flag.")
+	}
+	if *commentParent != "" && !commentHashExists(*commentParent, r.Comments) {
+		return errors.New("There is no matching parent comment.")
+	}
+
+	if *commentMessageFile != "" && *commentMessage == "" {
+		*commentMessage, err = input.FromFile(*commentMessageFile)
+		if err != nil {
+			return err
+		}
+	}
+	if *commentMessageFile == "" && *commentMessage == "" {
+		*commentMessage, err = input.LaunchEditor(repo, commentFilename)
+		if err != nil {
+			return err
+		}
+	}
+
+	commentedUponCommit, err := r.GetHeadCommit()
+	if err != nil {
+		return err
+	}
+	location := comment.Location{
+		Commit: commentedUponCommit,
+	}
+	if *commentFile != "" {
+		location.Path = *commentFile
+		location.Range = &commentLocation
+		if err := location.Check(r.Repo); err != nil {
+			return fmt.Errorf("Unable to comment on the given location: %v", err)
+		}
+	}
+
+	userEmail, err := repo.GetUserEmail()
+	if err != nil {
+		return err
+	}
+	c := comment.New(userEmail, *commentMessage)
+	c.Location = &location
+	c.Parent = *commentParent
+	if *commentLgtm || *commentNmw {
+		resolved := *commentLgtm
+		c.Resolved = &resolved
+	}
+
+	if *commentSign {
+		key, err := repo.GetUserSigningKey()
+		if err != nil {
+			return err
+		}
+		err = gpg.Sign(key, &c)
+		if err != nil {
+			return err
+		}
+	}
+
+	return r.AddComment(c)
+}
+
+// commentCmd defines the "comment" subcommand.
+var commentCmd = &Command{
+	Usage: func(arg0 string) {
+		fmt.Printf("Usage: %s comment [<option>...] [<review-hash>]\n\nOptions:\n", arg0)
+		commentFlagSet.PrintDefaults()
+	},
+	RunMethod: func(repo repository.Repo, args []string) error {
+		return commentOnReview(repo, args)
+	},
+}
diff --git a/third_party/go/git-appraise/commands/input/input.go b/third_party/go/git-appraise/commands/input/input.go
new file mode 100644
index 0000000000..9a8678a827
--- /dev/null
+++ b/third_party/go/git-appraise/commands/input/input.go
@@ -0,0 +1,118 @@
+/*
+Copyright 2015 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 input
+
+import (
+	"bufio"
+	"bytes"
+	"fmt"
+	"github.com/google/git-appraise/repository"
+	"io/ioutil"
+	"os"
+	"os/exec"
+)
+
+// LaunchEditor launches the default editor configured for the given repo. This
+// method blocks until the editor command has returned.
+//
+// The specified filename should be a temporary file and provided as a relative path
+// from the repo (e.g. "FILENAME" will be converted to ".git/FILENAME"). This file
+// will be deleted after the editor is closed and its contents have been read.
+//
+// This method returns the text that was read from the temporary file, or
+// an error if any step in the process failed.
+func LaunchEditor(repo repository.Repo, fileName string) (string, error) {
+	editor, err := repo.GetCoreEditor()
+	if err != nil {
+		return "", fmt.Errorf("Unable to detect default git editor: %v\n", err)
+	}
+
+	path := fmt.Sprintf("%s/.git/%s", repo.GetPath(), fileName)
+
+	cmd, err := startInlineCommand(editor, path)
+	if err != nil {
+		// Running the editor directly did not work. This might mean that
+		// the editor string is not a path to an executable, but rather
+		// a shell command (e.g. "emacsclient --tty"). As such, we'll try
+		// to run the command through bash, and if that fails, try with sh
+		args := []string{"-c", fmt.Sprintf("%s %q", editor, path)}
+		cmd, err = startInlineCommand("bash", args...)
+		if err != nil {
+			cmd, err = startInlineCommand("sh", args...)
+		}
+	}
+	if err != nil {
+		return "", fmt.Errorf("Unable to start editor: %v\n", err)
+	}
+
+	if err := cmd.Wait(); err != nil {
+		return "", fmt.Errorf("Editing finished with error: %v\n", err)
+	}
+
+	output, err := ioutil.ReadFile(path)
+	if err != nil {
+		os.Remove(path)
+		return "", fmt.Errorf("Error reading edited file: %v\n", err)
+	}
+	os.Remove(path)
+	return string(output), err
+}
+
+// FromFile loads and returns the contents of a given file. If - is passed
+// through, much like git, it will read from stdin. This can be piped data,
+// unless there is a tty in which case the user will be prompted to enter a
+// message.
+func FromFile(fileName string) (string, error) {
+	if fileName == "-" {
+		stat, err := os.Stdin.Stat()
+		if err != nil {
+			return "", fmt.Errorf("Error reading from stdin: %v\n", err)
+		}
+		if (stat.Mode() & os.ModeCharDevice) == 0 {
+			// There is no tty. This will allow us to read piped data instead.
+			output, err := ioutil.ReadAll(os.Stdin)
+			if err != nil {
+				return "", fmt.Errorf("Error reading from stdin: %v\n", err)
+			}
+			return string(output), err
+		}
+
+		fmt.Printf("(reading comment from standard input)\n")
+		var output bytes.Buffer
+		s := bufio.NewScanner(os.Stdin)
+		for s.Scan() {
+			output.Write(s.Bytes())
+			output.WriteRune('\n')
+		}
+		return output.String(), nil
+	}
+
+	output, err := ioutil.ReadFile(fileName)
+	if err != nil {
+		return "", fmt.Errorf("Error reading file: %v\n", err)
+	}
+	return string(output), err
+}
+
+func startInlineCommand(command string, args ...string) (*exec.Cmd, error) {
+	cmd := exec.Command(command, args...)
+	cmd.Stdin = os.Stdin
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+	err := cmd.Start()
+	return cmd, err
+}
diff --git a/third_party/go/git-appraise/commands/list.go b/third_party/go/git-appraise/commands/list.go
new file mode 100644
index 0000000000..cc9338dd7e
--- /dev/null
+++ b/third_party/go/git-appraise/commands/list.go
@@ -0,0 +1,74 @@
+/*
+Copyright 2015 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 (
+	"encoding/json"
+	"flag"
+	"fmt"
+	"github.com/google/git-appraise/commands/output"
+	"github.com/google/git-appraise/repository"
+	"github.com/google/git-appraise/review"
+)
+
+var listFlagSet = flag.NewFlagSet("list", flag.ExitOnError)
+
+var (
+	listAll        = listFlagSet.Bool("a", false, "List all reviews (not just the open ones).")
+	listJSONOutput = listFlagSet.Bool("json", false, "Format the output as JSON")
+)
+
+// listReviews lists all extant reviews.
+// TODO(ojarjur): Add more flags for filtering the output (e.g. filtering by reviewer or status).
+func listReviews(repo repository.Repo, args []string) error {
+	listFlagSet.Parse(args)
+	var reviews []review.Summary
+	if *listAll {
+		reviews = review.ListAll(repo)
+		if !*listJSONOutput {
+			fmt.Printf("Loaded %d reviews:\n", len(reviews))
+		}
+	} else {
+		reviews = review.ListOpen(repo)
+		if !*listJSONOutput {
+			fmt.Printf("Loaded %d open reviews:\n", len(reviews))
+		}
+	}
+	if *listJSONOutput {
+		b, err := json.MarshalIndent(reviews, "", "  ")
+		if err != nil {
+			return err
+		}
+		fmt.Println(string(b))
+		return nil
+	}
+	for _, r := range reviews {
+		output.PrintSummary(&r)
+	}
+	return nil
+}
+
+// listCmd defines the "list" subcommand.
+var listCmd = &Command{
+	Usage: func(arg0 string) {
+		fmt.Printf("Usage: %s list [<option>...]\n\nOptions:\n", arg0)
+		listFlagSet.PrintDefaults()
+	},
+	RunMethod: func(repo repository.Repo, args []string) error {
+		return listReviews(repo, args)
+	},
+}
diff --git a/third_party/go/git-appraise/commands/output/output.go b/third_party/go/git-appraise/commands/output/output.go
new file mode 100644
index 0000000000..4613cd3857
--- /dev/null
+++ b/third_party/go/git-appraise/commands/output/output.go
@@ -0,0 +1,216 @@
+/*
+Copyright 2015 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 output contains helper methods for pretty-printing code reviews.
+package output
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/google/git-appraise/review"
+)
+
+const (
+	// Template for printing the summary of a code review.
+	reviewSummaryTemplate = `[%s] %.12s
+  %s
+`
+	// Template for printing the summary of a code review.
+	reviewDetailsTemplate = `  %q -> %q
+  reviewers: %q
+  requester: %q
+  build status: %s
+`
+	// Template for printing the location of an inline comment
+	commentLocationTemplate = `%s%q@%.12s
+`
+	// Template for printing a single comment.
+	commentTemplate = `comment: %s
+author: %s
+time:   %s
+status: %s
+%s`
+	// Template for displaying the summary of the comment threads for a review
+	commentSummaryTemplate = `  comments (%d threads):
+`
+	// Number of lines of context to print for inline comments
+	contextLineCount = 5
+)
+
+// getStatusString returns a human friendly string encapsulating both the review's
+// resolved status, and its submitted status.
+func getStatusString(r *review.Summary) string {
+	if r.Resolved == nil && r.Submitted {
+		return "tbr"
+	}
+	if r.Resolved == nil {
+		return "pending"
+	}
+	if *r.Resolved && r.Submitted {
+		return "submitted"
+	}
+	if *r.Resolved {
+		return "accepted"
+	}
+	if r.Submitted {
+		return "danger"
+	}
+	if r.Request.TargetRef == "" {
+		return "abandon"
+	}
+	return "rejected"
+}
+
+// PrintSummary prints a single-line summary of a review.
+func PrintSummary(r *review.Summary) {
+	statusString := getStatusString(r)
+	indentedDescription := strings.Replace(r.Request.Description, "\n", "\n  ", -1)
+	fmt.Printf(reviewSummaryTemplate, statusString, r.Revision, indentedDescription)
+}
+
+// reformatTimestamp takes a timestamp string of the form "0123456789" and changes it
+// to the form "Mon Jan _2 13:04:05 UTC 2006".
+//
+// Timestamps that are not in the format we expect are left alone.
+func reformatTimestamp(timestamp string) string {
+	parsedTimestamp, err := strconv.ParseInt(timestamp, 10, 64)
+	if err != nil {
+		// The timestamp is an unexpected format, so leave it alone
+		return timestamp
+	}
+	t := time.Unix(parsedTimestamp, 0)
+	return t.Format(time.UnixDate)
+}
+
+// showThread prints the detailed output for an entire comment thread.
+func showThread(r *review.Review, thread review.CommentThread) error {
+	comment := thread.Comment
+	indent := "    "
+	if comment.Location != nil && comment.Location.Path != "" && comment.Location.Range != nil && comment.Location.Range.StartLine > 0 {
+		contents, err := r.Repo.Show(comment.Location.Commit, comment.Location.Path)
+		if err != nil {
+			return err
+		}
+		lines := strings.Split(contents, "\n")
+		err = comment.Location.Check(r.Repo)
+		if err != nil {
+			return err
+		}
+		if comment.Location.Range.StartLine <= uint32(len(lines)) {
+			firstLine := comment.Location.Range.StartLine
+			lastLine := comment.Location.Range.EndLine
+
+			if firstLine == 0 {
+				firstLine = 1
+			}
+
+			if lastLine == 0 {
+				lastLine = firstLine
+			}
+
+			if lastLine == firstLine {
+				minLine := int(lastLine) - int(contextLineCount)
+				if minLine <= 0 {
+					minLine = 1
+				}
+				firstLine = uint32(minLine)
+			}
+
+			fmt.Printf(commentLocationTemplate, indent, comment.Location.Path, comment.Location.Commit)
+			fmt.Println(indent + "|" + strings.Join(lines[firstLine-1:lastLine], "\n"+indent+"|"))
+		}
+	}
+	return showSubThread(r, thread, indent)
+}
+
+// showSubThread prints the given comment (sub)thread, indented by the given prefix string.
+func showSubThread(r *review.Review, thread review.CommentThread, indent string) error {
+	statusString := "fyi"
+	if thread.Resolved != nil {
+		if *thread.Resolved {
+			statusString = "lgtm"
+		} else {
+			statusString = "needs work"
+		}
+	}
+	comment := thread.Comment
+	threadHash := thread.Hash
+	timestamp := reformatTimestamp(comment.Timestamp)
+	commentSummary := fmt.Sprintf(indent+commentTemplate, threadHash, comment.Author, timestamp, statusString, comment.Description)
+	indent = indent + "  "
+	indentedSummary := strings.Replace(commentSummary, "\n", "\n"+indent, -1)
+	fmt.Println(indentedSummary)
+	for _, child := range thread.Children {
+		err := showSubThread(r, child, indent)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// printAnalyses prints the static analysis results for the latest commit in the review.
+func printAnalyses(r *review.Review) {
+	fmt.Println("  analyses: ", r.GetAnalysesMessage())
+}
+
+// printComments prints all of the comments for the review, with snippets of the preceding source code.
+func printComments(r *review.Review) error {
+	fmt.Printf(commentSummaryTemplate, len(r.Comments))
+	for _, thread := range r.Comments {
+		err := showThread(r, thread)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// PrintDetails prints a multi-line overview of a review, including all comments.
+func PrintDetails(r *review.Review) error {
+	PrintSummary(r.Summary)
+	fmt.Printf(reviewDetailsTemplate, r.Request.ReviewRef, r.Request.TargetRef,
+		strings.Join(r.Request.Reviewers, ", "),
+		r.Request.Requester, r.GetBuildStatusMessage())
+	printAnalyses(r)
+	if err := printComments(r); err != nil {
+		return err
+	}
+	return nil
+}
+
+// PrintJSON pretty prints the given review in JSON format.
+func PrintJSON(r *review.Review) error {
+	json, err := r.GetJSON()
+	if err != nil {
+		return err
+	}
+	fmt.Println(json)
+	return nil
+}
+
+// PrintDiff prints the diff of the review.
+func PrintDiff(r *review.Review, diffArgs ...string) error {
+	diff, err := r.GetDiff(diffArgs...)
+	if err != nil {
+		return err
+	}
+	fmt.Println(diff)
+	return nil
+}
diff --git a/third_party/go/git-appraise/commands/pull.go b/third_party/go/git-appraise/commands/pull.go
new file mode 100644
index 0000000000..809c20fdbb
--- /dev/null
+++ b/third_party/go/git-appraise/commands/pull.go
@@ -0,0 +1,93 @@
+/*
+Copyright 2015 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"
+
+	"github.com/google/git-appraise/repository"
+	"github.com/google/git-appraise/review"
+)
+
+var (
+	pullFlagSet = flag.NewFlagSet("pull", flag.ExitOnError)
+	pullVerify  = pullFlagSet.Bool("verify-signatures", false,
+		"verify the signatures of pulled reviews")
+)
+
+// pull updates the local git-notes used for reviews with those from a remote
+// repo.
+func pull(repo repository.Repo, args []string) error {
+	pullFlagSet.Parse(args)
+	pullArgs := pullFlagSet.Args()
+
+	if len(pullArgs) > 1 {
+		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 {
+		return repo.PullNotesAndArchive(remote, notesRefPattern,
+			archiveRefPattern)
+	}
+
+	// Otherwise, 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)
+	if err != nil {
+		return err
+	}
+	for _, revision := range revisions {
+		rvw, err := review.GetSummaryViaRefs(repo,
+			"refs/notes/"+remote+"/devtools/reviews",
+			"refs/notes/"+remote+"/devtools/discuss", revision)
+		if err != nil {
+			return err
+		}
+		err = rvw.Verify()
+		if err != nil {
+			return err
+		}
+		fmt.Println("verified review:", revision)
+	}
+
+	err = repo.MergeNotes(remote, notesRefPattern)
+	if err != nil {
+		return err
+	}
+	return repo.MergeArchives(remote, archiveRefPattern)
+}
+
+var pullCmd = &Command{
+	Usage: func(arg0 string) {
+		fmt.Printf("Usage: %s pull [<option>] [<remote>]\n\nOptions:\n", arg0)
+		pullFlagSet.PrintDefaults()
+	},
+	RunMethod: func(repo repository.Repo, args []string) error {
+		return pull(repo, args)
+	},
+}
diff --git a/third_party/go/git-appraise/commands/push.go b/third_party/go/git-appraise/commands/push.go
new file mode 100644
index 0000000000..c75a25eac7
--- /dev/null
+++ b/third_party/go/git-appraise/commands/push.go
@@ -0,0 +1,49 @@
+/*
+Copyright 2015 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"
+	"fmt"
+	"github.com/google/git-appraise/repository"
+)
+
+// push pushes the local git-notes used for reviews to a remote repo.
+func push(repo repository.Repo, args []string) error {
+	if len(args) > 1 {
+		return errors.New("Only pushing to one remote at a time is supported.")
+	}
+
+	remote := "origin"
+	if len(args) == 1 {
+		remote = args[0]
+	}
+
+	if err := repo.PushNotesAndArchive(remote, notesRefPattern, archiveRefPattern); err != nil {
+		return err
+	}
+	return nil
+}
+
+var pushCmd = &Command{
+	Usage: func(arg0 string) {
+		fmt.Printf("Usage: %s push [<remote>]\n", arg0)
+	},
+	RunMethod: func(repo repository.Repo, args []string) error {
+		return push(repo, args)
+	},
+}
diff --git a/third_party/go/git-appraise/commands/rebase.go b/third_party/go/git-appraise/commands/rebase.go
new file mode 100644
index 0000000000..2c4595a576
--- /dev/null
+++ b/third_party/go/git-appraise/commands/rebase.go
@@ -0,0 +1,100 @@
+/*
+Copyright 2016 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"
+
+	"github.com/google/git-appraise/repository"
+	"github.com/google/git-appraise/review"
+)
+
+var rebaseFlagSet = flag.NewFlagSet("rebase", flag.ExitOnError)
+
+var (
+	rebaseArchive = rebaseFlagSet.Bool("archive", true, "Prevent the original commit from being garbage collected.")
+	rebaseSign    = rebaseFlagSet.Bool("S", false,
+		"Sign the contents of the request after the rebase")
+)
+
+// Validate that the user's request to rebase a review makes sense.
+//
+// This checks both that the request is well formed, and that the
+// corresponding review is in a state where rebasing is appropriate.
+func validateRebaseRequest(repo repository.Repo, args []string) (*review.Review, error) {
+	var r *review.Review
+	var err error
+	if len(args) > 1 {
+		return nil, errors.New("Only rebasing a single review is supported.")
+	}
+	if len(args) == 1 {
+		r, err = review.Get(repo, args[0])
+	} else {
+		r, err = review.GetCurrent(repo)
+	}
+	if err != nil {
+		return nil, fmt.Errorf("Failed to load the review: %v\n", err)
+	}
+	if r == nil {
+		return nil, errors.New("There is no matching review.")
+	}
+
+	if r.Submitted {
+		return nil, errors.New("The review has already been submitted.")
+	}
+
+	if r.Request.TargetRef == "" {
+		return nil, errors.New("The review was abandoned.")
+	}
+
+	target := r.Request.TargetRef
+	if err := repo.VerifyGitRef(target); err != nil {
+		return nil, err
+	}
+
+	return r, nil
+}
+
+// Rebase the current code review.
+//
+// The "args" parameter contains all of the command line arguments that followed the subcommand.
+func rebaseReview(repo repository.Repo, args []string) error {
+	rebaseFlagSet.Parse(args)
+	args = rebaseFlagSet.Args()
+
+	r, err := validateRebaseRequest(repo, args)
+	if err != nil {
+		return err
+	}
+	if *rebaseSign {
+		return r.RebaseAndSign(*rebaseArchive)
+	}
+	return r.Rebase(*rebaseArchive)
+}
+
+// rebaseCmd defines the "rebase" subcommand.
+var rebaseCmd = &Command{
+	Usage: func(arg0 string) {
+		fmt.Printf("Usage: %s rebase [<option>...] [<review-hash>]\n\nOptions:\n", arg0)
+		rebaseFlagSet.PrintDefaults()
+	},
+	RunMethod: func(repo repository.Repo, args []string) error {
+		return rebaseReview(repo, args)
+	},
+}
diff --git a/third_party/go/git-appraise/commands/reject.go b/third_party/go/git-appraise/commands/reject.go
new file mode 100644
index 0000000000..e0e45babf8
--- /dev/null
+++ b/third_party/go/git-appraise/commands/reject.go
@@ -0,0 +1,119 @@
+/*
+Copyright 2015 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"
+
+	"github.com/google/git-appraise/commands/input"
+	"github.com/google/git-appraise/repository"
+	"github.com/google/git-appraise/review"
+	"github.com/google/git-appraise/review/comment"
+	"github.com/google/git-appraise/review/gpg"
+)
+
+var rejectFlagSet = flag.NewFlagSet("reject", flag.ExitOnError)
+
+var (
+	rejectMessageFile = rejectFlagSet.String("F", "", "Take the comment from the given file. Use - to read the message from the standard input")
+	rejectMessage     = rejectFlagSet.String("m", "", "Message to attach to the review")
+
+	rejectSign = rejectFlagSet.Bool("S", false,
+		"Sign the contents of the rejection")
+)
+
+// rejectReview adds an NMW comment to the current code review.
+func rejectReview(repo repository.Repo, args []string) error {
+	rejectFlagSet.Parse(args)
+	args = rejectFlagSet.Args()
+
+	var r *review.Review
+	var err error
+	if len(args) > 1 {
+		return errors.New("Only rejecting a single review is supported.")
+	}
+
+	if len(args) == 1 {
+		r, err = review.Get(repo, args[0])
+	} else {
+		r, err = review.GetCurrent(repo)
+	}
+
+	if err != nil {
+		return fmt.Errorf("Failed to load the review: %v\n", err)
+	}
+	if r == nil {
+		return errors.New("There is no matching review.")
+	}
+
+	if r.Request.TargetRef == "" {
+		return errors.New("The review was abandoned.")
+	}
+
+	if *rejectMessageFile != "" && *rejectMessage == "" {
+		*rejectMessage, err = input.FromFile(*rejectMessageFile)
+		if err != nil {
+			return err
+		}
+	}
+	if *rejectMessageFile == "" && *rejectMessage == "" {
+		*rejectMessage, err = input.LaunchEditor(repo, commentFilename)
+		if err != nil {
+			return err
+		}
+	}
+
+	rejectedCommit, err := r.GetHeadCommit()
+	if err != nil {
+		return err
+	}
+	location := comment.Location{
+		Commit: rejectedCommit,
+	}
+	resolved := false
+	userEmail, err := repo.GetUserEmail()
+	if err != nil {
+		return err
+	}
+	c := comment.New(userEmail, *rejectMessage)
+	c.Location = &location
+	c.Resolved = &resolved
+	if *rejectSign {
+		key, err := repo.GetUserSigningKey()
+		if err != nil {
+			return err
+		}
+		err = gpg.Sign(key, &c)
+		if err != nil {
+			return err
+		}
+	}
+	return r.AddComment(c)
+}
+
+// rejectCmd defines the "reject" subcommand.
+var rejectCmd = &Command{
+	Usage: func(arg0 string) {
+		fmt.Printf("Usage: %s reject [<option>...] [<commit>]\n\nOptions:\n", arg0)
+		rejectFlagSet.PrintDefaults()
+	},
+	RunMethod: func(repo repository.Repo, args []string) error {
+		return rejectReview(repo, args)
+	},
+}
diff --git a/third_party/go/git-appraise/commands/request.go b/third_party/go/git-appraise/commands/request.go
new file mode 100644
index 0000000000..9a9854c3f8
--- /dev/null
+++ b/third_party/go/git-appraise/commands/request.go
@@ -0,0 +1,182 @@
+/*
+Copyright 2015 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/input"
+	"github.com/google/git-appraise/repository"
+	"github.com/google/git-appraise/review/gpg"
+	"github.com/google/git-appraise/review/request"
+)
+
+// Template for the "request" subcommand's output.
+const requestSummaryTemplate = `Review requested:
+Commit: %s
+Target Ref: %s
+Review Ref: %s
+Message: "%s"
+`
+
+var requestFlagSet = flag.NewFlagSet("request", flag.ExitOnError)
+
+var (
+	requestMessageFile      = requestFlagSet.String("F", "", "Take the comment from the given file. Use - to read the message from the standard input")
+	requestMessage          = requestFlagSet.String("m", "", "Message to attach to the review")
+	requestReviewers        = requestFlagSet.String("r", "", "Comma-separated list of reviewers")
+	requestSource           = requestFlagSet.String("source", "HEAD", "Revision to review")
+	requestTarget           = requestFlagSet.String("target", "refs/heads/master", "Revision against which to review")
+	requestQuiet            = requestFlagSet.Bool("quiet", false, "Suppress review summary output")
+	requestAllowUncommitted = requestFlagSet.Bool("allow-uncommitted", false, "Allow uncommitted local changes.")
+	requestSign             = requestFlagSet.Bool("S", false,
+		"GPG sign the content of the request")
+)
+
+// Build the template review request based solely on the parsed flag values.
+func buildRequestFromFlags(requester string) (request.Request, error) {
+	var reviewers []string
+	if len(*requestReviewers) > 0 {
+		for _, reviewer := range strings.Split(*requestReviewers, ",") {
+			reviewers = append(reviewers, strings.TrimSpace(reviewer))
+		}
+	}
+	if *requestMessageFile != "" && *requestMessage == "" {
+		var err error
+		*requestMessage, err = input.FromFile(*requestMessageFile)
+		if err != nil {
+			return request.Request{}, err
+		}
+	}
+
+	return request.New(requester, reviewers, *requestSource, *requestTarget, *requestMessage), nil
+}
+
+// Get the commit at which the review request should be anchored.
+func getReviewCommit(repo repository.Repo, r request.Request, args []string) (string, string, error) {
+	if len(args) > 1 {
+		return "", "", errors.New("Only updating a single review is supported.")
+	}
+	if len(args) == 1 {
+		base, err := repo.MergeBase(r.TargetRef, args[0])
+		if err != nil {
+			return "", "", err
+		}
+		return args[0], base, nil
+	}
+
+	base, err := repo.MergeBase(r.TargetRef, r.ReviewRef)
+	if err != nil {
+		return "", "", err
+	}
+	reviewCommits, err := repo.ListCommitsBetween(base, r.ReviewRef)
+	if err != nil {
+		return "", "", err
+	}
+	if reviewCommits == nil {
+		return "", "", errors.New("There are no commits included in the review request")
+	}
+	return reviewCommits[0], base, nil
+}
+
+// Create a new code review request.
+//
+// The "args" parameter is all of the command line arguments that followed the subcommand.
+func requestReview(repo repository.Repo, args []string) error {
+	requestFlagSet.Parse(args)
+	args = requestFlagSet.Args()
+
+	if !*requestAllowUncommitted {
+		// Requesting a code review with uncommited local changes is usually a mistake, so
+		// we want to report that to the user instead of creating the request.
+		hasUncommitted, err := repo.HasUncommittedChanges()
+		if err != nil {
+			return err
+		}
+		if hasUncommitted {
+			return errors.New("You have uncommitted or untracked files. Use --allow-uncommitted to ignore those.")
+		}
+	}
+
+	userEmail, err := repo.GetUserEmail()
+	if err != nil {
+		return err
+	}
+	r, err := buildRequestFromFlags(userEmail)
+	if err != nil {
+		return err
+	}
+	if r.ReviewRef == "HEAD" {
+		headRef, err := repo.GetHeadRef()
+		if err != nil {
+			return err
+		}
+		r.ReviewRef = headRef
+	}
+	if err := repo.VerifyGitRef(r.TargetRef); err != nil {
+		return err
+	}
+	if err := repo.VerifyGitRef(r.ReviewRef); err != nil {
+		return err
+	}
+
+	reviewCommit, baseCommit, err := getReviewCommit(repo, r, args)
+	if err != nil {
+		return err
+	}
+	r.BaseCommit = baseCommit
+	if r.Description == "" {
+		description, err := repo.GetCommitMessage(reviewCommit)
+		if err != nil {
+			return err
+		}
+		r.Description = description
+	}
+	if *requestSign {
+		key, err := repo.GetUserSigningKey()
+		if err != nil {
+			return err
+		}
+		err = gpg.Sign(key, &r)
+		if err != nil {
+			return err
+		}
+	}
+	note, err := r.Write()
+	if err != nil {
+		return err
+	}
+	repo.AppendNote(request.Ref, reviewCommit, note)
+	if !*requestQuiet {
+		fmt.Printf(requestSummaryTemplate, reviewCommit, r.TargetRef, r.ReviewRef, r.Description)
+	}
+	return nil
+}
+
+// requestCmd defines the "request" subcommand.
+var requestCmd = &Command{
+	Usage: func(arg0 string) {
+		fmt.Printf("Usage: %s request [<option>...] [<review-hash>]\n\nOptions:\n", arg0)
+		requestFlagSet.PrintDefaults()
+	},
+	RunMethod: func(repo repository.Repo, args []string) error {
+		return requestReview(repo, args)
+	},
+}
diff --git a/third_party/go/git-appraise/commands/request_test.go b/third_party/go/git-appraise/commands/request_test.go
new file mode 100644
index 0000000000..3e09892e57
--- /dev/null
+++ b/third_party/go/git-appraise/commands/request_test.go
@@ -0,0 +1,36 @@
+/*
+Copyright 2015 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 (
+	"testing"
+)
+
+func TestBuildRequestFromFlags(t *testing.T) {
+	args := []string{"-m", "Request message", "-r", "Me, Myself, \nAnd I "}
+	requestFlagSet.Parse(args)
+	r, err := buildRequestFromFlags("user@hostname.com")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if r.Description != "Request message" {
+		t.Fatalf("Unexpected request description: '%s'", r.Description)
+	}
+	if r.Reviewers == nil || len(r.Reviewers) != 3 || r.Reviewers[0] != "Me" || r.Reviewers[1] != "Myself" || r.Reviewers[2] != "And I" {
+		t.Fatalf("Unexpected reviewers list: '%v'", r.Reviewers)
+	}
+}
diff --git a/third_party/go/git-appraise/commands/show.go b/third_party/go/git-appraise/commands/show.go
new file mode 100644
index 0000000000..9eb57dd093
--- /dev/null
+++ b/third_party/go/git-appraise/commands/show.go
@@ -0,0 +1,85 @@
+/*
+Copyright 2015 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"
+	"github.com/google/git-appraise/commands/output"
+	"github.com/google/git-appraise/repository"
+	"github.com/google/git-appraise/review"
+	"strings"
+)
+
+var showFlagSet = flag.NewFlagSet("show", flag.ExitOnError)
+
+var (
+	showJSONOutput  = showFlagSet.Bool("json", false, "Format the output as JSON")
+	showDiffOutput  = showFlagSet.Bool("diff", false, "Show the current diff for the review")
+	showDiffOptions = showFlagSet.String("diff-opts", "", "Options to pass to the diff tool; can only be used with the --diff option")
+)
+
+// showReview prints the current code review.
+func showReview(repo repository.Repo, args []string) error {
+	showFlagSet.Parse(args)
+	args = showFlagSet.Args()
+	if *showDiffOptions != "" && !*showDiffOutput {
+		return errors.New("The --diff-opts flag can only be used if the --diff flag is set.")
+	}
+
+	var r *review.Review
+	var err error
+	if len(args) > 1 {
+		return errors.New("Only showing a single review is supported.")
+	}
+
+	if len(args) == 1 {
+		r, err = review.Get(repo, args[0])
+	} else {
+		r, err = review.GetCurrent(repo)
+	}
+
+	if err != nil {
+		return fmt.Errorf("Failed to load the review: %v\n", err)
+	}
+	if r == nil {
+		return errors.New("There is no matching review.")
+	}
+	if *showJSONOutput {
+		return output.PrintJSON(r)
+	}
+	if *showDiffOutput {
+		var diffArgs []string
+		if *showDiffOptions != "" {
+			diffArgs = strings.Split(*showDiffOptions, ",")
+		}
+		return output.PrintDiff(r, diffArgs...)
+	}
+	return output.PrintDetails(r)
+}
+
+// showCmd defines the "show" subcommand.
+var showCmd = &Command{
+	Usage: func(arg0 string) {
+		fmt.Printf("Usage: %s show [<option>...] [<commit>]\n\nOptions:\n", arg0)
+		showFlagSet.PrintDefaults()
+	},
+	RunMethod: func(repo repository.Repo, args []string) error {
+		return showReview(repo, args)
+	},
+}
diff --git a/third_party/go/git-appraise/commands/submit.go b/third_party/go/git-appraise/commands/submit.go
new file mode 100644
index 0000000000..58fa002350
--- /dev/null
+++ b/third_party/go/git-appraise/commands/submit.go
@@ -0,0 +1,157 @@
+/*
+Copyright 2015 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"
+	"github.com/google/git-appraise/repository"
+	"github.com/google/git-appraise/review"
+)
+
+var submitFlagSet = flag.NewFlagSet("submit", flag.ExitOnError)
+
+var (
+	submitMerge       = submitFlagSet.Bool("merge", false, "Create a merge of the source and target refs.")
+	submitRebase      = submitFlagSet.Bool("rebase", false, "Rebase the source ref onto the target ref.")
+	submitFastForward = submitFlagSet.Bool("fast-forward", false, "Create a merge using the default fast-forward mode.")
+	submitTBR         = submitFlagSet.Bool("tbr", false, "(To be reviewed) Force the submission of a review that has not been accepted.")
+	submitArchive     = submitFlagSet.Bool("archive", true, "Prevent the original commit from being garbage collected; only affects rebased submits.")
+
+	submitSign = submitFlagSet.Bool("S", false,
+		"Sign the contents of the submission")
+)
+
+// Submit the current code review request.
+//
+// The "args" parameter contains all of the command line arguments that followed the subcommand.
+func submitReview(repo repository.Repo, args []string) error {
+	submitFlagSet.Parse(args)
+	args = submitFlagSet.Args()
+
+	if *submitMerge && *submitRebase {
+		return errors.New("Only one of --merge or --rebase is allowed.")
+	}
+
+	var r *review.Review
+	var err error
+	if len(args) > 1 {
+		return errors.New("Only accepting a single review is supported.")
+	}
+	if len(args) == 1 {
+		r, err = review.Get(repo, args[0])
+	} else {
+		r, err = review.GetCurrent(repo)
+	}
+
+	if err != nil {
+		return fmt.Errorf("Failed to load the review: %v\n", err)
+	}
+	if r == nil {
+		return errors.New("There is no matching review.")
+	}
+
+	if r.Submitted {
+		return errors.New("The review has already been submitted.")
+	}
+
+	if !*submitTBR && (r.Resolved == nil || !*r.Resolved) {
+		return errors.New("Not submitting as the review has not yet been accepted.")
+	}
+
+	target := r.Request.TargetRef
+	if err := repo.VerifyGitRef(target); err != nil {
+		return err
+	}
+	source, err := r.GetHeadCommit()
+	if err != nil {
+		return err
+	}
+
+	isAncestor, err := repo.IsAncestor(target, source)
+	if err != nil {
+		return err
+	}
+	if !isAncestor {
+		return errors.New("Refusing to submit a non-fast-forward review. First merge the target ref.")
+	}
+
+	if !(*submitRebase || *submitMerge || *submitFastForward) {
+		submitStrategy, err := repo.GetSubmitStrategy()
+		if err != nil {
+			return err
+		}
+		if submitStrategy == "merge" && !*submitRebase && !*submitFastForward {
+			*submitMerge = true
+		}
+		if submitStrategy == "rebase" && !*submitMerge && !*submitFastForward {
+			*submitRebase = true
+		}
+		if submitStrategy == "fast-forward" && !*submitRebase && !*submitMerge {
+			*submitFastForward = true
+		}
+	}
+
+	if *submitRebase {
+		var err error
+		if *submitSign {
+			err = r.RebaseAndSign(*submitArchive)
+		} else {
+			err = r.Rebase(*submitArchive)
+		}
+		if err != nil {
+			return err
+		}
+
+		source, err = r.GetHeadCommit()
+		if err != nil {
+			return err
+		}
+	}
+
+	if err := repo.SwitchToRef(target); err != nil {
+		return err
+	}
+	if *submitMerge {
+		submitMessage := fmt.Sprintf("Submitting review %.12s", r.Revision)
+		if *submitSign {
+			return repo.MergeAndSignRef(source, false, submitMessage,
+				r.Request.Description)
+		} else {
+			return repo.MergeRef(source, false, submitMessage,
+				r.Request.Description)
+		}
+	} else {
+		if *submitSign {
+			return repo.MergeAndSignRef(source, true)
+		} else {
+			return repo.MergeRef(source, true)
+		}
+	}
+}
+
+// submitCmd defines the "submit" subcommand.
+var submitCmd = &Command{
+	Usage: func(arg0 string) {
+		fmt.Printf("Usage: %s submit [<option>...] [<review-hash>]\n\nOptions:\n", arg0)
+		submitFlagSet.PrintDefaults()
+	},
+	RunMethod: func(repo repository.Repo, args []string) error {
+		return submitReview(repo, args)
+	},
+}
diff --git a/third_party/go/git-appraise/docs/tutorial.md b/third_party/go/git-appraise/docs/tutorial.md
new file mode 100644
index 0000000000..6f95bb7e2f
--- /dev/null
+++ b/third_party/go/git-appraise/docs/tutorial.md
@@ -0,0 +1,404 @@
+# Getting started with git-appraise
+
+This file gives an example code-review workflow using git-appraise. It starts
+with cloning a repository and goes all the way through to browsing
+your submitted commits.
+
+The git-appraise tool is largely agnostic of what workflow you use, so feel
+free to change things to your liking, but this particular workflow should help
+you get started.
+
+## Cloning your repository
+
+Since you're using a code review tool, we'll assume that you have a URL that
+you can push to and pull from in order to collaborate with the rest of your team.
+
+First we'll create our local clone of the repository:
+```shell
+git clone ${URL} example-repo
+cd example-repo
+```
+
+If you are starting from an empty repository, then it's a good practice to add a
+README file explaining the purpose of the repository:
+
+```shell
+echo '# Example Repository' > README.md
+git add README.md
+git commit -m 'Added a README file to the repo'
+git push
+```
+
+## Creating our first review
+
+Generally, reviews in git-appraise are used to decide if the code in one branch
+(called the "source") is ready to merge into another branch (called the
+"target"). The meaning of each branch and the policies around merging into a
+branch vary from team to team, but for this example we'll use a simple practice
+called [GitHub Flow](https://guides.github.com/introduction/flow/).
+
+Specifically, we'll create a new branch for a particular feature, review the
+changes to that branch against our master branch, and then delete the feature
+branch once we are done.
+
+### Creating our change
+
+Create the feature branch:
+```shell
+git checkout -b ${USER}/getting-started
+git push --set-upstream origin ${USER}/getting-started
+```
+
+... And make some changes to it:
+```shell
+echo "This is an example repository used for coming up to speed" >> README.md
+git commit -a -m "Added an explanation to the README file"
+git push
+```
+
+### Requesting the review
+
+Up to this point we've only used the regular commands that come with git. Now,
+we will use git-appraise to perform a review:
+
+Request a review:
+```shell
+git appraise request
+```
+
+The output of this will be a summary of the newly requested review:
+```
+Review requested:
+Commit: 1e6eb14c8014593843c5b5f29377585e4ed55304
+Target Ref: refs/heads/master
+Review Ref: refs/heads/ojarjur/getting-started
+Message: "Added an explanation to the README file"
+```
+
+Show the details of the current review:
+```shell
+git appraise show
+```
+
+```
+[pending] 1e6eb14c8014
+  Added an explanation to the README file
+  "refs/heads/ojarjur/getting-started" -> "refs/heads/master"
+  reviewers: ""
+  requester: "ojarjur@google.com"
+  build status: unknown
+  analyses:  No analyses available
+  comments (0 threads):
+```
+
+Show the changes included in the review:
+```shell
+git appraise show --diff
+```
+
+```
+diff --git a/README.md b/README.md
+index 08fde78..85c4208 100644
+--- a/README.md
++++ b/README.md
+@@ -1 +1,2 @@
+ # Example Repository
++This is an example repository used for coming up to speed
+```
+
+### Sending our updates to the remote repository
+
+Before a teammate can review our change, we have to make it available to them.
+This involves pushing both our commits, and our code review data to the remote
+repository:
+```shell
+git push
+git appraise pull
+git appraise push
+```
+
+The command `git appraise pull` is used to make sure that our local code review
+data includes everything from the remote repo before we try to push our changes
+back to it. If you forget to run this command, then the subsequent call to
+`git appraise push` might fail with a message that the push was rejected. If
+that happens, simply run `git appraise pull` and try again.
+
+## Reviewing the change
+
+Your teammates can review your changes using the same tool.
+
+Fetch the current data from the remote repository:
+```shell
+git fetch origin
+git appraise pull
+```
+
+List the open reviews:
+```shell
+git appraise list
+```
+
+The output of this command will be a list of entries formatted like this:
+```
+Loaded 1 open reviews:
+[pending] 1e6eb14c8014
+  Added an explanation to the README file
+```
+
+The text within the square brackets is the status of a review, and for open
+reviews will be one of "pending", "accepted", or "rejected". The text which
+follows the status is the hash of the first commit in the review. This is
+used to uniquely identify reviews, and most git-appraise commands will accept
+this hash as an argument in order to select the review to handle.
+
+For instance, we can see the details of a specific review using the "show"
+subcommand:
+```shell
+git appraise show 1e6eb14c8014
+```
+
+```
+[pending] 1e6eb14c8014
+  Added an explanation to the README file
+  "refs/heads/ojarjur/getting-started" -> "refs/heads/master"
+  reviewers: ""
+  requester: "ojarjur@google.com"
+  build status: unknown
+  analyses:  No analyses available
+  comments (0 threads):
+```
+
+... or, we can see the diff of the changes under review:
+```shell
+git appraise show --diff 1e6eb14c8014
+```
+
+```
+diff --git a/README.md b/README.md
+index 08fde78..85c4208 100644
+--- a/README.md
++++ b/README.md
+@@ -1 +1,2 @@
+ # Example Repository
++This is an example repository used for coming up to speed
+```
+
+Comments can be added either for the entire review, or on individual lines:
+```shell
+git appraise comment -f README.md -l 2 -m "Ah, so that's what this is" 1e6eb14c8014
+```
+
+These comments then show up in the output of `git appraise show`:
+```shell
+git appraise show 1e6eb14c8014
+```
+
+```
+[pending] 1e6eb14c8014
+  Added an explanation to the README file
+  "refs/heads/ojarjur/getting-started" -> "refs/heads/master"
+  reviewers: ""
+  requester: "ojarjur@google.com"
+  build status: unknown
+  analyses:  No analyses available
+  comments (1 threads):
+    "README.md"@1e6eb14c8014
+    |# Example Repository
+    |This is an example repository used for coming up to speed
+    comment: bd4c11ecafd443c9d1dde6035e89804160cd7487
+      author: ojarjur@google.com
+      time:   Fri Dec 18 10:58:54 PST 2015
+      status: fyi
+      Ah, so that's what this is
+```
+
+Comments initially only exist in your local repository, so to share them
+with the rest of your team you have to push your review changes back:
+
+```shell
+git appraise pull
+git appraise push
+```
+
+When the change is ready to be merged, you indicate that by accepting the
+review:
+
+```shell
+git appraise accept 1e6eb14c8014
+git appraise pull
+git appraise push
+```
+
+The updated status of the review will be visible in the output of "show":
+```shell
+git appraise show 1e6eb14c8014
+```
+
+```
+[accepted] 1e6eb14c8014
+  Added an explanation to the README file
+  "refs/heads/ojarjur/getting-started" -> "refs/heads/master"
+  reviewers: ""
+  requester: "ojarjur@google.com"
+  build status: unknown
+  analyses:  No analyses available
+  comments (2 threads):
+    "README.md"@1e6eb14c8014
+    |# Example Repository
+    |This is an example repository used for coming up to speed
+    comment: bd4c11ecafd443c9d1dde6035e89804160cd7487
+      author: ojarjur@google.com
+      time:   Fri Dec 18 10:58:54 PST 2015
+      status: fyi
+      Ah, so that's what this is
+    comment: 4034c60e6ed6f24b01e9a581087d1ab86d376b81
+      author: ojarjur@google.com
+      time:   Fri Dec 18 11:02:45 PST 2015
+      status: fyi
+```
+
+## Submitting the change
+
+Once a review has been accepted, you can merge it with the tool:
+
+```shell
+git appraise submit --merge 1e6eb14c8014
+git push
+```
+
+The submit command will pop up a text editor where you can edit the default
+merge message. That message will be used to create a new commit that is a
+merge of the previous commit on the master branch, and the history of all
+of your changes to the review. You can see what this looks like using
+the `git log --graph` command:
+
+```
+*   commit 3a4d1b8cd264b921c858185f2c36aac283b45e49
+|\  Merge: b404fa3 1e6eb14
+| | Author: Omar Jarjur <ojarjur@google.com>
+| | Date:   Fri Dec 18 11:06:24 2015 -0800
+| | 
+| |     Submitting review 1e6eb14c8014
+| |     
+| |     Added an explanation to the README file
+| |   
+| * commit 1e6eb14c8014593843c5b5f29377585e4ed55304
+|/  Author: Omar Jarjur <ojarjur@google.com>
+|   Date:   Fri Dec 18 10:49:56 2015 -0800
+|   
+|       Added an explanation to the README file
+|  
+* commit b404fa39ae98950d95ab06012191f58507e51d12
+  Author: Omar Jarjur <ojarjur@google.com>
+  Date:   Fri Dec 18 10:48:06 2015 -0800
+  
+      Added a README file to the repo
+```
+
+This is sometimes called a "merge bubble". When the review is simply accepted
+as is, these do not add much value. However, reviews often go through several
+rounds of changes before they are accepted. By using these merge commits, we
+can preserve both the full history of individual reviews, and the high-level
+(review-based) history of the repository.
+
+This can be seen with the history of git-appraise itself. We can see the high
+level review history using `git log --first-parent`:
+
+```
+commit 83c4d770cfde25c943de161c0cac54d714b7de38
+Merge: 9a607b8 931d1b4
+Author: Omar Jarjur <ojarjur@google.com>
+Date:   Fri Dec 18 09:46:10 2015 -0800
+
+    Submitting review 8cb887077783
+    
+    Fix a bug where requesting a review would fail with an erroneous message.
+    
+    We were figuring out the set of commits to include in a review by
+    listing the commits between the head of the target ref and the head of
+    the source ref. However, this only works if the source ref is a
+    fast-forward of the target ref.
+    
+    This commit changes it so that we use the merge-base of the target and
+    source refs as the starting point instead of the target ref.
+
+commit 9a607b8529d7483e5b323303c73da05843ff3ca9
+Author: Harry Lawrence <hazbo@gmx.com>
+Date:   Fri Dec 18 10:24:00 2015 +0000
+
+    Added links to Eclipse and Jenkins plugins
+    
+    As suggested in #11
+
+commit 8876cfff2ed848d50cb559c05d44e11b95ca791c
+Merge: 00c0e82 1436c83
+Author: Omar Jarjur <ojarjur@google.com>
+Date:   Thu Dec 17 12:46:32 2015 -0800
+
+    Submitting review 09aecba64027
+    
+    Force default git editor when omitting -m
+    For review comments, the absence of the -m flag will now attempt to load the
+    user's default git editor.
+    
+    i.e. git appraise comment c0a643ff39dd
+    
+    An initial draft as discussed in #8
+    
+    I'm still not sure whether or not the file that is saved is in the most appropriate place or not. I like the idea of it being relative to the project although it could have gone in `/tmp` I suppose.
+
+commit 00c0e827e5b86fb9d200f474d4f65f43677cbc6c
+Merge: 31209ce 41fde0b
+Author: Omar Jarjur <ojarjur@google.com>
+Date:   Wed Dec 16 17:10:06 2015 -0800
+
+    Submitting review 2c9bff89f0f8
+    
+    Improve the error messages returned when a git command fails.
+    
+    Previously, we were simply cascading the error returned by the instance
+    of exec.Command. However, that winds up just being something of the form
+    "exit status 128", with all of the real error message going to the
+    Stderr field.
+    
+    As such, this commit changes the behavior to save the data written to
+    stderr, and use it to construct a new error to return.
+
+...
+```
+
+Here you see a linear view of the reviews that have been submitted, but if we
+run the command `git log --oneline --graph`, then we can see that the full
+history of each individual review is also available:
+
+```
+*   83c4d77 Submitting review 8cb887077783
+|\  
+| *   931d1b4 Merge branch 'master' into ojarjur/fix-request-bug
+| |\  
+| |/  
+|/|   
+* | 9a607b8 Added links to Eclipse and Jenkins plugins
+| *   c7be567 Merge branch 'master' into ojarjur/fix-request-bug
+| |\  
+| |/  
+|/|   
+* |   8876cff Submitting review 09aecba64027
+|\ \  
+| * | 1436c83 Using git var GIT_EDITOR rather than git config
+| * | 09aecba Force default git editor when omitting -m
+|/ /  
+| * 8cb8870 Fix a bug where requesting a review would fail with an erroneous message.
+|/  
+*   00c0e82 Submitting review 2c9bff89f0f8
+...
+```
+
+## Cleaning up
+
+Now that our feature branch has been merged into master, we can delete it:
+
+```shell
+git branch -d ${USER}/getting-started
+git push origin --delete ${USER}/getting-started
+```
diff --git a/third_party/go/git-appraise/git-appraise/git-appraise.go b/third_party/go/git-appraise/git-appraise/git-appraise.go
new file mode 100644
index 0000000000..ca5a30cf6d
--- /dev/null
+++ b/third_party/go/git-appraise/git-appraise/git-appraise.go
@@ -0,0 +1,104 @@
+/*
+Copyright 2015 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.
+*/
+
+// Command git-appraise manages code reviews stored as git-notes in the source repo.
+//
+// To install, run:
+//
+//    $ go get github.com/google/git-appraise/git-appraise
+//
+// And for usage information, run:
+//
+//    $ git-appraise help
+package main
+
+import (
+	"fmt"
+	"github.com/google/git-appraise/commands"
+	"github.com/google/git-appraise/repository"
+	"os"
+	"sort"
+	"strings"
+)
+
+const usageMessageTemplate = `Usage: %s <command>
+
+Where <command> is one of:
+  %s
+
+For individual command usage, run:
+  %s help <command>
+`
+
+func usage() {
+	command := os.Args[0]
+	var subcommands []string
+	for subcommand := range commands.CommandMap {
+		subcommands = append(subcommands, subcommand)
+	}
+	sort.Strings(subcommands)
+	fmt.Printf(usageMessageTemplate, command, strings.Join(subcommands, "\n  "), command)
+}
+
+func help() {
+	if len(os.Args) < 3 {
+		usage()
+		return
+	}
+	subcommand, ok := commands.CommandMap[os.Args[2]]
+	if !ok {
+		fmt.Printf("Unknown command %q\n", os.Args[2])
+		usage()
+		return
+	}
+	subcommand.Usage(os.Args[0])
+}
+
+func main() {
+	if len(os.Args) > 1 && os.Args[1] == "help" {
+		help()
+		return
+	}
+	cwd, err := os.Getwd()
+	if err != nil {
+		fmt.Printf("Unable to get the current working directory: %q\n", err)
+		return
+	}
+	repo, err := repository.NewGitRepo(cwd)
+	if err != nil {
+		fmt.Printf("%s must be run from within a git repo.\n", os.Args[0])
+		return
+	}
+	if len(os.Args) < 2 {
+		subcommand, ok := commands.CommandMap["list"]
+		if !ok {
+			fmt.Printf("Unable to list reviews")
+			return
+		}
+		subcommand.Run(repo, []string{})
+		return
+	}
+	subcommand, ok := commands.CommandMap[os.Args[1]]
+	if !ok {
+		fmt.Printf("Unknown command: %q\n", os.Args[1])
+		usage()
+		return
+	}
+	if err := subcommand.Run(repo, os.Args[2:]); err != nil {
+		fmt.Println(err.Error())
+		os.Exit(1)
+	}
+}
diff --git a/third_party/go/git-appraise/repository/git.go b/third_party/go/git-appraise/repository/git.go
new file mode 100644
index 0000000000..31d27ea6d2
--- /dev/null
+++ b/third_party/go/git-appraise/repository/git.go
@@ -0,0 +1,987 @@
+/*
+Copyright 2015 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 repository contains helper methods for working with the Git repo.
+package repository
+
+import (
+	"bufio"
+	"bytes"
+	"crypto/sha1"
+	"encoding/json"
+	"fmt"
+	"io"
+	"os"
+	"os/exec"
+	"strconv"
+	"strings"
+)
+
+const branchRefPrefix = "refs/heads/"
+
+// GitRepo represents an instance of a (local) git repository.
+type GitRepo struct {
+	Path string
+}
+
+// Run the given git command with the given I/O reader/writers, returning an error if it fails.
+func (repo *GitRepo) runGitCommandWithIO(stdin io.Reader, stdout, stderr io.Writer, args ...string) error {
+	cmd := exec.Command("git", args...)
+	cmd.Dir = repo.Path
+	cmd.Stdin = stdin
+	cmd.Stdout = stdout
+	cmd.Stderr = stderr
+	return cmd.Run()
+}
+
+// Run the given git command and return its stdout, or an error if the command fails.
+func (repo *GitRepo) runGitCommandRaw(args ...string) (string, string, error) {
+	var stdout bytes.Buffer
+	var stderr bytes.Buffer
+	err := repo.runGitCommandWithIO(nil, &stdout, &stderr, args...)
+	return strings.TrimSpace(stdout.String()), strings.TrimSpace(stderr.String()), err
+}
+
+// Run the given git command and return its stdout, or an error if the command fails.
+func (repo *GitRepo) runGitCommand(args ...string) (string, error) {
+	stdout, stderr, err := repo.runGitCommandRaw(args...)
+	if err != nil {
+		if stderr == "" {
+			stderr = "Error running git command: " + strings.Join(args, " ")
+		}
+		err = fmt.Errorf(stderr)
+	}
+	return stdout, err
+}
+
+// Run the given git command using the same stdin, stdout, and stderr as the review tool.
+func (repo *GitRepo) runGitCommandInline(args ...string) error {
+	return repo.runGitCommandWithIO(os.Stdin, os.Stdout, os.Stderr, args...)
+}
+
+// NewGitRepo determines if the given working directory is inside of a git repository,
+// and returns the corresponding GitRepo instance if it is.
+func NewGitRepo(path string) (*GitRepo, error) {
+	repo := &GitRepo{Path: path}
+	_, _, err := repo.runGitCommandRaw("rev-parse")
+	if err == nil {
+		return repo, nil
+	}
+	if _, ok := err.(*exec.ExitError); ok {
+		return nil, err
+	}
+	return nil, err
+}
+
+// GetPath returns the path to the repo.
+func (repo *GitRepo) GetPath() string {
+	return repo.Path
+}
+
+// GetRepoStateHash returns a hash which embodies the entire current state of a repository.
+func (repo *GitRepo) GetRepoStateHash() (string, error) {
+	stateSummary, error := repo.runGitCommand("show-ref")
+	return fmt.Sprintf("%x", sha1.Sum([]byte(stateSummary))), error
+}
+
+// GetUserEmail returns the email address that the user has used to configure git.
+func (repo *GitRepo) GetUserEmail() (string, error) {
+	return repo.runGitCommand("config", "user.email")
+}
+
+// GetUserSigningKey returns the key id the user has configured for
+// sigining git artifacts.
+func (repo *GitRepo) GetUserSigningKey() (string, error) {
+	return repo.runGitCommand("config", "user.signingKey")
+}
+
+// GetCoreEditor returns the name of the editor that the user has used to configure git.
+func (repo *GitRepo) GetCoreEditor() (string, error) {
+	return repo.runGitCommand("var", "GIT_EDITOR")
+}
+
+// GetSubmitStrategy returns the way in which a review is submitted
+func (repo *GitRepo) GetSubmitStrategy() (string, error) {
+	submitStrategy, _ := repo.runGitCommand("config", "appraise.submit")
+	return submitStrategy, nil
+}
+
+// HasUncommittedChanges returns true if there are local, uncommitted changes.
+func (repo *GitRepo) HasUncommittedChanges() (bool, error) {
+	out, err := repo.runGitCommand("status", "--porcelain")
+	if err != nil {
+		return false, err
+	}
+	if len(out) > 0 {
+		return true, nil
+	}
+	return false, nil
+}
+
+// VerifyCommit verifies that the supplied hash points to a known commit.
+func (repo *GitRepo) VerifyCommit(hash string) error {
+	out, err := repo.runGitCommand("cat-file", "-t", hash)
+	if err != nil {
+		return err
+	}
+	objectType := strings.TrimSpace(string(out))
+	if objectType != "commit" {
+		return fmt.Errorf("Hash %q points to a non-commit object of type %q", hash, objectType)
+	}
+	return nil
+}
+
+// VerifyGitRef verifies that the supplied ref points to a known commit.
+func (repo *GitRepo) VerifyGitRef(ref string) error {
+	_, err := repo.runGitCommand("show-ref", "--verify", ref)
+	return err
+}
+
+// GetHeadRef returns the ref that is the current HEAD.
+func (repo *GitRepo) GetHeadRef() (string, error) {
+	return repo.runGitCommand("symbolic-ref", "HEAD")
+}
+
+// GetCommitHash returns the hash of the commit pointed to by the given ref.
+func (repo *GitRepo) GetCommitHash(ref string) (string, error) {
+	return repo.runGitCommand("show", "-s", "--format=%H", ref)
+}
+
+// ResolveRefCommit returns the commit pointed to by the given ref, which may be a remote ref.
+//
+// This differs from GetCommitHash which only works on exact matches, in that it will try to
+// intelligently handle the scenario of a ref not existing locally, but being known to exist
+// in a remote repo.
+//
+// This method should be used when a command may be performed by either the reviewer or the
+// reviewee, while GetCommitHash should be used when the encompassing command should only be
+// performed by the reviewee.
+func (repo *GitRepo) ResolveRefCommit(ref string) (string, error) {
+	if err := repo.VerifyGitRef(ref); err == nil {
+		return repo.GetCommitHash(ref)
+	}
+	if strings.HasPrefix(ref, "refs/heads/") {
+		// The ref is a branch. Check if it exists in exactly one remote
+		pattern := strings.Replace(ref, "refs/heads", "**", 1)
+		matchingOutput, err := repo.runGitCommand("for-each-ref", "--format=%(refname)", pattern)
+		if err != nil {
+			return "", err
+		}
+		matchingRefs := strings.Split(matchingOutput, "\n")
+		if len(matchingRefs) == 1 && matchingRefs[0] != "" {
+			// There is exactly one match
+			return repo.GetCommitHash(matchingRefs[0])
+		}
+		return "", fmt.Errorf("Unable to find a git ref matching the pattern %q", pattern)
+	}
+	return "", fmt.Errorf("Unknown git ref %q", ref)
+}
+
+// GetCommitMessage returns the message stored in the commit pointed to by the given ref.
+func (repo *GitRepo) GetCommitMessage(ref string) (string, error) {
+	return repo.runGitCommand("show", "-s", "--format=%B", ref)
+}
+
+// GetCommitTime returns the commit time of the commit pointed to by the given ref.
+func (repo *GitRepo) GetCommitTime(ref string) (string, error) {
+	return repo.runGitCommand("show", "-s", "--format=%ct", ref)
+}
+
+// GetLastParent returns the last parent of the given commit (as ordered by git).
+func (repo *GitRepo) GetLastParent(ref string) (string, error) {
+	return repo.runGitCommand("rev-list", "--skip", "1", "-n", "1", ref)
+}
+
+// GetCommitDetails returns the details of a commit's metadata.
+func (repo GitRepo) GetCommitDetails(ref string) (*CommitDetails, error) {
+	var err error
+	show := func(formatString string) (result string) {
+		if err != nil {
+			return ""
+		}
+		result, err = repo.runGitCommand("show", "-s", ref, fmt.Sprintf("--format=tformat:%s", formatString))
+		return result
+	}
+
+	jsonFormatString := "{\"tree\":\"%T\", \"time\": \"%at\"}"
+	detailsJSON := show(jsonFormatString)
+	if err != nil {
+		return nil, err
+	}
+	var details CommitDetails
+	err = json.Unmarshal([]byte(detailsJSON), &details)
+	if err != nil {
+		return nil, err
+	}
+	details.Author = show("%an")
+	details.AuthorEmail = show("%ae")
+	details.Summary = show("%s")
+	parentsString := show("%P")
+	details.Parents = strings.Split(parentsString, " ")
+	if err != nil {
+		return nil, err
+	}
+	return &details, nil
+}
+
+// MergeBase determines if the first commit that is an ancestor of the two arguments.
+func (repo *GitRepo) MergeBase(a, b string) (string, error) {
+	return repo.runGitCommand("merge-base", a, b)
+}
+
+// IsAncestor determines if the first argument points to a commit that is an ancestor of the second.
+func (repo *GitRepo) IsAncestor(ancestor, descendant string) (bool, error) {
+	_, _, err := repo.runGitCommandRaw("merge-base", "--is-ancestor", ancestor, descendant)
+	if err == nil {
+		return true, nil
+	}
+	if _, ok := err.(*exec.ExitError); ok {
+		return false, nil
+	}
+	return false, fmt.Errorf("Error while trying to determine commit ancestry: %v", err)
+}
+
+// Diff computes the diff between two given commits.
+func (repo *GitRepo) Diff(left, right string, diffArgs ...string) (string, error) {
+	args := []string{"diff"}
+	args = append(args, diffArgs...)
+	args = append(args, fmt.Sprintf("%s..%s", left, right))
+	return repo.runGitCommand(args...)
+}
+
+// Show returns the contents of the given file at the given commit.
+func (repo *GitRepo) Show(commit, path string) (string, error) {
+	return repo.runGitCommand("show", fmt.Sprintf("%s:%s", commit, path))
+}
+
+// SwitchToRef changes the currently-checked-out ref.
+func (repo *GitRepo) SwitchToRef(ref string) error {
+	// If the ref starts with "refs/heads/", then we have to trim that prefix,
+	// or else we will wind up in a detached HEAD state.
+	if strings.HasPrefix(ref, branchRefPrefix) {
+		ref = ref[len(branchRefPrefix):]
+	}
+	_, err := repo.runGitCommand("checkout", ref)
+	return err
+}
+
+// mergeArchives merges two archive refs.
+func (repo *GitRepo) mergeArchives(archive, remoteArchive string) error {
+	remoteHash, err := repo.GetCommitHash(remoteArchive)
+	if err != nil {
+		return err
+	}
+	if remoteHash == "" {
+		// The remote archive does not exist, so we have nothing to do
+		return nil
+	}
+
+	archiveHash, err := repo.GetCommitHash(archive)
+	if err != nil {
+		return err
+	}
+	if archiveHash == "" {
+		// The local archive does not exist, so we merely need to set it
+		_, err := repo.runGitCommand("update-ref", archive, remoteHash)
+		return err
+	}
+
+	isAncestor, err := repo.IsAncestor(archiveHash, remoteHash)
+	if err != nil {
+		return err
+	}
+	if isAncestor {
+		// The archive can simply be fast-forwarded
+		_, err := repo.runGitCommand("update-ref", archive, remoteHash, archiveHash)
+		return err
+	}
+
+	// Create a merge commit of the two archives
+	refDetails, err := repo.GetCommitDetails(remoteArchive)
+	if err != nil {
+		return err
+	}
+	newArchiveHash, err := repo.runGitCommand("commit-tree", "-p", remoteHash, "-p", archiveHash, "-m", "Merge local and remote archives", refDetails.Tree)
+	if err != nil {
+		return err
+	}
+	newArchiveHash = strings.TrimSpace(newArchiveHash)
+	_, err = repo.runGitCommand("update-ref", archive, newArchiveHash, archiveHash)
+	return err
+}
+
+// ArchiveRef adds the current commit pointed to by the 'ref' argument
+// under the ref specified in the 'archive' argument.
+//
+// Both the 'ref' and 'archive' arguments are expected to be the fully
+// qualified names of git refs (e.g. 'refs/heads/my-change' or
+// 'refs/devtools/archives/reviews').
+//
+// If the ref pointed to by the 'archive' argument does not exist
+// yet, then it will be created.
+func (repo *GitRepo) ArchiveRef(ref, archive string) error {
+	refHash, err := repo.GetCommitHash(ref)
+	if err != nil {
+		return err
+	}
+	refDetails, err := repo.GetCommitDetails(ref)
+	if err != nil {
+		return err
+	}
+
+	commitTreeArgs := []string{"commit-tree"}
+	archiveHash, err := repo.GetCommitHash(archive)
+	if err != nil {
+		archiveHash = ""
+	} else {
+		commitTreeArgs = append(commitTreeArgs, "-p", archiveHash)
+	}
+	commitTreeArgs = append(commitTreeArgs, "-p", refHash, "-m", fmt.Sprintf("Archive %s", refHash), refDetails.Tree)
+	newArchiveHash, err := repo.runGitCommand(commitTreeArgs...)
+	if err != nil {
+		return err
+	}
+	newArchiveHash = strings.TrimSpace(newArchiveHash)
+	updateRefArgs := []string{"update-ref", archive, newArchiveHash}
+	if archiveHash != "" {
+		updateRefArgs = append(updateRefArgs, archiveHash)
+	}
+	_, err = repo.runGitCommand(updateRefArgs...)
+	return err
+}
+
+// MergeRef merges the given ref into the current one.
+//
+// The ref argument is the ref to merge, and fastForward indicates that the
+// current ref should only move forward, as opposed to creating a bubble merge.
+// The messages argument(s) provide text that should be included in the default
+// merge commit message (separated by blank lines).
+func (repo *GitRepo) MergeRef(ref string, fastForward bool, messages ...string) error {
+	args := []string{"merge"}
+	if fastForward {
+		args = append(args, "--ff", "--ff-only")
+	} else {
+		args = append(args, "--no-ff")
+	}
+	if len(messages) > 0 {
+		commitMessage := strings.Join(messages, "\n\n")
+		args = append(args, "-e", "-m", commitMessage)
+	}
+	args = append(args, ref)
+	return repo.runGitCommandInline(args...)
+}
+
+// MergeAndSignRef merges the given ref into the current one and signs the
+// merge.
+//
+// The ref argument is the ref to merge, and fastForward indicates that the
+// current ref should only move forward, as opposed to creating a bubble merge.
+// The messages argument(s) provide text that should be included in the default
+// merge commit message (separated by blank lines).
+func (repo *GitRepo) MergeAndSignRef(ref string, fastForward bool,
+	messages ...string) error {
+
+	args := []string{"merge"}
+	if fastForward {
+		args = append(args, "--ff", "--ff-only", "-S")
+	} else {
+		args = append(args, "--no-ff", "-S")
+	}
+	if len(messages) > 0 {
+		commitMessage := strings.Join(messages, "\n\n")
+		args = append(args, "-e", "-m", commitMessage)
+	}
+	args = append(args, ref)
+	return repo.runGitCommandInline(args...)
+}
+
+// RebaseRef rebases the current ref onto the given one.
+func (repo *GitRepo) RebaseRef(ref string) error {
+	return repo.runGitCommandInline("rebase", "-i", ref)
+}
+
+// RebaseAndSignRef rebases the current ref onto the given one and signs the
+// result.
+func (repo *GitRepo) RebaseAndSignRef(ref string) error {
+	return repo.runGitCommandInline("rebase", "-S", "-i", ref)
+}
+
+// ListCommits returns the list of commits reachable from the given ref.
+//
+// The generated list is in chronological order (with the oldest commit first).
+//
+// If the specified ref does not exist, then this method returns an empty result.
+func (repo *GitRepo) ListCommits(ref string) []string {
+	var stdout bytes.Buffer
+	var stderr bytes.Buffer
+	if err := repo.runGitCommandWithIO(nil, &stdout, &stderr, "rev-list", "--reverse", ref); err != nil {
+		return nil
+	}
+
+	byteLines := bytes.Split(stdout.Bytes(), []byte("\n"))
+	var commits []string
+	for _, byteLine := range byteLines {
+		commits = append(commits, string(byteLine))
+	}
+	return commits
+}
+
+// ListCommitsBetween returns the list of commits between the two given revisions.
+//
+// The "from" parameter is the starting point (exclusive), and the "to"
+// parameter is the ending point (inclusive).
+//
+// The "from" commit does not need to be an ancestor of the "to" commit. If it
+// is not, then the merge base of the two is used as the starting point.
+// Admittedly, this makes calling these the "between" commits is a bit of a
+// misnomer, but it also makes the method easier to use when you want to
+// generate the list of changes in a feature branch, as it eliminates the need
+// to explicitly calculate the merge base. This also makes the semantics of the
+// method compatible with git's built-in "rev-list" command.
+//
+// The generated list is in chronological order (with the oldest commit first).
+func (repo *GitRepo) ListCommitsBetween(from, to string) ([]string, error) {
+	out, err := repo.runGitCommand("rev-list", "--reverse", from+".."+to)
+	if err != nil {
+		return nil, err
+	}
+	if out == "" {
+		return nil, nil
+	}
+	return strings.Split(out, "\n"), nil
+}
+
+// GetNotes uses the "git" command-line tool to read the notes from the given ref for a given revision.
+func (repo *GitRepo) GetNotes(notesRef, revision string) []Note {
+	var notes []Note
+	rawNotes, err := repo.runGitCommand("notes", "--ref", notesRef, "show", revision)
+	if err != nil {
+		// We just assume that this means there are no notes
+		return nil
+	}
+	for _, line := range strings.Split(rawNotes, "\n") {
+		notes = append(notes, Note([]byte(line)))
+	}
+	return notes
+}
+
+func stringsReader(s []*string) io.Reader {
+	var subReaders []io.Reader
+	for _, strPtr := range s {
+		subReader := strings.NewReader(*strPtr)
+		subReaders = append(subReaders, subReader, strings.NewReader("\n"))
+	}
+	return io.MultiReader(subReaders...)
+}
+
+// splitBatchCheckOutput parses the output of a 'git cat-file --batch-check=...' command.
+//
+// The output is expected to be formatted as a series of entries, with each
+// entry consisting of:
+// 1. The SHA1 hash of the git object being output, followed by a space.
+// 2. The git "type" of the object (commit, blob, tree, missing, etc), followed by a newline.
+//
+// To generate this format, make sure that the 'git cat-file' command includes
+// the argument '--batch-check=%(objectname) %(objecttype)'.
+//
+// The return value is a map from object hash to a boolean indicating if that object is a commit.
+func splitBatchCheckOutput(out *bytes.Buffer) (map[string]bool, error) {
+	isCommit := make(map[string]bool)
+	reader := bufio.NewReader(out)
+	for {
+		nameLine, err := reader.ReadString(byte(' '))
+		if err == io.EOF {
+			return isCommit, nil
+		}
+		if err != nil {
+			return nil, fmt.Errorf("Failure while reading the next object name: %v", err)
+		}
+		nameLine = strings.TrimSuffix(nameLine, " ")
+		typeLine, err := reader.ReadString(byte('\n'))
+		if err != nil && err != io.EOF {
+			return nil, fmt.Errorf("Failure while reading the next object type: %q - %v", nameLine, err)
+		}
+		typeLine = strings.TrimSuffix(typeLine, "\n")
+		if typeLine == "commit" {
+			isCommit[nameLine] = true
+		}
+	}
+}
+
+// splitBatchCatFileOutput parses the output of a 'git cat-file --batch=...' command.
+//
+// The output is expected to be formatted as a series of entries, with each
+// entry consisting of:
+// 1. The SHA1 hash of the git object being output, followed by a newline.
+// 2. The size of the object's contents in bytes, followed by a newline.
+// 3. The objects contents.
+//
+// To generate this format, make sure that the 'git cat-file' command includes
+// the argument '--batch=%(objectname)\n%(objectsize)'.
+func splitBatchCatFileOutput(out *bytes.Buffer) (map[string][]byte, error) {
+	contentsMap := make(map[string][]byte)
+	reader := bufio.NewReader(out)
+	for {
+		nameLine, err := reader.ReadString(byte('\n'))
+		if strings.HasSuffix(nameLine, "\n") {
+			nameLine = strings.TrimSuffix(nameLine, "\n")
+		}
+		if err == io.EOF {
+			return contentsMap, nil
+		}
+		if err != nil {
+			return nil, fmt.Errorf("Failure while reading the next object name: %v", err)
+		}
+		sizeLine, err := reader.ReadString(byte('\n'))
+		if strings.HasSuffix(sizeLine, "\n") {
+			sizeLine = strings.TrimSuffix(sizeLine, "\n")
+		}
+		if err != nil {
+			return nil, fmt.Errorf("Failure while reading the next object size: %q - %v", nameLine, err)
+		}
+		size, err := strconv.Atoi(sizeLine)
+		if err != nil {
+			return nil, fmt.Errorf("Failure while parsing the next object size: %q - %v", nameLine, err)
+		}
+		contentBytes := make([]byte, size, size)
+		readDest := contentBytes
+		len := 0
+		err = nil
+		for err == nil && len < size {
+			nextLen := 0
+			nextLen, err = reader.Read(readDest)
+			len += nextLen
+			readDest = contentBytes[len:]
+		}
+		contentsMap[nameLine] = contentBytes
+		if err == io.EOF {
+			return contentsMap, nil
+		}
+		if err != nil {
+			return nil, err
+		}
+		for bs, err := reader.Peek(1); err == nil && bs[0] == byte('\n'); bs, err = reader.Peek(1) {
+			reader.ReadByte()
+		}
+	}
+}
+
+// notesMapping represents the association between a git object and the notes for that object.
+type notesMapping struct {
+	ObjectHash *string
+	NotesHash  *string
+}
+
+// notesOverview represents a high-level overview of all the notes under a single notes ref.
+type notesOverview struct {
+	NotesMappings      []*notesMapping
+	ObjectHashesReader io.Reader
+	NotesHashesReader  io.Reader
+}
+
+// notesOverview returns an overview of the git notes stored under the given ref.
+func (repo *GitRepo) notesOverview(notesRef string) (*notesOverview, error) {
+	var stdout bytes.Buffer
+	var stderr bytes.Buffer
+	if err := repo.runGitCommandWithIO(nil, &stdout, &stderr, "notes", "--ref", notesRef, "list"); err != nil {
+		return nil, err
+	}
+
+	var notesMappings []*notesMapping
+	var objHashes []*string
+	var notesHashes []*string
+	outScanner := bufio.NewScanner(&stdout)
+	for outScanner.Scan() {
+		line := outScanner.Text()
+		lineParts := strings.Split(line, " ")
+		if len(lineParts) != 2 {
+			return nil, fmt.Errorf("Malformed output line from 'git-notes list': %q", line)
+		}
+		objHash := &lineParts[1]
+		notesHash := &lineParts[0]
+		notesMappings = append(notesMappings, &notesMapping{
+			ObjectHash: objHash,
+			NotesHash:  notesHash,
+		})
+		objHashes = append(objHashes, objHash)
+		notesHashes = append(notesHashes, notesHash)
+	}
+	err := outScanner.Err()
+	if err != nil && err != io.EOF {
+		return nil, fmt.Errorf("Failure parsing the output of 'git-notes list': %v", err)
+	}
+	return &notesOverview{
+		NotesMappings:      notesMappings,
+		ObjectHashesReader: stringsReader(objHashes),
+		NotesHashesReader:  stringsReader(notesHashes),
+	}, nil
+}
+
+// getIsCommitMap returns a mapping of all the annotated objects that are commits.
+func (overview *notesOverview) getIsCommitMap(repo *GitRepo) (map[string]bool, error) {
+	var stdout bytes.Buffer
+	var stderr bytes.Buffer
+	if err := repo.runGitCommandWithIO(overview.ObjectHashesReader, &stdout, &stderr, "cat-file", "--batch-check=%(objectname) %(objecttype)"); err != nil {
+		return nil, fmt.Errorf("Failure performing a batch file check: %v", err)
+	}
+	isCommit, err := splitBatchCheckOutput(&stdout)
+	if err != nil {
+		return nil, fmt.Errorf("Failure parsing the output of a batch file check: %v", err)
+	}
+	return isCommit, nil
+}
+
+// getNoteContentsMap returns a mapping from all the notes hashes to their contents.
+func (overview *notesOverview) getNoteContentsMap(repo *GitRepo) (map[string][]byte, error) {
+	var stdout bytes.Buffer
+	var stderr bytes.Buffer
+	if err := repo.runGitCommandWithIO(overview.NotesHashesReader, &stdout, &stderr, "cat-file", "--batch=%(objectname)\n%(objectsize)"); err != nil {
+		return nil, fmt.Errorf("Failure performing a batch file read: %v", err)
+	}
+	noteContentsMap, err := splitBatchCatFileOutput(&stdout)
+	if err != nil {
+		return nil, fmt.Errorf("Failure parsing the output of a batch file read: %v", err)
+	}
+	return noteContentsMap, nil
+}
+
+// GetAllNotes reads the contents of the notes under the given ref for every commit.
+//
+// The returned value is a mapping from commit hash to the list of notes for that commit.
+//
+// This is the batch version of the corresponding GetNotes(...) method.
+func (repo *GitRepo) GetAllNotes(notesRef string) (map[string][]Note, error) {
+	// This code is unfortunately quite complicated, but it needs to be so.
+	//
+	// Conceptually, this is equivalent to:
+	//   result := make(map[string][]Note)
+	//   for _, commit := range repo.ListNotedRevisions(notesRef) {
+	//     result[commit] = repo.GetNotes(notesRef, commit)
+	//   }
+	//   return result, nil
+	//
+	// However, that logic would require separate executions of the 'git'
+	// command for every annotated commit. For a repo with 10s of thousands
+	// of reviews, that would mean calling Cmd.Run(...) 10s of thousands of
+	// times. That, in turn, would take so long that the tool would be unusable.
+	//
+	// This method avoids that by taking advantage of the 'git cat-file --batch="..."'
+	// command. That allows us to use a single invocation of Cmd.Run(...) to
+	// inspect multiple git objects at once.
+	//
+	// As such, regardless of the number of reviews in a repo, we can get all
+	// of the notes using a total of three invocations of Cmd.Run(...):
+	//  1. One to list all the annotated objects (and their notes hash)
+	//  2. A second one to filter out all of the annotated objects that are not commits.
+	//  3. A final one to get the contents of all of the notes blobs.
+	overview, err := repo.notesOverview(notesRef)
+	if err != nil {
+		return nil, err
+	}
+	isCommit, err := overview.getIsCommitMap(repo)
+	if err != nil {
+		return nil, fmt.Errorf("Failure building the set of commit objects: %v", err)
+	}
+	noteContentsMap, err := overview.getNoteContentsMap(repo)
+	if err != nil {
+		return nil, fmt.Errorf("Failure building the mapping from notes hash to contents: %v", err)
+	}
+	commitNotesMap := make(map[string][]Note)
+	for _, notesMapping := range overview.NotesMappings {
+		if !isCommit[*notesMapping.ObjectHash] {
+			continue
+		}
+		noteBytes := noteContentsMap[*notesMapping.NotesHash]
+		byteSlices := bytes.Split(noteBytes, []byte("\n"))
+		var notes []Note
+		for _, slice := range byteSlices {
+			notes = append(notes, Note(slice))
+		}
+		commitNotesMap[*notesMapping.ObjectHash] = notes
+	}
+
+	return commitNotesMap, nil
+}
+
+// AppendNote appends a note to a revision under the given ref.
+func (repo *GitRepo) AppendNote(notesRef, revision string, note Note) error {
+	_, err := repo.runGitCommand("notes", "--ref", notesRef, "append", "-m", string(note), revision)
+	return err
+}
+
+// ListNotedRevisions returns the collection of revisions that are annotated by notes in the given ref.
+func (repo *GitRepo) ListNotedRevisions(notesRef string) []string {
+	var revisions []string
+	notesListOut, err := repo.runGitCommand("notes", "--ref", notesRef, "list")
+	if err != nil {
+		return nil
+	}
+	notesList := strings.Split(notesListOut, "\n")
+	for _, notePair := range notesList {
+		noteParts := strings.SplitN(notePair, " ", 2)
+		if len(noteParts) == 2 {
+			objHash := noteParts[1]
+			objType, err := repo.runGitCommand("cat-file", "-t", objHash)
+			// If a note points to an object that we do not know about (yet), then err will not
+			// be nil. We can safely just ignore those notes.
+			if err == nil && objType == "commit" {
+				revisions = append(revisions, objHash)
+			}
+		}
+	}
+	return revisions
+}
+
+// PushNotes pushes git notes to a remote repo.
+func (repo *GitRepo) PushNotes(remote, notesRefPattern string) error {
+	refspec := fmt.Sprintf("%s:%s", notesRefPattern, notesRefPattern)
+
+	// The push is liable to fail if the user forgot to do a pull first, so
+	// we treat errors as user errors rather than fatal errors.
+	err := repo.runGitCommandInline("push", remote, refspec)
+	if err != nil {
+		return fmt.Errorf("Failed to push to the remote '%s': %v", remote, err)
+	}
+	return nil
+}
+
+// PushNotesAndArchive pushes the given notes and archive refs to a remote repo.
+func (repo *GitRepo) PushNotesAndArchive(remote, notesRefPattern, archiveRefPattern string) error {
+	notesRefspec := fmt.Sprintf("%s:%s", notesRefPattern, notesRefPattern)
+	archiveRefspec := fmt.Sprintf("%s:%s", archiveRefPattern, archiveRefPattern)
+	err := repo.runGitCommandInline("push", remote, notesRefspec, archiveRefspec)
+	if err != nil {
+		return fmt.Errorf("Failed to push the local archive to the remote '%s': %v", remote, err)
+	}
+	return nil
+}
+
+func getRemoteNotesRef(remote, localNotesRef string) string {
+	relativeNotesRef := strings.TrimPrefix(localNotesRef, "refs/notes/")
+	return "refs/notes/" + remote + "/" + relativeNotesRef
+}
+
+// MergeNotes merges in the remote's state of the notes reference into the
+// local repository's.
+func (repo *GitRepo) MergeNotes(remote, notesRefPattern string) error {
+	remoteRefs, err := repo.runGitCommand("ls-remote", remote, notesRefPattern)
+	if err != nil {
+		return err
+	}
+	for _, line := range strings.Split(remoteRefs, "\n") {
+		lineParts := strings.Split(line, "\t")
+		if len(lineParts) == 2 {
+			ref := lineParts[1]
+			remoteRef := getRemoteNotesRef(remote, ref)
+			_, err := repo.runGitCommand("notes", "--ref", ref, "merge", remoteRef, "-s", "cat_sort_uniq")
+			if err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
+
+// PullNotes fetches the contents of the given notes ref from a remote repo,
+// and then merges them with the corresponding local notes using the
+// "cat_sort_uniq" strategy.
+func (repo *GitRepo) PullNotes(remote, notesRefPattern string) error {
+	remoteNotesRefPattern := getRemoteNotesRef(remote, notesRefPattern)
+	fetchRefSpec := fmt.Sprintf("+%s:%s", notesRefPattern, remoteNotesRefPattern)
+	err := repo.runGitCommandInline("fetch", remote, fetchRefSpec)
+	if err != nil {
+		return err
+	}
+
+	return repo.MergeNotes(remote, notesRefPattern)
+}
+
+func getRemoteArchiveRef(remote, archiveRefPattern string) string {
+	relativeArchiveRef := strings.TrimPrefix(archiveRefPattern, "refs/devtools/archives/")
+	return "refs/devtools/remoteArchives/" + remote + "/" + relativeArchiveRef
+}
+
+// MergeArchives merges in the remote's state of the archives reference into
+// the local repository's.
+func (repo *GitRepo) MergeArchives(remote, archiveRefPattern string) error {
+	remoteRefs, err := repo.runGitCommand("ls-remote", remote, archiveRefPattern)
+	if err != nil {
+		return err
+	}
+	for _, line := range strings.Split(remoteRefs, "\n") {
+		lineParts := strings.Split(line, "\t")
+		if len(lineParts) == 2 {
+			ref := lineParts[1]
+			remoteRef := getRemoteArchiveRef(remote, ref)
+			if err := repo.mergeArchives(ref, remoteRef); err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
+
+func (repo *GitRepo) fetchNotes(remote, notesRefPattern,
+	archiveRefPattern string) error {
+
+	remoteArchiveRef := getRemoteArchiveRef(remote, archiveRefPattern)
+	archiveFetchRefSpec := fmt.Sprintf("+%s:%s", archiveRefPattern, remoteArchiveRef)
+
+	remoteNotesRefPattern := getRemoteNotesRef(remote, notesRefPattern)
+	notesFetchRefSpec := fmt.Sprintf("+%s:%s", notesRefPattern, remoteNotesRefPattern)
+
+	return repo.runGitCommandInline("fetch", remote, notesFetchRefSpec, archiveFetchRefSpec)
+}
+
+// PullNotesAndArchive fetches the contents of the notes and archives refs from
+// a remote repo, and merges them with the corresponding local refs.
+//
+// For notes refs, we assume that every note can be automatically merged using
+// the 'cat_sort_uniq' strategy (the git-appraise schemas fit that requirement),
+// so we automatically merge the remote notes into the local notes.
+//
+// For "archive" refs, they are expected to be used solely for maintaining
+// reachability of commits that are part of the history of any reviews,
+// so we do not maintain any consistency with their tree objects. Instead,
+// we merely ensure that their history graph includes every commit that we
+// intend to keep.
+func (repo *GitRepo) PullNotesAndArchive(remote, notesRefPattern, archiveRefPattern string) error {
+	err := repo.fetchNotes(remote, notesRefPattern, archiveRefPattern)
+	if err != nil {
+		return err
+	}
+
+	err = repo.MergeNotes(remote, notesRefPattern)
+	if err != nil {
+		return err
+	}
+	return repo.MergeArchives(remote, archiveRefPattern)
+}
+
+// FetchAndReturnNewReviewHashes fetches the notes "branches" and then susses
+// out the IDs (the revision the review points to) of any new reviews, then
+// returns that list of IDs.
+//
+// This is accomplished by determining which files in the notes tree have
+// changed because the _names_ of these files correspond to the revisions they
+// point to.
+func (repo *GitRepo) FetchAndReturnNewReviewHashes(remote, notesRefPattern,
+	archiveRefPattern string) ([]string, error) {
+
+	// Record the current state of the reviews and comments refs.
+	var (
+		getAllRevs, getAllComs    bool
+		reviewsList, commentsList []string
+	)
+	reviewBeforeHash, err := repo.GetCommitHash(
+		"notes/" + remote + "/devtools/reviews")
+	getAllRevs = err != nil
+
+	commentBeforeHash, err := repo.GetCommitHash(
+		"notes/" + remote + "/devtools/discuss")
+	getAllComs = err != nil
+
+	// Update them from the remote.
+	err = repo.fetchNotes(remote, notesRefPattern, archiveRefPattern)
+	if err != nil {
+		return nil, err
+	}
+
+	// Now, if either of these are new refs, we just use the whole tree at that
+	// new ref. Otherwise we see which reviews or comments changed and collect
+	// them into a list.
+	if getAllRevs {
+		hash, err := repo.GetCommitHash(
+			"notes/" + remote + "/devtools/reviews")
+		// It is possible that even after we've pulled that this ref still
+		// isn't present (because there are no reviews yet).
+		if err == nil {
+			rvws, err := repo.runGitCommand("ls-tree", "-r", "--name-only",
+				hash)
+			if err != nil {
+				return nil, err
+			}
+			reviewsList = strings.Split(strings.Replace(rvws, "/", "", -1),
+				"\n")
+		}
+	} else {
+		reviewAfterHash, err := repo.GetCommitHash(
+			"notes/" + remote + "/devtools/reviews")
+		if err != nil {
+			return nil, err
+		}
+
+		// Only run through this if the fetch fetched new revisions.
+		// Otherwise leave reviewsList as its default value, an empty slice
+		// of strings.
+		if reviewBeforeHash != reviewAfterHash {
+			newReviewsRaw, err := repo.runGitCommand("diff", "--name-only",
+				reviewBeforeHash, reviewAfterHash)
+			if err != nil {
+				return nil, err
+			}
+			reviewsList = strings.Split(strings.Replace(newReviewsRaw,
+				"/", "", -1), "\n")
+		}
+	}
+
+	if getAllComs {
+		hash, err := repo.GetCommitHash(
+			"notes/" + remote + "/devtools/discuss")
+		// It is possible that even after we've pulled that this ref still
+		// isn't present (because there are no comments yet).
+		if err == nil {
+			rvws, err := repo.runGitCommand("ls-tree", "-r", "--name-only",
+				hash)
+			if err != nil {
+				return nil, err
+			}
+			commentsList = strings.Split(strings.Replace(rvws, "/", "", -1),
+				"\n")
+		}
+	} else {
+		commentAfterHash, err := repo.GetCommitHash(
+			"notes/" + remote + "/devtools/discuss")
+		if err != nil {
+			return nil, err
+		}
+
+		// Only run through this if the fetch fetched new revisions.
+		// Otherwise leave commentsList as its default value, an empty slice
+		// of strings.
+		if commentBeforeHash != commentAfterHash {
+			newCommentsRaw, err := repo.runGitCommand("diff", "--name-only",
+				commentBeforeHash, commentAfterHash)
+			if err != nil {
+				return nil, err
+			}
+			commentsList = strings.Split(strings.Replace(newCommentsRaw,
+				"/", "", -1), "\n")
+		}
+	}
+
+	// Now that we have our two lists, we need to merge them.
+	updatedReviewSet := make(map[string]struct{})
+	for _, hash := range append(reviewsList, commentsList...) {
+		updatedReviewSet[hash] = struct{}{}
+	}
+
+	updatedReviews := make([]string, 0, len(updatedReviewSet))
+	for key, _ := range updatedReviewSet {
+		updatedReviews = append(updatedReviews, key)
+	}
+	return updatedReviews, nil
+}
diff --git a/third_party/go/git-appraise/repository/git_test.go b/third_party/go/git-appraise/repository/git_test.go
new file mode 100644
index 0000000000..e1a9e2b2ea
--- /dev/null
+++ b/third_party/go/git-appraise/repository/git_test.go
@@ -0,0 +1,94 @@
+/*
+Copyright 2016 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 repository
+
+import (
+	"bytes"
+	"testing"
+)
+
+const (
+	simpleBatchCheckOutput = `ddbdcb9d5aa71d35de481789bacece9a2f8138d0 commit
+de9ebcdf2a1e93365eefc2739f73f2c68a280c11 commit
+def9abf52f9a17d4f168e05bc420557a87a55961 commit
+df324616ea2bc9bf6fc7025fc80a373ecec687b6 missing
+dfdd159c9c11c08d84c8c050d2a1a4db29147916 commit
+e4e48e2b4d76ac305cf76fee1d1c8c0283127d71 commit
+e6ae4ed08704fe3c258ab486b07a36e28c3c238a commit
+e807a993d1807b154294b9875b9d926b6f246d0c commit
+e90f75882526e9bc5a71af64d60ea50092ed0b1d commit`
+	simpleBatchCatFileOutput = `c1f5a5f135b171cc963b822d338000d185f1ae4f
+342
+{"timestamp":"1450315153","v":0,"agent":"Jenkins(1.627) GitNotesJobLogger","url":"https://jenkins-dot-developer-tools-bundle.appspot.com/job/git-appraise/105/"}
+
+{"timestamp":"1450315161","v":0,"agent":"Jenkins(1.627) GitNotesJobLogger","url":"https://jenkins-dot-developer-tools-bundle.appspot.com/job/git-appraise/105/","status":"success"}
+
+31ea4952450bbe5db0d6a7a7903e451925106c0f
+141
+{"timestamp":"1440202534","url":"https://travis-ci.org/google/git-appraise/builds/76722074","agent":"continuous-integration/travis-ci/push"}
+
+bde25250a9f6dc9c56f16befa5a2d73c8558b472
+342
+{"timestamp":"1450434854","v":0,"agent":"Jenkins(1.627) GitNotesJobLogger","url":"https://jenkins-dot-developer-tools-bundle.appspot.com/job/git-appraise/112/"}
+
+{"timestamp":"1450434860","v":0,"agent":"Jenkins(1.627) GitNotesJobLogger","url":"https://jenkins-dot-developer-tools-bundle.appspot.com/job/git-appraise/112/","status":"success"}
+
+3128dc6881bf7647aea90fef1f4fbf883df6a8fe
+342
+{"timestamp":"1457445850","v":0,"agent":"Jenkins(1.627) GitNotesJobLogger","url":"https://jenkins-dot-developer-tools-bundle.appspot.com/job/git-appraise/191/"}
+
+{"timestamp":"1457445856","v":0,"agent":"Jenkins(1.627) GitNotesJobLogger","url":"https://jenkins-dot-developer-tools-bundle.appspot.com/job/git-appraise/191/","status":"success"}
+
+`
+)
+
+func TestSplitBatchCheckOutput(t *testing.T) {
+	buf := bytes.NewBuffer([]byte(simpleBatchCheckOutput))
+	commitsMap, err := splitBatchCheckOutput(buf)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !commitsMap["ddbdcb9d5aa71d35de481789bacece9a2f8138d0"] {
+		t.Fatal("Failed to recognize the first commit as valid")
+	}
+	if !commitsMap["de9ebcdf2a1e93365eefc2739f73f2c68a280c11"] {
+		t.Fatal("Failed to recognize the second commit as valid")
+	}
+	if !commitsMap["e90f75882526e9bc5a71af64d60ea50092ed0b1d"] {
+		t.Fatal("Failed to recognize the last commit as valid")
+	}
+	if commitsMap["df324616ea2bc9bf6fc7025fc80a373ecec687b6"] {
+		t.Fatal("Failed to filter out a missing object")
+	}
+}
+
+func TestSplitBatchCatFileOutput(t *testing.T) {
+	buf := bytes.NewBuffer([]byte(simpleBatchCatFileOutput))
+	notesMap, err := splitBatchCatFileOutput(buf)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(notesMap["c1f5a5f135b171cc963b822d338000d185f1ae4f"]) != 342 {
+		t.Fatal("Failed to parse the contents of the first cat'ed file")
+	}
+	if len(notesMap["31ea4952450bbe5db0d6a7a7903e451925106c0f"]) != 141 {
+		t.Fatal("Failed to parse the contents of the second cat'ed file")
+	}
+	if len(notesMap["3128dc6881bf7647aea90fef1f4fbf883df6a8fe"]) != 342 {
+		t.Fatal("Failed to parse the contents of the last cat'ed file")
+	}
+}
diff --git a/third_party/go/git-appraise/repository/mock_repo.go b/third_party/go/git-appraise/repository/mock_repo.go
new file mode 100644
index 0000000000..2d8debe483
--- /dev/null
+++ b/third_party/go/git-appraise/repository/mock_repo.go
@@ -0,0 +1,613 @@
+/*
+Copyright 2015 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 repository
+
+import (
+	"crypto/sha1"
+	"encoding/json"
+	"fmt"
+	"strings"
+)
+
+// Constants used for testing.
+// We initialize our mock repo with two branches (one of which holds a pending review),
+// and commit history that looks like this:
+//
+//  Master Branch:    A--B--D--E--F--J
+//                     \   /    \  \
+//                       C       \  \
+//                                \  \
+//  Review Branch:                 G--H--I
+//
+// Where commits "B" and "D" represent reviews that have been submitted, and "G"
+// is a pending review.
+const (
+	TestTargetRef          = "refs/heads/master"
+	TestReviewRef          = "refs/heads/ojarjur/mychange"
+	TestAlternateReviewRef = "refs/review/mychange"
+	TestRequestsRef        = "refs/notes/devtools/reviews"
+	TestCommentsRef        = "refs/notes/devtools/discuss"
+
+	TestCommitA = "A"
+	TestCommitB = "B"
+	TestCommitC = "C"
+	TestCommitD = "D"
+	TestCommitE = "E"
+	TestCommitF = "F"
+	TestCommitG = "G"
+	TestCommitH = "H"
+	TestCommitI = "I"
+	TestCommitJ = "J"
+
+	TestRequestB = `{"timestamp": "0000000001", "reviewRef": "refs/heads/ojarjur/mychange", "targetRef": "refs/heads/master", "requester": "ojarjur", "reviewers": ["ojarjur"], "description": "B"}`
+	TestRequestD = `{"timestamp": "0000000002", "reviewRef": "refs/heads/ojarjur/mychange", "targetRef": "refs/heads/master", "requester": "ojarjur", "reviewers": ["ojarjur"], "description": "D"}`
+	TestRequestG = `{"timestamp": "0000000004", "reviewRef": "refs/heads/ojarjur/mychange", "targetRef": "refs/heads/master", "requester": "ojarjur", "reviewers": ["ojarjur"], "description": "G"}
+
+{"timestamp": "0000000005", "reviewRef": "refs/heads/ojarjur/mychange", "targetRef": "refs/heads/master", "requester": "ojarjur", "reviewers": ["ojarjur"], "description": "Updated description of G"}
+
+{"timestamp": "0000000005", "reviewRef": "refs/heads/ojarjur/mychange", "targetRef": "refs/heads/master", "requester": "ojarjur", "reviewers": ["ojarjur"], "description": "Final description of G"}`
+
+	TestDiscussB = `{"timestamp": "0000000001", "author": "ojarjur", "location": {"commit": "B"}, "resolved": true}`
+	TestDiscussD = `{"timestamp": "0000000003", "author": "ojarjur", "location": {"commit": "E"}, "resolved": true}`
+)
+
+type mockCommit struct {
+	Message string   `json:"message,omitempty"`
+	Time    string   `json:"time,omitempty"`
+	Parents []string `json:"parents,omitempty"`
+}
+
+// mockRepoForTest defines an instance of Repo that can be used for testing.
+type mockRepoForTest struct {
+	Head    string
+	Refs    map[string]string            `json:"refs,omitempty"`
+	Commits map[string]mockCommit        `json:"commits,omitempty"`
+	Notes   map[string]map[string]string `json:"notes,omitempty"`
+}
+
+func (r *mockRepoForTest) createCommit(message string, time string, parents []string) (string, error) {
+	newCommit := mockCommit{
+		Message: message,
+		Time:    time,
+		Parents: parents,
+	}
+	newCommitJSON, err := json.Marshal(newCommit)
+	if err != nil {
+		return "", err
+	}
+	newCommitHash := fmt.Sprintf("%x", sha1.Sum([]byte(newCommitJSON)))
+	r.Commits[newCommitHash] = newCommit
+	return newCommitHash, nil
+}
+
+// NewMockRepoForTest returns a mocked-out instance of the Repo interface that has been pre-populated with test data.
+func NewMockRepoForTest() Repo {
+	commitA := mockCommit{
+		Message: "First commit",
+		Time:    "0",
+		Parents: nil,
+	}
+	commitB := mockCommit{
+		Message: "Second commit",
+		Time:    "1",
+		Parents: []string{TestCommitA},
+	}
+	commitC := mockCommit{
+		Message: "No, I'm the second commit",
+		Time:    "1",
+		Parents: []string{TestCommitA},
+	}
+	commitD := mockCommit{
+		Message: "Fourth commit",
+		Time:    "2",
+		Parents: []string{TestCommitB, TestCommitC},
+	}
+	commitE := mockCommit{
+		Message: "Fifth commit",
+		Time:    "3",
+		Parents: []string{TestCommitD},
+	}
+	commitF := mockCommit{
+		Message: "Sixth commit",
+		Time:    "4",
+		Parents: []string{TestCommitE},
+	}
+	commitG := mockCommit{
+		Message: "No, I'm the sixth commit",
+		Time:    "4",
+		Parents: []string{TestCommitE},
+	}
+	commitH := mockCommit{
+		Message: "Seventh commit",
+		Time:    "5",
+		Parents: []string{TestCommitG, TestCommitF},
+	}
+	commitI := mockCommit{
+		Message: "Eighth commit",
+		Time:    "6",
+		Parents: []string{TestCommitH},
+	}
+	commitJ := mockCommit{
+		Message: "No, I'm the eighth commit",
+		Time:    "6",
+		Parents: []string{TestCommitF},
+	}
+	return &mockRepoForTest{
+		Head: TestTargetRef,
+		Refs: map[string]string{
+			TestTargetRef:          TestCommitJ,
+			TestReviewRef:          TestCommitI,
+			TestAlternateReviewRef: TestCommitI,
+		},
+		Commits: map[string]mockCommit{
+			TestCommitA: commitA,
+			TestCommitB: commitB,
+			TestCommitC: commitC,
+			TestCommitD: commitD,
+			TestCommitE: commitE,
+			TestCommitF: commitF,
+			TestCommitG: commitG,
+			TestCommitH: commitH,
+			TestCommitI: commitI,
+			TestCommitJ: commitJ,
+		},
+		Notes: map[string]map[string]string{
+			TestRequestsRef: map[string]string{
+				TestCommitB: TestRequestB,
+				TestCommitD: TestRequestD,
+				TestCommitG: TestRequestG,
+			},
+			TestCommentsRef: map[string]string{
+				TestCommitB: TestDiscussB,
+				TestCommitD: TestDiscussD,
+			},
+		},
+	}
+}
+
+// GetPath returns the path to the repo.
+func (r *mockRepoForTest) GetPath() string { return "~/mockRepo/" }
+
+// GetRepoStateHash returns a hash which embodies the entire current state of a repository.
+func (r *mockRepoForTest) GetRepoStateHash() (string, error) {
+	repoJSON, err := json.Marshal(r)
+	if err != nil {
+		return "", err
+	}
+	return fmt.Sprintf("%x", sha1.Sum([]byte(repoJSON))), nil
+}
+
+// GetUserEmail returns the email address that the user has used to configure git.
+func (r *mockRepoForTest) GetUserEmail() (string, error) { return "user@example.com", nil }
+
+// GetUserSigningKey returns the key id the user has configured for
+// sigining git artifacts.
+func (r *mockRepoForTest) GetUserSigningKey() (string, error) {
+	return "gpgsig", nil
+}
+
+// GetCoreEditor returns the name of the editor that the user has used to configure git.
+func (r *mockRepoForTest) GetCoreEditor() (string, error) { return "vi", nil }
+
+// GetSubmitStrategy returns the way in which a review is submitted
+func (r *mockRepoForTest) GetSubmitStrategy() (string, error) { return "merge", nil }
+
+// HasUncommittedChanges returns true if there are local, uncommitted changes.
+func (r *mockRepoForTest) HasUncommittedChanges() (bool, error) { return false, nil }
+
+func (r *mockRepoForTest) resolveLocalRef(ref string) (string, error) {
+	if ref == "HEAD" {
+		ref = r.Head
+	}
+	if commit, ok := r.Refs[ref]; ok {
+		return commit, nil
+	}
+	if _, ok := r.Commits[ref]; ok {
+		return ref, nil
+	}
+	return "", fmt.Errorf("The ref %q does not exist", ref)
+}
+
+// VerifyCommit verifies that the supplied hash points to a known commit.
+func (r *mockRepoForTest) VerifyCommit(hash string) error {
+	if _, ok := r.Commits[hash]; !ok {
+		return fmt.Errorf("The given hash %q is not a known commit", hash)
+	}
+	return nil
+}
+
+// VerifyGitRef verifies that the supplied ref points to a known commit.
+func (r *mockRepoForTest) VerifyGitRef(ref string) error {
+	_, err := r.resolveLocalRef(ref)
+	return err
+}
+
+// GetHeadRef returns the ref that is the current HEAD.
+func (r *mockRepoForTest) GetHeadRef() (string, error) { return r.Head, nil }
+
+// GetCommitHash returns the hash of the commit pointed to by the given ref.
+func (r *mockRepoForTest) GetCommitHash(ref string) (string, error) {
+	err := r.VerifyGitRef(ref)
+	if err != nil {
+		return "", err
+	}
+	return r.resolveLocalRef(ref)
+}
+
+// ResolveRefCommit returns the commit pointed to by the given ref, which may be a remote ref.
+//
+// This differs from GetCommitHash which only works on exact matches, in that it will try to
+// intelligently handle the scenario of a ref not existing locally, but being known to exist
+// in a remote repo.
+//
+// This method should be used when a command may be performed by either the reviewer or the
+// reviewee, while GetCommitHash should be used when the encompassing command should only be
+// performed by the reviewee.
+func (r *mockRepoForTest) ResolveRefCommit(ref string) (string, error) {
+	if commit, err := r.resolveLocalRef(ref); err == nil {
+		return commit, err
+	}
+	return r.resolveLocalRef(strings.Replace(ref, "refs/heads/", "refs/remotes/origin/", 1))
+}
+
+func (r *mockRepoForTest) getCommit(ref string) (mockCommit, error) {
+	commit, err := r.resolveLocalRef(ref)
+	return r.Commits[commit], err
+}
+
+// GetCommitMessage returns the message stored in the commit pointed to by the given ref.
+func (r *mockRepoForTest) GetCommitMessage(ref string) (string, error) {
+	commit, err := r.getCommit(ref)
+	if err != nil {
+		return "", err
+	}
+	return commit.Message, nil
+}
+
+// GetCommitTime returns the commit time of the commit pointed to by the given ref.
+func (r *mockRepoForTest) GetCommitTime(ref string) (string, error) {
+	commit, err := r.getCommit(ref)
+	if err != nil {
+		return "", err
+	}
+	return commit.Time, nil
+}
+
+// GetLastParent returns the last parent of the given commit (as ordered by git).
+func (r *mockRepoForTest) GetLastParent(ref string) (string, error) {
+	commit, err := r.getCommit(ref)
+	if len(commit.Parents) > 0 {
+		return commit.Parents[len(commit.Parents)-1], err
+	}
+	return "", err
+}
+
+// GetCommitDetails returns the details of a commit's metadata.
+func (r *mockRepoForTest) GetCommitDetails(ref string) (*CommitDetails, error) {
+	commit, err := r.getCommit(ref)
+	if err != nil {
+		return nil, err
+	}
+	var details CommitDetails
+	details.Author = "Test Author"
+	details.AuthorEmail = "author@example.com"
+	details.Summary = commit.Message
+	details.Time = commit.Time
+	details.Parents = commit.Parents
+	return &details, nil
+}
+
+// ancestors returns the breadth-first traversal of a commit's ancestors
+func (r *mockRepoForTest) ancestors(commit string) ([]string, error) {
+	queue := []string{commit}
+	var ancestors []string
+	for queue != nil {
+		var nextQueue []string
+		for _, c := range queue {
+			commit, err := r.getCommit(c)
+			if err != nil {
+				return nil, err
+			}
+			parents := commit.Parents
+			nextQueue = append(nextQueue, parents...)
+			ancestors = append(ancestors, parents...)
+		}
+		queue = nextQueue
+	}
+	return ancestors, nil
+}
+
+// IsAncestor determines if the first argument points to a commit that is an ancestor of the second.
+func (r *mockRepoForTest) IsAncestor(ancestor, descendant string) (bool, error) {
+	var err error
+	ancestor, err = r.resolveLocalRef(ancestor)
+	if err != nil {
+		return false, err
+	}
+	descendant, err = r.resolveLocalRef(descendant)
+	if err != nil {
+		return false, err
+	}
+	if ancestor == descendant {
+		return true, nil
+	}
+	descendantCommit, err := r.getCommit(descendant)
+	if err != nil {
+		return false, err
+	}
+	for _, parent := range descendantCommit.Parents {
+		if t, e := r.IsAncestor(ancestor, parent); e == nil && t {
+			return true, nil
+		}
+	}
+	return false, nil
+}
+
+// MergeBase determines if the first commit that is an ancestor of the two arguments.
+func (r *mockRepoForTest) MergeBase(a, b string) (string, error) {
+	ancestors, err := r.ancestors(a)
+	if err != nil {
+		return "", err
+	}
+	for _, ancestor := range ancestors {
+		if t, e := r.IsAncestor(ancestor, b); e == nil && t {
+			return ancestor, nil
+		}
+	}
+	return "", nil
+}
+
+// Diff computes the diff between two given commits.
+func (r *mockRepoForTest) Diff(left, right string, diffArgs ...string) (string, error) {
+	return fmt.Sprintf("Diff between %q and %q", left, right), nil
+}
+
+// Show returns the contents of the given file at the given commit.
+func (r *mockRepoForTest) Show(commit, path string) (string, error) {
+	return fmt.Sprintf("%s:%s", commit, path), nil
+}
+
+// SwitchToRef changes the currently-checked-out ref.
+func (r *mockRepoForTest) SwitchToRef(ref string) error {
+	r.Head = ref
+	return nil
+}
+
+// ArchiveRef adds the current commit pointed to by the 'ref' argument
+// under the ref specified in the 'archive' argument.
+//
+// Both the 'ref' and 'archive' arguments are expected to be the fully
+// qualified names of git refs (e.g. 'refs/heads/my-change' or
+// 'refs/archive/devtools').
+//
+// If the ref pointed to by the 'archive' argument does not exist
+// yet, then it will be created.
+func (r *mockRepoForTest) ArchiveRef(ref, archive string) error {
+	commitToArchive, err := r.resolveLocalRef(ref)
+	if err != nil {
+		return err
+	}
+	var archiveParents []string
+	if archiveCommit, err := r.resolveLocalRef(archive); err == nil {
+		archiveParents = []string{archiveCommit, commitToArchive}
+	} else {
+		archiveParents = []string{commitToArchive}
+	}
+	archiveCommit, err := r.createCommit("Archiving", "Nowish", archiveParents)
+	if err != nil {
+		return err
+	}
+	r.Refs[archive] = archiveCommit
+	return nil
+}
+
+// MergeRef merges the given ref into the current one.
+//
+// The ref argument is the ref to merge, and fastForward indicates that the
+// current ref should only move forward, as opposed to creating a bubble merge.
+func (r *mockRepoForTest) MergeRef(ref string, fastForward bool, messages ...string) error {
+	newCommitHash, err := r.resolveLocalRef(ref)
+	if err != nil {
+		return err
+	}
+	if !fastForward {
+		origCommit, err := r.resolveLocalRef(r.Head)
+		if err != nil {
+			return err
+		}
+		newCommit, err := r.getCommit(ref)
+		if err != nil {
+			return err
+		}
+		message := strings.Join(messages, "\n\n")
+		time := newCommit.Time
+		parents := []string{origCommit, newCommitHash}
+		newCommitHash, err = r.createCommit(message, time, parents)
+		if err != nil {
+			return err
+		}
+	}
+	r.Refs[r.Head] = newCommitHash
+	return nil
+}
+
+// MergeAndSignRef merges the given ref into the current one and signs the
+// merge.
+//
+// The ref argument is the ref to merge, and fastForward indicates that the
+// current ref should only move forward, as opposed to creating a bubble merge.
+func (r *mockRepoForTest) MergeAndSignRef(ref string, fastForward bool,
+	messages ...string) error {
+	return nil
+}
+
+// RebaseRef rebases the current ref onto the given one.
+func (r *mockRepoForTest) RebaseRef(ref string) error {
+	parentHash := r.Refs[ref]
+	origCommit, err := r.getCommit(r.Head)
+	if err != nil {
+		return err
+	}
+	newCommitHash, err := r.createCommit(origCommit.Message, origCommit.Time, []string{parentHash})
+	if err != nil {
+		return err
+	}
+	if strings.HasPrefix(r.Head, "refs/heads/") {
+		r.Refs[r.Head] = newCommitHash
+	} else {
+		// The current head is not a branch, so updating
+		// it should leave us in a detached-head state.
+		r.Head = newCommitHash
+	}
+	return nil
+}
+
+// RebaseAndSignRef rebases the current ref onto the given one and signs the
+// result.
+func (r *mockRepoForTest) RebaseAndSignRef(ref string) error { return nil }
+
+// ListCommits returns the list of commits reachable from the given ref.
+//
+// The generated list is in chronological order (with the oldest commit first).
+//
+// If the specified ref does not exist, then this method returns an empty result.
+func (r *mockRepoForTest) ListCommits(ref string) []string { return nil }
+
+// ListCommitsBetween returns the list of commits between the two given revisions.
+//
+// The "from" parameter is the starting point (exclusive), and the "to"
+// parameter is the ending point (inclusive).
+//
+// The "from" commit does not need to be an ancestor of the "to" commit. If it
+// is not, then the merge base of the two is used as the starting point.
+// Admittedly, this makes calling these the "between" commits is a bit of a
+// misnomer, but it also makes the method easier to use when you want to
+// generate the list of changes in a feature branch, as it eliminates the need
+// to explicitly calculate the merge base. This also makes the semantics of the
+// method compatible with git's built-in "rev-list" command.
+//
+// The generated list is in chronological order (with the oldest commit first).
+func (r *mockRepoForTest) ListCommitsBetween(from, to string) ([]string, error) {
+	commits := []string{to}
+	potentialCommits, _ := r.ancestors(to)
+	for _, commit := range potentialCommits {
+		blocked, err := r.IsAncestor(commit, from)
+		if err != nil {
+			return nil, err
+		}
+		if !blocked {
+			commits = append(commits, commit)
+		}
+	}
+	return commits, nil
+}
+
+// GetNotes reads the notes from the given ref that annotate the given revision.
+func (r *mockRepoForTest) GetNotes(notesRef, revision string) []Note {
+	notesText := r.Notes[notesRef][revision]
+	var notes []Note
+	for _, line := range strings.Split(notesText, "\n") {
+		notes = append(notes, Note(line))
+	}
+	return notes
+}
+
+// GetAllNotes reads the contents of the notes under the given ref for every commit.
+//
+// The returned value is a mapping from commit hash to the list of notes for that commit.
+//
+// This is the batch version of the corresponding GetNotes(...) method.
+func (r *mockRepoForTest) GetAllNotes(notesRef string) (map[string][]Note, error) {
+	notesMap := make(map[string][]Note)
+	for _, commit := range r.ListNotedRevisions(notesRef) {
+		notesMap[commit] = r.GetNotes(notesRef, commit)
+	}
+	return notesMap, nil
+}
+
+// AppendNote appends a note to a revision under the given ref.
+func (r *mockRepoForTest) AppendNote(ref, revision string, note Note) error {
+	existingNotes := r.Notes[ref][revision]
+	newNotes := existingNotes + "\n" + string(note)
+	r.Notes[ref][revision] = newNotes
+	return nil
+}
+
+// ListNotedRevisions returns the collection of revisions that are annotated by notes in the given ref.
+func (r *mockRepoForTest) ListNotedRevisions(notesRef string) []string {
+	var revisions []string
+	for revision := range r.Notes[notesRef] {
+		if _, ok := r.Commits[revision]; ok {
+			revisions = append(revisions, revision)
+		}
+	}
+	return revisions
+}
+
+// PushNotes pushes git notes to a remote repo.
+func (r *mockRepoForTest) PushNotes(remote, notesRefPattern string) error { return nil }
+
+// PullNotes fetches the contents of the given notes ref from a remote repo,
+// and then merges them with the corresponding local notes using the
+// "cat_sort_uniq" strategy.
+func (r *mockRepoForTest) PullNotes(remote, notesRefPattern string) error { return nil }
+
+// PushNotesAndArchive pushes the given notes and archive refs to a remote repo.
+func (r *mockRepoForTest) PushNotesAndArchive(remote, notesRefPattern, archiveRefPattern string) error {
+	return nil
+}
+
+// PullNotesAndArchive fetches the contents of the notes and archives refs from
+// a remote repo, and merges them with the corresponding local refs.
+//
+// For notes refs, we assume that every note can be automatically merged using
+// the 'cat_sort_uniq' strategy (the git-appraise schemas fit that requirement),
+// so we automatically merge the remote notes into the local notes.
+//
+// For "archive" refs, they are expected to be used solely for maintaining
+// reachability of commits that are part of the history of any reviews,
+// so we do not maintain any consistency with their tree objects. Instead,
+// we merely ensure that their history graph includes every commit that we
+// intend to keep.
+func (r *mockRepoForTest) PullNotesAndArchive(remote, notesRefPattern, archiveRefPattern string) error {
+	return nil
+}
+
+// MergeNotes merges in the remote's state of the archives reference into
+// the local repository's.
+func (repo *mockRepoForTest) MergeNotes(remote, notesRefPattern string) error {
+	return nil
+}
+
+// MergeArchives merges in the remote's state of the archives reference into
+// the local repository's.
+func (repo *mockRepoForTest) MergeArchives(remote,
+	archiveRefPattern string) error {
+	return nil
+}
+
+// FetchAndReturnNewReviewHashes fetches the notes "branches" and then susses
+// out the IDs (the revision the review points to) of any new reviews, then
+// returns that list of IDs.
+//
+// This is accomplished by determining which files in the notes tree have
+// changed because the _names_ of these files correspond to the revisions they
+// point to.
+func (repo *mockRepoForTest) FetchAndReturnNewReviewHashes(remote, notesRefPattern,
+	archiveRefPattern string) ([]string, error) {
+	return nil, nil
+}
diff --git a/third_party/go/git-appraise/repository/repo.go b/third_party/go/git-appraise/repository/repo.go
new file mode 100644
index 0000000000..91acd177ed
--- /dev/null
+++ b/third_party/go/git-appraise/repository/repo.go
@@ -0,0 +1,221 @@
+/*
+Copyright 2015 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 repository contains helper methods for working with a Git repo.
+package repository
+
+// Note represents the contents of a git-note
+type Note []byte
+
+// CommitDetails represents the contents of a commit.
+type CommitDetails struct {
+	Author      string   `json:"author,omitempty"`
+	AuthorEmail string   `json:"authorEmail,omitempty"`
+	Tree        string   `json:"tree,omitempty"`
+	Time        string   `json:"time,omitempty"`
+	Parents     []string `json:"parents,omitempty"`
+	Summary     string   `json:"summary,omitempty"`
+}
+
+// Repo represents a source code repository.
+type Repo interface {
+	// GetPath returns the path to the repo.
+	GetPath() string
+
+	// GetRepoStateHash returns a hash which embodies the entire current state of a repository.
+	GetRepoStateHash() (string, error)
+
+	// GetUserEmail returns the email address that the user has used to configure git.
+	GetUserEmail() (string, error)
+
+	// GetUserSigningKey returns the key id the user has configured for
+	// sigining git artifacts.
+	GetUserSigningKey() (string, error)
+
+	// GetCoreEditor returns the name of the editor that the user has used to configure git.
+	GetCoreEditor() (string, error)
+
+	// GetSubmitStrategy returns the way in which a review is submitted
+	GetSubmitStrategy() (string, error)
+
+	// HasUncommittedChanges returns true if there are local, uncommitted changes.
+	HasUncommittedChanges() (bool, error)
+
+	// VerifyCommit verifies that the supplied hash points to a known commit.
+	VerifyCommit(hash string) error
+
+	// VerifyGitRef verifies that the supplied ref points to a known commit.
+	VerifyGitRef(ref string) error
+
+	// GetHeadRef returns the ref that is the current HEAD.
+	GetHeadRef() (string, error)
+
+	// GetCommitHash returns the hash of the commit pointed to by the given ref.
+	GetCommitHash(ref string) (string, error)
+
+	// ResolveRefCommit returns the commit pointed to by the given ref, which may be a remote ref.
+	//
+	// This differs from GetCommitHash which only works on exact matches, in that it will try to
+	// intelligently handle the scenario of a ref not existing locally, but being known to exist
+	// in a remote repo.
+	//
+	// This method should be used when a command may be performed by either the reviewer or the
+	// reviewee, while GetCommitHash should be used when the encompassing command should only be
+	// performed by the reviewee.
+	ResolveRefCommit(ref string) (string, error)
+
+	// GetCommitMessage returns the message stored in the commit pointed to by the given ref.
+	GetCommitMessage(ref string) (string, error)
+
+	// GetCommitTime returns the commit time of the commit pointed to by the given ref.
+	GetCommitTime(ref string) (string, error)
+
+	// GetLastParent returns the last parent of the given commit (as ordered by git).
+	GetLastParent(ref string) (string, error)
+
+	// GetCommitDetails returns the details of a commit's metadata.
+	GetCommitDetails(ref string) (*CommitDetails, error)
+
+	// MergeBase determines if the first commit that is an ancestor of the two arguments.
+	MergeBase(a, b string) (string, error)
+
+	// IsAncestor determines if the first argument points to a commit that is an ancestor of the second.
+	IsAncestor(ancestor, descendant string) (bool, error)
+
+	// Diff computes the diff between two given commits.
+	Diff(left, right string, diffArgs ...string) (string, error)
+
+	// Show returns the contents of the given file at the given commit.
+	Show(commit, path string) (string, error)
+
+	// SwitchToRef changes the currently-checked-out ref.
+	SwitchToRef(ref string) error
+
+	// ArchiveRef adds the current commit pointed to by the 'ref' argument
+	// under the ref specified in the 'archive' argument.
+	//
+	// Both the 'ref' and 'archive' arguments are expected to be the fully
+	// qualified names of git refs (e.g. 'refs/heads/my-change' or
+	// 'refs/archive/devtools').
+	//
+	// If the ref pointed to by the 'archive' argument does not exist
+	// yet, then it will be created.
+	ArchiveRef(ref, archive string) error
+
+	// MergeRef merges the given ref into the current one.
+	//
+	// The ref argument is the ref to merge, and fastForward indicates that the
+	// current ref should only move forward, as opposed to creating a bubble merge.
+	// The messages argument(s) provide text that should be included in the default
+	// merge commit message (separated by blank lines).
+	MergeRef(ref string, fastForward bool, messages ...string) error
+
+	// MergeAndSignRef merges the given ref into the current one and signs the
+	// merge.
+	//
+	// The ref argument is the ref to merge, and fastForward indicates that the
+	// current ref should only move forward, as opposed to creating a bubble merge.
+	// The messages argument(s) provide text that should be included in the default
+	// merge commit message (separated by blank lines).
+	MergeAndSignRef(ref string, fastForward bool, messages ...string) error
+
+	// RebaseRef rebases the current ref onto the given one.
+	RebaseRef(ref string) error
+
+	// RebaseAndSignRef rebases the current ref onto the given one and signs
+	// the result.
+	RebaseAndSignRef(ref string) error
+
+	// ListCommits returns the list of commits reachable from the given ref.
+	//
+	// The generated list is in chronological order (with the oldest commit first).
+	//
+	// If the specified ref does not exist, then this method returns an empty result.
+	ListCommits(ref string) []string
+
+	// ListCommitsBetween returns the list of commits between the two given revisions.
+	//
+	// The "from" parameter is the starting point (exclusive), and the "to"
+	// parameter is the ending point (inclusive).
+	//
+	// The "from" commit does not need to be an ancestor of the "to" commit. If it
+	// is not, then the merge base of the two is used as the starting point.
+	// Admittedly, this makes calling these the "between" commits is a bit of a
+	// misnomer, but it also makes the method easier to use when you want to
+	// generate the list of changes in a feature branch, as it eliminates the need
+	// to explicitly calculate the merge base. This also makes the semantics of the
+	// method compatible with git's built-in "rev-list" command.
+	//
+	// The generated list is in chronological order (with the oldest commit first).
+	ListCommitsBetween(from, to string) ([]string, error)
+
+	// GetNotes reads the notes from the given ref that annotate the given revision.
+	GetNotes(notesRef, revision string) []Note
+
+	// GetAllNotes reads the contents of the notes under the given ref for every commit.
+	//
+	// The returned value is a mapping from commit hash to the list of notes for that commit.
+	//
+	// This is the batch version of the corresponding GetNotes(...) method.
+	GetAllNotes(notesRef string) (map[string][]Note, error)
+
+	// AppendNote appends a note to a revision under the given ref.
+	AppendNote(ref, revision string, note Note) error
+
+	// ListNotedRevisions returns the collection of revisions that are annotated by notes in the given ref.
+	ListNotedRevisions(notesRef string) []string
+
+	// PushNotes pushes git notes to a remote repo.
+	PushNotes(remote, notesRefPattern string) error
+
+	// PullNotes fetches the contents of the given notes ref from a remote repo,
+	// and then merges them with the corresponding local notes using the
+	// "cat_sort_uniq" strategy.
+	PullNotes(remote, notesRefPattern string) error
+
+	// PushNotesAndArchive pushes the given notes and archive refs to a remote repo.
+	PushNotesAndArchive(remote, notesRefPattern, archiveRefPattern string) error
+
+	// PullNotesAndArchive fetches the contents of the notes and archives refs from
+	// a remote repo, and merges them with the corresponding local refs.
+	//
+	// For notes refs, we assume that every note can be automatically merged using
+	// the 'cat_sort_uniq' strategy (the git-appraise schemas fit that requirement),
+	// so we automatically merge the remote notes into the local notes.
+	//
+	// For "archive" refs, they are expected to be used solely for maintaining
+	// reachability of commits that are part of the history of any reviews,
+	// so we do not maintain any consistency with their tree objects. Instead,
+	// we merely ensure that their history graph includes every commit that we
+	// intend to keep.
+	PullNotesAndArchive(remote, notesRefPattern, archiveRefPattern string) error
+
+	// MergeNotes merges in the remote's state of the archives reference into
+	// the local repository's.
+	MergeNotes(remote, notesRefPattern string) error
+	// MergeArchives merges in the remote's state of the archives reference
+	// into the local repository's.
+	MergeArchives(remote, archiveRefPattern string) error
+
+	// FetchAndReturnNewReviewHashes fetches the notes "branches" and then
+	// susses out the IDs (the revision the review points to) of any new
+	// reviews, then returns that list of IDs.
+	//
+	// This is accomplished by determining which files in the notes tree have
+	// changed because the _names_ of these files correspond to the revisions
+	// they point to.
+	FetchAndReturnNewReviewHashes(remote, notesRefPattern, archiveRefPattern string) ([]string, error)
+}
diff --git a/third_party/go/git-appraise/review/analyses/analyses.go b/third_party/go/git-appraise/review/analyses/analyses.go
new file mode 100644
index 0000000000..4828f3b230
--- /dev/null
+++ b/third_party/go/git-appraise/review/analyses/analyses.go
@@ -0,0 +1,160 @@
+/*
+Copyright 2015 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 analyses defines the internal representation of static analysis reports.
+package analyses
+
+import (
+	"encoding/json"
+	"io/ioutil"
+	"net/http"
+	"sort"
+	"strconv"
+
+	"github.com/google/git-appraise/repository"
+)
+
+const (
+	// Ref defines the git-notes ref that we expect to contain analysis reports.
+	Ref = "refs/notes/devtools/analyses"
+
+	// StatusLooksGoodToMe is the status string representing that analyses reported no messages.
+	StatusLooksGoodToMe = "lgtm"
+	// StatusForYourInformation is the status string representing that analyses reported informational messages.
+	StatusForYourInformation = "fyi"
+	// StatusNeedsMoreWork is the status string representing that analyses reported error messages.
+	StatusNeedsMoreWork = "nmw"
+
+	// FormatVersion defines the latest version of the request format supported by the tool.
+	FormatVersion = 0
+)
+
+// Report represents a build/test status report generated by analyses tool.
+// Every field is optional.
+type Report struct {
+	Timestamp string `json:"timestamp,omitempty"`
+	URL       string `json:"url,omitempty"`
+	Status    string `json:"status,omitempty"`
+	// Version represents the version of the metadata format.
+	Version int `json:"v,omitempty"`
+}
+
+// LocationRange represents the location within a source file that an analysis message covers.
+type LocationRange struct {
+	StartLine   uint32 `json:"start_line,omitempty"`
+	StartColumn uint32 `json:"start_column,omitempty"`
+	EndLine     uint32 `json:"end_line,omitempty"`
+	EndColumn   uint32 `json:"end_column,omitempty"`
+}
+
+// Location represents the location within a source tree that an analysis message covers.
+type Location struct {
+	Path  string         `json:"path,omitempty"`
+	Range *LocationRange `json:"range,omitempty"`
+}
+
+// Note represents a single analysis message.
+type Note struct {
+	Location    *Location `json:"location,omitempty"`
+	Category    string    `json:"category,omitempty"`
+	Description string    `json:"description"`
+}
+
+// AnalyzeResponse represents the response from a static-analysis tool.
+type AnalyzeResponse struct {
+	Notes []Note `json:"note,omitempty"`
+}
+
+// ReportDetails represents an entire static analysis run (which might include multiple analysis tools).
+type ReportDetails struct {
+	AnalyzeResponse []AnalyzeResponse `json:"analyze_response,omitempty"`
+}
+
+// GetLintReportResult downloads the details of a lint report and returns the responses embedded in it.
+func (analysesReport Report) GetLintReportResult() ([]AnalyzeResponse, error) {
+	if analysesReport.URL == "" {
+		return nil, nil
+	}
+	res, err := http.Get(analysesReport.URL)
+	if err != nil {
+		return nil, err
+	}
+	analysesResults, err := ioutil.ReadAll(res.Body)
+	res.Body.Close()
+	if err != nil {
+		return nil, err
+	}
+	var details ReportDetails
+	err = json.Unmarshal([]byte(analysesResults), &details)
+	if err != nil {
+		return nil, err
+	}
+	return details.AnalyzeResponse, nil
+}
+
+// GetNotes downloads the details of an analyses report and returns the notes embedded in it.
+func (analysesReport Report) GetNotes() ([]Note, error) {
+	reportResults, err := analysesReport.GetLintReportResult()
+	if err != nil {
+		return nil, err
+	}
+	var reportNotes []Note
+	for _, reportResult := range reportResults {
+		reportNotes = append(reportNotes, reportResult.Notes...)
+	}
+	return reportNotes, nil
+}
+
+// Parse parses an analysis report from a git note.
+func Parse(note repository.Note) (Report, error) {
+	bytes := []byte(note)
+	var report Report
+	err := json.Unmarshal(bytes, &report)
+	return report, err
+}
+
+// GetLatestAnalysesReport takes a collection of analysis reports, and returns the one with the most recent timestamp.
+func GetLatestAnalysesReport(reports []Report) (*Report, error) {
+	timestampReportMap := make(map[int]*Report)
+	var timestamps []int
+
+	for _, report := range reports {
+		timestamp, err := strconv.Atoi(report.Timestamp)
+		if err != nil {
+			return nil, err
+		}
+		timestamps = append(timestamps, timestamp)
+		timestampReportMap[timestamp] = &report
+	}
+	if len(timestamps) == 0 {
+		return nil, nil
+	}
+	sort.Sort(sort.Reverse(sort.IntSlice(timestamps)))
+	return timestampReportMap[timestamps[0]], nil
+}
+
+// ParseAllValid takes collection of git notes and tries to parse a analyses report
+// from each one. Any notes that are not valid analyses reports get ignored.
+func ParseAllValid(notes []repository.Note) []Report {
+	var reports []Report
+	for _, note := range notes {
+		report, err := Parse(note)
+		if err == nil && report.Version == FormatVersion {
+			reports = append(reports, report)
+		}
+	}
+	return reports
+}
diff --git a/third_party/go/git-appraise/review/analyses/analyses_test.go b/third_party/go/git-appraise/review/analyses/analyses_test.go
new file mode 100644
index 0000000000..00a811ef6a
--- /dev/null
+++ b/third_party/go/git-appraise/review/analyses/analyses_test.go
@@ -0,0 +1,77 @@
+/*
+Copyright 2015 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 analyses
+
+import (
+	"fmt"
+	"github.com/google/git-appraise/repository"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+)
+
+const (
+	mockOldReport = `{"timestamp": "0", "url": "https://this-url-does-not-exist.test/analysis.json"}`
+	mockNewReport = `{"timestamp": "1", "url": "%s"}`
+	mockResults   = `{
+  "analyze_response": [{
+    "note": [{
+      "location": {
+        "path": "file.txt",
+        "range": {
+          "start_line": 5
+        }
+      },
+      "category": "test",
+      "description": "This is a test"
+    }]
+  }]
+}`
+)
+
+func mockHandler(t *testing.T) func(http.ResponseWriter, *http.Request) {
+	return func(w http.ResponseWriter, r *http.Request) {
+		t.Log(r)
+		fmt.Fprintln(w, mockResults)
+		w.WriteHeader(http.StatusOK)
+	}
+}
+
+func TestGetLatestResult(t *testing.T) {
+	mockServer := httptest.NewServer(http.HandlerFunc(mockHandler(t)))
+	defer mockServer.Close()
+
+	reports := ParseAllValid([]repository.Note{
+		repository.Note([]byte(mockOldReport)),
+		repository.Note([]byte(fmt.Sprintf(mockNewReport, mockServer.URL))),
+	})
+
+	report, err := GetLatestAnalysesReport(reports)
+	if err != nil {
+		t.Fatal("Unexpected error while parsing analysis reports", err)
+	}
+	if report == nil {
+		t.Fatal("Unexpected nil report")
+	}
+	reportResult, err := report.GetLintReportResult()
+	if err != nil {
+		t.Fatal("Unexpected error while reading the latest report's results", err)
+	}
+	if len(reportResult) != 1 {
+		t.Fatal("Unexpected report result", reportResult)
+	}
+}
diff --git a/third_party/go/git-appraise/review/ci/ci.go b/third_party/go/git-appraise/review/ci/ci.go
new file mode 100644
index 0000000000..b2cfd22743
--- /dev/null
+++ b/third_party/go/git-appraise/review/ci/ci.go
@@ -0,0 +1,95 @@
+/*
+Copyright 2015 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 ci defines the internal representation of a continuous integration reports.
+package ci
+
+import (
+	"encoding/json"
+	"github.com/google/git-appraise/repository"
+	"sort"
+	"strconv"
+)
+
+const (
+	// Ref defines the git-notes ref that we expect to contain CI reports.
+	Ref = "refs/notes/devtools/ci"
+
+	// StatusSuccess is the status string representing that a build and/or test passed.
+	StatusSuccess = "success"
+	// StatusFailure is the status string representing that a build and/or test failed.
+	StatusFailure = "failure"
+
+	// FormatVersion defines the latest version of the request format supported by the tool.
+	FormatVersion = 0
+)
+
+// Report represents a build/test status report generated by a continuous integration tool.
+//
+// Every field is optional.
+type Report struct {
+	Timestamp string `json:"timestamp,omitempty"`
+	URL       string `json:"url,omitempty"`
+	Status    string `json:"status,omitempty"`
+	Agent     string `json:"agent,omitempty"`
+	// Version represents the version of the metadata format.
+	Version int `json:"v,omitempty"`
+}
+
+// Parse parses a CI report from a git note.
+func Parse(note repository.Note) (Report, error) {
+	bytes := []byte(note)
+	var report Report
+	err := json.Unmarshal(bytes, &report)
+	return report, err
+}
+
+// GetLatestCIReport takes the collection of reports and returns the one with the most recent timestamp.
+func GetLatestCIReport(reports []Report) (*Report, error) {
+	timestampReportMap := make(map[int]*Report)
+	var timestamps []int
+
+	for _, report := range reports {
+		timestamp, err := strconv.Atoi(report.Timestamp)
+		if err != nil {
+			return nil, err
+		}
+		timestamps = append(timestamps, timestamp)
+		timestampReportMap[timestamp] = &report
+	}
+	if len(timestamps) == 0 {
+		return nil, nil
+	}
+	sort.Sort(sort.Reverse(sort.IntSlice(timestamps)))
+	return timestampReportMap[timestamps[0]], nil
+}
+
+// ParseAllValid takes collection of git notes and tries to parse a CI report
+// from each one. Any notes that are not valid CI reports get ignored, as we
+// expect the git notes to be a heterogenous list, with only some of them
+// being valid CI status reports.
+func ParseAllValid(notes []repository.Note) []Report {
+	var reports []Report
+	for _, note := range notes {
+		report, err := Parse(note)
+		if err == nil && report.Version == FormatVersion {
+			if report.Status == "" || report.Status == StatusSuccess || report.Status == StatusFailure {
+				reports = append(reports, report)
+			}
+		}
+	}
+	return reports
+}
diff --git a/third_party/go/git-appraise/review/ci/ci_test.go b/third_party/go/git-appraise/review/ci/ci_test.go
new file mode 100644
index 0000000000..c141f053d9
--- /dev/null
+++ b/third_party/go/git-appraise/review/ci/ci_test.go
@@ -0,0 +1,85 @@
+/*
+Copyright 2015 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 ci
+
+import (
+	"github.com/google/git-appraise/repository"
+	"testing"
+)
+
+const testCINote1 = `{
+	"Timestamp": "4",
+	"URL": "www.google.com",
+	"Status": "success"
+}`
+
+const testCINote2 = `{
+	"Timestamp": "16",
+	"URL": "www.google.com",
+	"Status": "failure"
+}`
+
+const testCINote3 = `{
+	"Timestamp": "30",
+	"URL": "www.google.com",
+	"Status": "something else"
+}`
+
+const testCINote4 = `{
+	"Timestamp": "28",
+	"URL": "www.google.com",
+	"Status": "success"
+}`
+
+const testCINote5 = `{
+	"Timestamp": "27",
+	"URL": "www.google.com",
+	"Status": "success"
+}`
+
+func TestCIReport(t *testing.T) {
+	latestReport, err := GetLatestCIReport(ParseAllValid([]repository.Note{
+		repository.Note(testCINote1),
+		repository.Note(testCINote2),
+	}))
+	if err != nil {
+		t.Fatal("Failed to properly fetch the latest report", err)
+	}
+	expected, err := Parse(repository.Note(testCINote2))
+	if err != nil {
+		t.Fatal("Failed to parse the expected report", err)
+	}
+	if *latestReport != expected {
+		t.Fatal("This is not the latest ", latestReport)
+	}
+	latestReport, err = GetLatestCIReport(ParseAllValid([]repository.Note{
+		repository.Note(testCINote1),
+		repository.Note(testCINote2),
+		repository.Note(testCINote3),
+		repository.Note(testCINote4),
+	}))
+	if err != nil {
+		t.Fatal("Failed to properly fetch the latest report", err)
+	}
+	expected, err = Parse(repository.Note(testCINote4))
+	if err != nil {
+		t.Fatal("Failed to parse the expected report", err)
+	}
+	if *latestReport != expected {
+		t.Fatal("This is not the latest ", latestReport)
+	}
+}
diff --git a/third_party/go/git-appraise/review/comment/comment.go b/third_party/go/git-appraise/review/comment/comment.go
new file mode 100644
index 0000000000..b1dea49c13
--- /dev/null
+++ b/third_party/go/git-appraise/review/comment/comment.go
@@ -0,0 +1,266 @@
+/*
+Copyright 2015 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 comment defines the internal representation of a review comment.
+package comment
+
+import (
+	"crypto/sha1"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/google/git-appraise/repository"
+	"github.com/google/git-appraise/review/gpg"
+)
+
+// Ref defines the git-notes ref that we expect to contain review comments.
+const Ref = "refs/notes/devtools/discuss"
+
+// FormatVersion defines the latest version of the comment format supported by the tool.
+const FormatVersion = 0
+
+// ErrInvalidRange inidcates an error during parsing of a user-defined file
+// range
+var ErrInvalidRange = errors.New("invalid file location range. The required form is StartLine[+StartColumn][:EndLine[+EndColumn]]. The first line in a file is considered to be line 1")
+
+// Range represents the range of text that is under discussion.
+type Range struct {
+	StartLine   uint32 `json:"startLine"`
+	StartColumn uint32 `json:"startColumn,omitempty"`
+	EndLine     uint32 `json:"endLine,omitempty"`
+	EndColumn   uint32 `json:"endColumn,omitempty"`
+}
+
+// Location represents the location of a comment within a commit.
+type Location struct {
+	Commit string `json:"commit,omitempty"`
+	// If the path is omitted, then the comment applies to the entire commit.
+	Path string `json:"path,omitempty"`
+	// If the range is omitted, then the location represents an entire file.
+	Range *Range `json:"range,omitempty"`
+}
+
+// Check verifies that this location is valid in the provided
+// repository.
+func (location *Location) Check(repo repository.Repo) error {
+	contents, err := repo.Show(location.Commit, location.Path)
+	if err != nil {
+		return err
+	}
+	lines := strings.Split(contents, "\n")
+	if location.Range.StartLine > uint32(len(lines)) {
+		return fmt.Errorf("Line number %d does not exist in file %q",
+			location.Range.StartLine,
+			location.Path)
+	}
+	if location.Range.StartColumn != 0 &&
+		location.Range.StartColumn > uint32(len(lines[location.Range.StartLine-1])) {
+		return fmt.Errorf("Line %d in %q is too short for column %d",
+			location.Range.StartLine,
+			location.Path,
+			location.Range.StartColumn)
+	}
+	if location.Range.EndLine != 0 &&
+		location.Range.EndLine > uint32(len(lines)) {
+		return fmt.Errorf("End line number %d does not exist in file %q",
+			location.Range.EndLine,
+			location.Path)
+	}
+	if location.Range.EndColumn != 0 &&
+		location.Range.EndColumn > uint32(len(lines[location.Range.EndLine-1])) {
+		return fmt.Errorf("End line %d in %q is too short for column %d",
+			location.Range.EndLine,
+			location.Path,
+			location.Range.EndColumn)
+	}
+	return nil
+}
+
+// Comment represents a review comment, and can occur in any of the following contexts:
+// 1. As a comment on an entire commit.
+// 2. As a comment about a specific file in a commit.
+// 3. As a comment about a specific line in a commit.
+// 4. As a response to another comment.
+type Comment struct {
+	// Timestamp and Author are optimizations that allows us to display comment threads
+	// without having to run git-blame over the notes object. This is done because
+	// git-blame will become more and more expensive as the number of code reviews grows.
+	Timestamp string `json:"timestamp,omitempty"`
+	Author    string `json:"author,omitempty"`
+	// If original is provided, then the comment is an updated version of another comment.
+	Original string `json:"original,omitempty"`
+	// If parent is provided, then the comment is a response to another comment.
+	Parent string `json:"parent,omitempty"`
+	// If location is provided, then the comment is specific to that given location.
+	Location    *Location `json:"location,omitempty"`
+	Description string    `json:"description,omitempty"`
+	// The resolved bit indicates that no further action is needed.
+	//
+	// When the parent of the comment is another comment, this means that comment
+	// has been addressed. Otherwise, the parent is the commit, and this means that the
+	// change has been accepted. If the resolved bit is unset, then the comment is only an FYI.
+	Resolved *bool `json:"resolved,omitempty"`
+	// Version represents the version of the metadata format.
+	Version int `json:"v,omitempty"`
+
+	gpg.Sig
+}
+
+// New returns a new comment with the given description message.
+//
+// The Timestamp and Author fields are automatically filled in with the current time and user.
+func New(author string, description string) Comment {
+	return Comment{
+		Timestamp:   strconv.FormatInt(time.Now().Unix(), 10),
+		Author:      author,
+		Description: description,
+	}
+}
+
+// Parse parses a review comment from a git note.
+func Parse(note repository.Note) (Comment, error) {
+	bytes := []byte(note)
+	var comment Comment
+	err := json.Unmarshal(bytes, &comment)
+	return comment, err
+}
+
+// ParseAllValid takes collection of git notes and tries to parse a review
+// comment from each one. Any notes that are not valid review comments get
+// ignored, as we expect the git notes to be a heterogenous list, with only
+// some of them being review comments.
+func ParseAllValid(notes []repository.Note) map[string]Comment {
+	comments := make(map[string]Comment)
+	for _, note := range notes {
+		comment, err := Parse(note)
+		if err == nil && comment.Version == FormatVersion {
+			hash, err := comment.Hash()
+			if err == nil {
+				comments[hash] = comment
+			}
+		}
+	}
+	return comments
+}
+
+func (comment Comment) serialize() ([]byte, error) {
+	if len(comment.Timestamp) < 10 {
+		// To make sure that timestamps from before 2001 appear in the correct
+		// alphabetical order, we reformat the timestamp to be at least 10 characters
+		// and zero-padded.
+		time, err := strconv.ParseInt(comment.Timestamp, 10, 64)
+		if err == nil {
+			comment.Timestamp = fmt.Sprintf("%010d", time)
+		}
+		// We ignore the other case, as the comment timestamp is not in a format
+		// we expected, so we should just leave it alone.
+	}
+	return json.Marshal(comment)
+}
+
+// Write writes a review comment as a JSON-formatted git note.
+func (comment Comment) Write() (repository.Note, error) {
+	bytes, err := comment.serialize()
+	return repository.Note(bytes), err
+}
+
+// Hash returns the SHA1 hash of a review comment.
+func (comment Comment) Hash() (string, error) {
+	bytes, err := comment.serialize()
+	return fmt.Sprintf("%x", sha1.Sum(bytes)), err
+}
+
+// Set implenents flag.Value for the Range type
+func (r *Range) Set(s string) error {
+	var err error
+	*r = Range{}
+
+	if s == "" {
+		return nil
+	}
+	startEndParts := strings.Split(s, ":")
+	if len(startEndParts) > 2 {
+		return ErrInvalidRange
+	}
+
+	r.StartLine, r.StartColumn, err = parseRangePart(startEndParts[0])
+	if err != nil {
+		return err
+	}
+	if len(startEndParts) == 1 {
+		return nil
+	}
+
+	r.EndLine, r.EndColumn, err = parseRangePart(startEndParts[1])
+	if err != nil {
+		return err
+	}
+
+	if r.StartLine > r.EndLine {
+		return errors.New("start line cannot be greater than end line in range")
+	}
+
+	return nil
+}
+
+func parseRangePart(s string) (uint32, uint32, error) {
+	parts := strings.Split(s, "+")
+	if len(parts) > 2 {
+		return 0, 0, ErrInvalidRange
+	}
+
+	line, err := strconv.ParseUint(parts[0], 10, 32)
+	if err != nil {
+		return 0, 0, ErrInvalidRange
+	}
+
+	if len(parts) == 1 {
+		return uint32(line), 0, nil
+	}
+
+	col, err := strconv.ParseUint(parts[1], 10, 32)
+	if err != nil {
+		return 0, 0, ErrInvalidRange
+	}
+
+	if line == 0 && col != 0 {
+		// line 0 represents the entire file
+		return 0, 0, ErrInvalidRange
+	}
+
+	return uint32(line), uint32(col), nil
+}
+
+func (r *Range) String() string {
+	out := ""
+	if r.StartLine != 0 {
+		out = fmt.Sprintf("%d", r.StartLine)
+	}
+	if r.StartColumn != 0 {
+		out = fmt.Sprintf("%s+%d", out, r.StartColumn)
+	}
+	if r.EndLine != 0 {
+		out = fmt.Sprintf("%s:%d", out, r.EndLine)
+	}
+	if r.EndColumn != 0 {
+		out = fmt.Sprintf("%s+%d", out, r.EndColumn)
+	}
+	return out
+}
diff --git a/third_party/go/git-appraise/review/gpg/signable.go b/third_party/go/git-appraise/review/gpg/signable.go
new file mode 100644
index 0000000000..776764c6fc
--- /dev/null
+++ b/third_party/go/git-appraise/review/gpg/signable.go
@@ -0,0 +1,129 @@
+// Package gpg provides an interface and an abstraction with which to sign and
+// verify review requests and comments.
+package gpg
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"os"
+	"os/exec"
+)
+
+const placeholder = "gpgsig"
+
+// Sig provides an abstraction around shelling out to GPG to sign the
+// content it's given.
+type Sig struct {
+	// Sig holds an object's content's signature.
+	Sig string `json:"signature,omitempty"`
+}
+
+// Signable is an interfaces which provides the pointer to the signable
+// object's stringified signature.
+//
+// This pointer is used by `Sign` and `Verify` to replace its contents with
+// `placeholder` or the signature itself for the purposes of signing or
+// verifying.
+type Signable interface {
+	Signature() *string
+}
+
+// Signature is `Sig`'s implementation of `Signable`. Through this function, an
+// object which needs to implement `Signable` need only embed `Sig`
+// anonymously. See, e.g., review/request.go.
+func (s *Sig) Signature() *string {
+	return &s.Sig
+}
+
+// Sign uses gpg to sign the contents of a request and deposit it into the
+// signature key of the request.
+func Sign(key string, s Signable) error {
+	// First we retrieve the pointer and write `placeholder` as its value.
+	sigPtr := s.Signature()
+	*sigPtr = placeholder
+
+	// Marshal the content and sign it.
+	content, err := json.Marshal(s)
+	if err != nil {
+		return err
+	}
+	sig, err := signContent(key, content)
+	if err != nil {
+		return err
+	}
+
+	// Write the signature as the new value at the pointer.
+	*sigPtr = sig.String()
+	return nil
+}
+
+func signContent(key string, content []byte) (*bytes.Buffer,
+	error) {
+	var stdout, stderr bytes.Buffer
+	cmd := exec.Command("gpg", "-u", key, "--detach-sign", "--armor")
+	cmd.Stdin = bytes.NewReader(content)
+	cmd.Stdout = &stdout
+	cmd.Stderr = &stderr
+	err := cmd.Run()
+	return &stdout, err
+}
+
+// Verify verifies the signatures on the request and its comments with the
+// given key.
+func Verify(s Signable) error {
+	// Retrieve the pointer.
+	sigPtr := s.Signature()
+	// Copy its contents.
+	sig := *sigPtr
+	// Overwrite the value with the placeholder.
+	*sigPtr = placeholder
+
+	defer func() { *sigPtr = sig }()
+
+	// 1. Marshal the content into JSON.
+	// 2. Write the signature and the content to temp files.
+	// 3. Use gpg to verify the signature.
+	content, err := json.Marshal(s)
+	if err != nil {
+		return err
+	}
+	sigFile, err := ioutil.TempFile("", "sig")
+	if err != nil {
+		return err
+	}
+	defer os.Remove(sigFile.Name())
+	_, err = sigFile.Write([]byte(sig))
+	if err != nil {
+		return err
+	}
+	err = sigFile.Close()
+	if err != nil {
+		return err
+	}
+
+	contentFile, err := ioutil.TempFile("", "content")
+	if err != nil {
+		return err
+	}
+	defer os.Remove(contentFile.Name())
+	_, err = contentFile.Write(content)
+	if err != nil {
+		return err
+	}
+	err = contentFile.Close()
+	if err != nil {
+		return err
+	}
+
+	var stdout, stderr bytes.Buffer
+	cmd := exec.Command("gpg", "--verify", sigFile.Name(), contentFile.Name())
+	cmd.Stdout = &stdout
+	cmd.Stderr = &stderr
+	err = cmd.Run()
+	if err != nil {
+		return fmt.Errorf("%s", stderr.String())
+	}
+	return nil
+}
diff --git a/third_party/go/git-appraise/review/request/request.go b/third_party/go/git-appraise/review/request/request.go
new file mode 100644
index 0000000000..c23fd427a8
--- /dev/null
+++ b/third_party/go/git-appraise/review/request/request.go
@@ -0,0 +1,104 @@
+/*
+Copyright 2015 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 request defines the internal representation of a review request.
+package request
+
+import (
+	"encoding/json"
+	"strconv"
+	"time"
+
+	"github.com/google/git-appraise/repository"
+	"github.com/google/git-appraise/review/gpg"
+)
+
+// Ref defines the git-notes ref that we expect to contain review requests.
+const Ref = "refs/notes/devtools/reviews"
+
+// FormatVersion defines the latest version of the request format supported by the tool.
+const FormatVersion = 0
+
+// Request represents an initial request for a code review.
+//
+// Every field is optional.
+type Request struct {
+	// Timestamp and Requester are optimizations that allows us to display reviews
+	// without having to run git-blame over the notes object. This is done because
+	// git-blame will become more and more expensive as the number of reviews grows.
+	Timestamp   string   `json:"timestamp,omitempty"`
+	ReviewRef   string   `json:"reviewRef,omitempty"`
+	TargetRef   string   `json:"targetRef"`
+	Requester   string   `json:"requester,omitempty"`
+	Reviewers   []string `json:"reviewers,omitempty"`
+	Description string   `json:"description,omitempty"`
+	// Version represents the version of the metadata format.
+	Version int `json:"v,omitempty"`
+	// BaseCommit stores the commit ID of the target ref at the time the review was requested.
+	// This is optional, and only used for submitted reviews which were anchored at a merge commit.
+	// This allows someone viewing that submitted review to find the diff against which the
+	// code was reviewed.
+	BaseCommit string `json:"baseCommit,omitempty"`
+	// Alias stores a post-rebase commit ID for the review. This allows the tool
+	// to track the history of a review even if the commit history changes.
+	Alias string `json:"alias,omitempty"`
+
+	gpg.Sig
+}
+
+// New returns a new request.
+//
+// The Timestamp and Requester fields are automatically filled in with the current time and user.
+func New(requester string, reviewers []string, reviewRef, targetRef, description string) Request {
+	return Request{
+		Timestamp:   strconv.FormatInt(time.Now().Unix(), 10),
+		Requester:   requester,
+		Reviewers:   reviewers,
+		ReviewRef:   reviewRef,
+		TargetRef:   targetRef,
+		Description: description,
+	}
+}
+
+// Parse parses a review request from a git note.
+func Parse(note repository.Note) (Request, error) {
+	bytes := []byte(note)
+	var request Request
+	err := json.Unmarshal(bytes, &request)
+	// TODO(ojarjur): If "requester" is not set, then use git-blame to fill it in.
+	return request, err
+}
+
+// ParseAllValid takes collection of git notes and tries to parse a review
+// request from each one. Any notes that are not valid review requests get
+// ignored, as we expect the git notes to be a heterogenous list, with only
+// some of them being review requests.
+func ParseAllValid(notes []repository.Note) []Request {
+	var requests []Request
+	for _, note := range notes {
+		request, err := Parse(note)
+		if err == nil && request.Version == FormatVersion {
+			requests = append(requests, request)
+		}
+	}
+	return requests
+}
+
+// Write writes a review request as a JSON-formatted git note.
+func (request *Request) Write() (repository.Note, error) {
+	bytes, err := json.Marshal(request)
+	return repository.Note(bytes), err
+}
diff --git a/third_party/go/git-appraise/review/review.go b/third_party/go/git-appraise/review/review.go
new file mode 100644
index 0000000000..a23dd17bf7
--- /dev/null
+++ b/third_party/go/git-appraise/review/review.go
@@ -0,0 +1,772 @@
+/*
+Copyright 2015 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 review contains the data structures used to represent code reviews.
+package review
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"sort"
+
+	"github.com/google/git-appraise/repository"
+	"github.com/google/git-appraise/review/analyses"
+	"github.com/google/git-appraise/review/ci"
+	"github.com/google/git-appraise/review/comment"
+	"github.com/google/git-appraise/review/gpg"
+	"github.com/google/git-appraise/review/request"
+)
+
+const archiveRef = "refs/devtools/archives/reviews"
+
+// CommentThread represents the tree-based hierarchy of comments.
+//
+// The Resolved field represents the aggregate status of the entire thread. If
+// it is set to false, then it indicates that there is an unaddressed comment
+// in the thread. If it is unset, then that means that the root comment is an
+// FYI only, and that there are no unaddressed comments. If it is set to true,
+// then that means that there are no unaddressed comments, and that the root
+// comment has its resolved bit set to true.
+type CommentThread struct {
+	Hash     string             `json:"hash,omitempty"`
+	Comment  comment.Comment    `json:"comment"`
+	Original *comment.Comment   `json:"original,omitempty"`
+	Edits    []*comment.Comment `json:"edits,omitempty"`
+	Children []CommentThread    `json:"children,omitempty"`
+	Resolved *bool              `json:"resolved,omitempty"`
+	Edited   bool               `json:"edited,omitempty"`
+}
+
+// Summary represents the high-level state of a code review.
+//
+// This high-level state corresponds to the data that can be quickly read
+// directly from the repo, so other methods that need to operate on a lot
+// of reviews (such as listing the open reviews) should prefer operating on
+// the summary rather than the details.
+//
+// Review summaries have two status fields which are orthogonal:
+// 1. Resolved indicates if a reviewer has accepted or rejected the change.
+// 2. Submitted indicates if the change has been incorporated into the target.
+type Summary struct {
+	Repo        repository.Repo   `json:"-"`
+	Revision    string            `json:"revision"`
+	Request     request.Request   `json:"request"`
+	AllRequests []request.Request `json:"-"`
+	Comments    []CommentThread   `json:"comments,omitempty"`
+	Resolved    *bool             `json:"resolved,omitempty"`
+	Submitted   bool              `json:"submitted"`
+}
+
+// Review represents the entire state of a code review.
+//
+// This extends Summary to also include a list of reports for both the
+// continuous integration status, and the static analysis runs. Those reports
+// correspond to either the current commit in the review ref (for pending
+// reviews), or to the last commented-upon commit (for submitted reviews).
+type Review struct {
+	*Summary
+	Reports  []ci.Report       `json:"reports,omitempty"`
+	Analyses []analyses.Report `json:"analyses,omitempty"`
+}
+
+type commentsByTimestamp []*comment.Comment
+
+// Interface methods for sorting comment threads by timestamp
+func (cs commentsByTimestamp) Len() int      { return len(cs) }
+func (cs commentsByTimestamp) Swap(i, j int) { cs[i], cs[j] = cs[j], cs[i] }
+func (cs commentsByTimestamp) Less(i, j int) bool {
+	return cs[i].Timestamp < cs[j].Timestamp
+}
+
+type byTimestamp []CommentThread
+
+// Interface methods for sorting comment threads by timestamp
+func (threads byTimestamp) Len() int      { return len(threads) }
+func (threads byTimestamp) Swap(i, j int) { threads[i], threads[j] = threads[j], threads[i] }
+func (threads byTimestamp) Less(i, j int) bool {
+	return threads[i].Comment.Timestamp < threads[j].Comment.Timestamp
+}
+
+type requestsByTimestamp []request.Request
+
+// Interface methods for sorting review requests by timestamp
+func (requests requestsByTimestamp) Len() int { return len(requests) }
+func (requests requestsByTimestamp) Swap(i, j int) {
+	requests[i], requests[j] = requests[j], requests[i]
+}
+func (requests requestsByTimestamp) Less(i, j int) bool {
+	return requests[i].Timestamp < requests[j].Timestamp
+}
+
+type summariesWithNewestRequestsFirst []Summary
+
+// Interface methods for sorting review summaries in reverse chronological order
+func (summaries summariesWithNewestRequestsFirst) Len() int { return len(summaries) }
+func (summaries summariesWithNewestRequestsFirst) Swap(i, j int) {
+	summaries[i], summaries[j] = summaries[j], summaries[i]
+}
+func (summaries summariesWithNewestRequestsFirst) Less(i, j int) bool {
+	return summaries[i].Request.Timestamp > summaries[j].Request.Timestamp
+}
+
+// updateThreadsStatus calculates the aggregate status of a sequence of comment threads.
+//
+// The aggregate status is the conjunction of all of the non-nil child statuses.
+//
+// This has the side-effect of setting the "Resolved" field of all descendant comment threads.
+func updateThreadsStatus(threads []CommentThread) *bool {
+	sort.Stable(byTimestamp(threads))
+	noUnresolved := true
+	var result *bool
+	for i := range threads {
+		thread := &threads[i]
+		thread.updateResolvedStatus()
+		if thread.Resolved != nil {
+			noUnresolved = noUnresolved && *thread.Resolved
+			result = &noUnresolved
+		}
+	}
+	return result
+}
+
+// updateResolvedStatus calculates the aggregate status of a single comment thread,
+// and updates the "Resolved" field of that thread accordingly.
+func (thread *CommentThread) updateResolvedStatus() {
+	resolved := updateThreadsStatus(thread.Children)
+	if resolved == nil {
+		thread.Resolved = thread.Comment.Resolved
+		return
+	}
+
+	if !*resolved {
+		thread.Resolved = resolved
+		return
+	}
+
+	if thread.Comment.Resolved == nil || !*thread.Comment.Resolved {
+		thread.Resolved = nil
+		return
+	}
+
+	thread.Resolved = resolved
+}
+
+// Verify verifies the signature on a comment.
+func (thread *CommentThread) Verify() error {
+	err := gpg.Verify(&thread.Comment)
+	if err != nil {
+		hash, _ := thread.Comment.Hash()
+		return fmt.Errorf("verification of comment [%s] failed: %s", hash, err)
+	}
+	for _, child := range thread.Children {
+		err = child.Verify()
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// mutableThread is an internal-only data structure used to store partially constructed comment threads.
+type mutableThread struct {
+	Hash     string
+	Comment  comment.Comment
+	Edits    []*comment.Comment
+	Children []*mutableThread
+}
+
+// fixMutableThread is a helper method to finalize a mutableThread struct
+// (partially constructed comment thread) as a CommentThread struct
+// (fully constructed comment thread).
+func fixMutableThread(mutableThread *mutableThread) CommentThread {
+	var children []CommentThread
+	edited := len(mutableThread.Edits) > 0
+	for _, mutableChild := range mutableThread.Children {
+		child := fixMutableThread(mutableChild)
+		if (!edited) && child.Edited {
+			edited = true
+		}
+		children = append(children, child)
+	}
+	comment := &mutableThread.Comment
+	if len(mutableThread.Edits) > 0 {
+		sort.Stable(commentsByTimestamp(mutableThread.Edits))
+		comment = mutableThread.Edits[len(mutableThread.Edits)-1]
+	}
+
+	return CommentThread{
+		Hash:     mutableThread.Hash,
+		Comment:  *comment,
+		Original: &mutableThread.Comment,
+		Edits:    mutableThread.Edits,
+		Children: children,
+		Edited:   edited,
+	}
+}
+
+// This function builds the comment thread tree from the log-based list of comments.
+//
+// Since the comments can be processed in any order, this uses an internal mutable
+// data structure, and then converts it to the proper CommentThread structure at the end.
+func buildCommentThreads(commentsByHash map[string]comment.Comment) []CommentThread {
+	threadsByHash := make(map[string]*mutableThread)
+	for hash, comment := range commentsByHash {
+		thread, ok := threadsByHash[hash]
+		if !ok {
+			thread = &mutableThread{
+				Hash:    hash,
+				Comment: comment,
+			}
+			threadsByHash[hash] = thread
+		}
+	}
+	var rootHashes []string
+	for hash, thread := range threadsByHash {
+		if thread.Comment.Original != "" {
+			original, ok := threadsByHash[thread.Comment.Original]
+			if ok {
+				original.Edits = append(original.Edits, &thread.Comment)
+			}
+		} else if thread.Comment.Parent == "" {
+			rootHashes = append(rootHashes, hash)
+		} else {
+			parent, ok := threadsByHash[thread.Comment.Parent]
+			if ok {
+				parent.Children = append(parent.Children, thread)
+			}
+		}
+	}
+	var threads []CommentThread
+	for _, hash := range rootHashes {
+		threads = append(threads, fixMutableThread(threadsByHash[hash]))
+	}
+	return threads
+}
+
+// loadComments reads in the log-structured sequence of comments for a review,
+// and then builds the corresponding tree-structured comment threads.
+func (r *Summary) loadComments(commentNotes []repository.Note) []CommentThread {
+	commentsByHash := comment.ParseAllValid(commentNotes)
+	return buildCommentThreads(commentsByHash)
+}
+
+func getSummaryFromNotes(repo repository.Repo, revision string, requestNotes, commentNotes []repository.Note) (*Summary, error) {
+	requests := request.ParseAllValid(requestNotes)
+	if requests == nil {
+		return nil, fmt.Errorf("Could not find any review requests for %q", revision)
+	}
+	sort.Stable(requestsByTimestamp(requests))
+	reviewSummary := Summary{
+		Repo:        repo,
+		Revision:    revision,
+		Request:     requests[len(requests)-1],
+		AllRequests: requests,
+	}
+	reviewSummary.Comments = reviewSummary.loadComments(commentNotes)
+	reviewSummary.Resolved = updateThreadsStatus(reviewSummary.Comments)
+	return &reviewSummary, nil
+}
+
+// GetSummary returns the summary of the code review specified by its revision
+// and the references which contain that reviews summary and comments.
+//
+// If no review request exists, the returned review summary is nil.
+func GetSummaryViaRefs(repo repository.Repo, requestRef, commentRef,
+	revision string) (*Summary, error) {
+
+	if err := repo.VerifyCommit(revision); err != nil {
+		return nil, fmt.Errorf("Could not find a commit named %q", revision)
+	}
+	requestNotes := repo.GetNotes(requestRef, revision)
+	commentNotes := repo.GetNotes(commentRef, revision)
+	summary, err := getSummaryFromNotes(repo, revision, requestNotes, commentNotes)
+	if err != nil {
+		return nil, err
+	}
+	currentCommit := revision
+	if summary.Request.Alias != "" {
+		currentCommit = summary.Request.Alias
+	}
+
+	if !summary.IsAbandoned() {
+		submitted, err := repo.IsAncestor(currentCommit, summary.Request.TargetRef)
+		if err != nil {
+			return nil, err
+		}
+		summary.Submitted = submitted
+	}
+	return summary, nil
+}
+
+// GetSummary returns the summary of the specified code review.
+//
+// If no review request exists, the returned review summary is nil.
+func GetSummary(repo repository.Repo, revision string) (*Summary, error) {
+	return GetSummaryViaRefs(repo, request.Ref, comment.Ref, revision)
+}
+
+// Details returns the detailed review for the given summary.
+func (r *Summary) Details() (*Review, error) {
+	review := Review{
+		Summary: r,
+	}
+	currentCommit, err := review.GetHeadCommit()
+	if err == nil {
+		review.Reports = ci.ParseAllValid(review.Repo.GetNotes(ci.Ref, currentCommit))
+		review.Analyses = analyses.ParseAllValid(review.Repo.GetNotes(analyses.Ref, currentCommit))
+	}
+	return &review, nil
+}
+
+// IsAbandoned returns whether or not the given review has been abandoned.
+func (r *Summary) IsAbandoned() bool {
+	return r.Request.TargetRef == ""
+}
+
+// IsOpen returns whether or not the given review is still open (neither submitted nor abandoned).
+func (r *Summary) IsOpen() bool {
+	return !r.Submitted && !r.IsAbandoned()
+}
+
+// Verify returns whether or not a summary's comments are a) signed, and b)
+/// that those signatures are verifiable.
+func (r *Summary) Verify() error {
+	err := gpg.Verify(&r.Request)
+	if err != nil {
+		return fmt.Errorf("couldn't verify request targeting: %q: %s",
+			r.Request.TargetRef, err)
+	}
+	for _, thread := range r.Comments {
+		err := thread.Verify()
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// Get returns the specified code review.
+//
+// If no review request exists, the returned review is nil.
+func Get(repo repository.Repo, revision string) (*Review, error) {
+	summary, err := GetSummary(repo, revision)
+	if err != nil {
+		return nil, err
+	}
+	if summary == nil {
+		return nil, nil
+	}
+	return summary.Details()
+}
+
+func getIsSubmittedCheck(repo repository.Repo) func(ref, commit string) bool {
+	refCommitsMap := make(map[string]map[string]bool)
+
+	getRefCommitsMap := func(ref string) map[string]bool {
+		commitsMap, ok := refCommitsMap[ref]
+		if ok {
+			return commitsMap
+		}
+		commitsMap = make(map[string]bool)
+		for _, commit := range repo.ListCommits(ref) {
+			commitsMap[commit] = true
+		}
+		refCommitsMap[ref] = commitsMap
+		return commitsMap
+	}
+
+	return func(ref, commit string) bool {
+		return getRefCommitsMap(ref)[commit]
+	}
+}
+
+func unsortedListAll(repo repository.Repo) []Summary {
+	reviewNotesMap, err := repo.GetAllNotes(request.Ref)
+	if err != nil {
+		return nil
+	}
+	discussNotesMap, err := repo.GetAllNotes(comment.Ref)
+	if err != nil {
+		return nil
+	}
+
+	isSubmittedCheck := getIsSubmittedCheck(repo)
+	var reviews []Summary
+	for commit, notes := range reviewNotesMap {
+		summary, err := getSummaryFromNotes(repo, commit, notes, discussNotesMap[commit])
+		if err != nil {
+			continue
+		}
+		if !summary.IsAbandoned() {
+			summary.Submitted = isSubmittedCheck(summary.Request.TargetRef, summary.getStartingCommit())
+		}
+		reviews = append(reviews, *summary)
+	}
+	return reviews
+}
+
+// ListAll returns all reviews stored in the git-notes.
+func ListAll(repo repository.Repo) []Summary {
+	reviews := unsortedListAll(repo)
+	sort.Stable(summariesWithNewestRequestsFirst(reviews))
+	return reviews
+}
+
+// ListOpen returns all reviews that are not yet incorporated into their target refs.
+func ListOpen(repo repository.Repo) []Summary {
+	var openReviews []Summary
+	for _, review := range unsortedListAll(repo) {
+		if review.IsOpen() {
+			openReviews = append(openReviews, review)
+		}
+	}
+	sort.Stable(summariesWithNewestRequestsFirst(openReviews))
+	return openReviews
+}
+
+// GetCurrent returns the current, open code review.
+//
+// If there are multiple matching reviews, then an error is returned.
+func GetCurrent(repo repository.Repo) (*Review, error) {
+	reviewRef, err := repo.GetHeadRef()
+	if err != nil {
+		return nil, err
+	}
+	var matchingReviews []Summary
+	for _, review := range ListOpen(repo) {
+		if review.Request.ReviewRef == reviewRef {
+			matchingReviews = append(matchingReviews, review)
+		}
+	}
+	if matchingReviews == nil {
+		return nil, nil
+	}
+	if len(matchingReviews) != 1 {
+		return nil, fmt.Errorf("There are %d open reviews for the ref \"%s\"", len(matchingReviews), reviewRef)
+	}
+	return matchingReviews[0].Details()
+}
+
+// GetBuildStatusMessage returns a string of the current build-and-test status
+// of the review, or "unknown" if the build-and-test status cannot be determined.
+func (r *Review) GetBuildStatusMessage() string {
+	statusMessage := "unknown"
+	ciReport, err := ci.GetLatestCIReport(r.Reports)
+	if err != nil {
+		return fmt.Sprintf("unknown: %s", err)
+	}
+	if ciReport != nil {
+		statusMessage = fmt.Sprintf("%s (%q)", ciReport.Status, ciReport.URL)
+	}
+	return statusMessage
+}
+
+// GetAnalysesNotes returns all of the notes from the most recent static
+// analysis run recorded in the git notes.
+func (r *Review) GetAnalysesNotes() ([]analyses.Note, error) {
+	latestAnalyses, err := analyses.GetLatestAnalysesReport(r.Analyses)
+	if err != nil {
+		return nil, err
+	}
+	if latestAnalyses == nil {
+		return nil, fmt.Errorf("No analyses available")
+	}
+	return latestAnalyses.GetNotes()
+}
+
+// GetAnalysesMessage returns a string summarizing the results of the
+// most recent static analyses.
+func (r *Review) GetAnalysesMessage() string {
+	latestAnalyses, err := analyses.GetLatestAnalysesReport(r.Analyses)
+	if err != nil {
+		return err.Error()
+	}
+	if latestAnalyses == nil {
+		return "No analyses available"
+	}
+	status := latestAnalyses.Status
+	if status != "" && status != analyses.StatusNeedsMoreWork {
+		return status
+	}
+	analysesNotes, err := latestAnalyses.GetNotes()
+	if err != nil {
+		return err.Error()
+	}
+	if analysesNotes == nil {
+		return "passed"
+	}
+	return fmt.Sprintf("%d warnings\n", len(analysesNotes))
+	// TODO(ojarjur): Figure out the best place to display the actual notes
+}
+
+func prettyPrintJSON(jsonBytes []byte) (string, error) {
+	var prettyBytes bytes.Buffer
+	err := json.Indent(&prettyBytes, jsonBytes, "", "  ")
+	if err != nil {
+		return "", err
+	}
+	return prettyBytes.String(), nil
+}
+
+// GetJSON returns the pretty printed JSON for a review summary.
+func (r *Summary) GetJSON() (string, error) {
+	jsonBytes, err := json.Marshal(*r)
+	if err != nil {
+		return "", err
+	}
+	return prettyPrintJSON(jsonBytes)
+}
+
+// GetJSON returns the pretty printed JSON for a review.
+func (r *Review) GetJSON() (string, error) {
+	jsonBytes, err := json.Marshal(*r)
+	if err != nil {
+		return "", err
+	}
+	return prettyPrintJSON(jsonBytes)
+}
+
+// findLastCommit returns the later (newest) commit from the union of the provided commit
+// and all of the commits that are referenced in the given comment threads.
+func (r *Review) findLastCommit(startingCommit, latestCommit string, commentThreads []CommentThread) string {
+	isLater := func(commit string) bool {
+		if err := r.Repo.VerifyCommit(commit); err != nil {
+			return false
+		}
+		if t, e := r.Repo.IsAncestor(latestCommit, commit); e == nil && t {
+			return true
+		}
+		if t, e := r.Repo.IsAncestor(startingCommit, commit); e == nil && !t {
+			return false
+		}
+		if t, e := r.Repo.IsAncestor(commit, latestCommit); e == nil && t {
+			return false
+		}
+		ct, err := r.Repo.GetCommitTime(commit)
+		if err != nil {
+			return false
+		}
+		lt, err := r.Repo.GetCommitTime(latestCommit)
+		if err != nil {
+			return true
+		}
+		return ct > lt
+	}
+	updateLatest := func(commit string) {
+		if commit == "" {
+			return
+		}
+		if isLater(commit) {
+			latestCommit = commit
+		}
+	}
+	for _, commentThread := range commentThreads {
+		comment := commentThread.Comment
+		if comment.Location != nil {
+			updateLatest(comment.Location.Commit)
+		}
+		updateLatest(r.findLastCommit(startingCommit, latestCommit, commentThread.Children))
+	}
+	return latestCommit
+}
+
+func (r *Summary) getStartingCommit() string {
+	if r.Request.Alias != "" {
+		return r.Request.Alias
+	}
+	return r.Revision
+}
+
+// GetHeadCommit returns the latest commit in a review.
+func (r *Review) GetHeadCommit() (string, error) {
+	currentCommit := r.getStartingCommit()
+	if r.Request.ReviewRef == "" {
+		return currentCommit, nil
+	}
+
+	if r.Submitted {
+		// The review has already been submitted.
+		// Go through the list of comments and find the last commented upon commit.
+		return r.findLastCommit(currentCommit, currentCommit, r.Comments), nil
+	}
+
+	// It is possible that the review ref is no longer an ancestor of the starting
+	// commit (e.g. if a rebase left us in a detached head), in which case we have to
+	// find the head commit without using it.
+	useReviewRef, err := r.Repo.IsAncestor(currentCommit, r.Request.ReviewRef)
+	if err != nil {
+		return "", err
+	}
+	if useReviewRef {
+		return r.Repo.ResolveRefCommit(r.Request.ReviewRef)
+	}
+
+	return r.findLastCommit(currentCommit, currentCommit, r.Comments), nil
+}
+
+// GetBaseCommit returns the commit against which a review should be compared.
+func (r *Review) GetBaseCommit() (string, error) {
+	if !r.IsOpen() {
+		if r.Request.BaseCommit != "" {
+			return r.Request.BaseCommit, nil
+		}
+
+		// This means the review has been submitted, but did not specify a base commit.
+		// In this case, we have to treat the last parent commit as the base. This is
+		// usually what we want, since merging a target branch into a feature branch
+		// results in the previous commit to the feature branch being the first parent,
+		// and the latest commit to the target branch being the second parent.
+		return r.Repo.GetLastParent(r.Revision)
+	}
+
+	targetRefHead, err := r.Repo.ResolveRefCommit(r.Request.TargetRef)
+	if err != nil {
+		return "", err
+	}
+	leftHandSide := targetRefHead
+	rightHandSide := r.Revision
+	if r.Request.ReviewRef != "" {
+		if reviewRefHead, err := r.Repo.ResolveRefCommit(r.Request.ReviewRef); err == nil {
+			rightHandSide = reviewRefHead
+		}
+	}
+
+	return r.Repo.MergeBase(leftHandSide, rightHandSide)
+}
+
+// ListCommits lists the commits included in a review.
+func (r *Review) ListCommits() ([]string, error) {
+	baseCommit, err := r.GetBaseCommit()
+	if err != nil {
+		return nil, err
+	}
+	headCommit, err := r.GetHeadCommit()
+	if err != nil {
+		return nil, err
+	}
+	return r.Repo.ListCommitsBetween(baseCommit, headCommit)
+}
+
+// GetDiff returns the diff for a review.
+func (r *Review) GetDiff(diffArgs ...string) (string, error) {
+	var baseCommit, headCommit string
+	baseCommit, err := r.GetBaseCommit()
+	if err == nil {
+		headCommit, err = r.GetHeadCommit()
+	}
+	if err == nil {
+		return r.Repo.Diff(baseCommit, headCommit, diffArgs...)
+	}
+	return "", err
+}
+
+// AddComment adds the given comment to the review.
+func (r *Review) AddComment(c comment.Comment) error {
+	commentNote, err := c.Write()
+	if err != nil {
+		return err
+	}
+
+	r.Repo.AppendNote(comment.Ref, r.Revision, commentNote)
+	return nil
+}
+
+// Rebase performs an interactive rebase of the review onto its target ref.
+//
+// If the 'archivePrevious' argument is true, then the previous head of the
+// review will be added to the 'refs/devtools/archives/reviews' ref prior
+// to being rewritten. That ensures the review history is kept from being
+// garbage collected.
+func (r *Review) Rebase(archivePrevious bool) error {
+	if archivePrevious {
+		orig, err := r.GetHeadCommit()
+		if err != nil {
+			return err
+		}
+		if err := r.Repo.ArchiveRef(orig, archiveRef); err != nil {
+			return err
+		}
+	}
+	if err := r.Repo.SwitchToRef(r.Request.ReviewRef); err != nil {
+		return err
+	}
+
+	err := r.Repo.RebaseRef(r.Request.TargetRef)
+	if err != nil {
+		return err
+	}
+
+	alias, err := r.Repo.GetCommitHash("HEAD")
+	if err != nil {
+		return err
+	}
+	r.Request.Alias = alias
+	newNote, err := r.Request.Write()
+	if err != nil {
+		return err
+	}
+	return r.Repo.AppendNote(request.Ref, r.Revision, newNote)
+}
+
+// RebaseAndSign performs an interactive rebase of the review onto its
+// target ref. It signs the result of the rebase as well as (re)signs
+// the review request itself.
+//
+// If the 'archivePrevious' argument is true, then the previous head of the
+// review will be added to the 'refs/devtools/archives/reviews' ref prior
+// to being rewritten. That ensures the review history is kept from being
+// garbage collected.
+func (r *Review) RebaseAndSign(archivePrevious bool) error {
+	if archivePrevious {
+		orig, err := r.GetHeadCommit()
+		if err != nil {
+			return err
+		}
+		if err := r.Repo.ArchiveRef(orig, archiveRef); err != nil {
+			return err
+		}
+	}
+	if err := r.Repo.SwitchToRef(r.Request.ReviewRef); err != nil {
+		return err
+	}
+
+	err := r.Repo.RebaseAndSignRef(r.Request.TargetRef)
+	if err != nil {
+		return err
+	}
+
+	alias, err := r.Repo.GetCommitHash("HEAD")
+	if err != nil {
+		return err
+	}
+	r.Request.Alias = alias
+
+	key, err := r.Repo.GetUserSigningKey()
+	if err != nil {
+		return err
+	}
+	err = gpg.Sign(key, &r.Request)
+	if err != nil {
+		return err
+	}
+
+	newNote, err := r.Request.Write()
+	if err != nil {
+		return err
+	}
+	return r.Repo.AppendNote(request.Ref, r.Revision, newNote)
+}
diff --git a/third_party/go/git-appraise/review/review_test.go b/third_party/go/git-appraise/review/review_test.go
new file mode 100644
index 0000000000..af699afd9a
--- /dev/null
+++ b/third_party/go/git-appraise/review/review_test.go
@@ -0,0 +1,870 @@
+/*
+Copyright 2015 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 review
+
+import (
+	"github.com/google/git-appraise/repository"
+	"github.com/google/git-appraise/review/comment"
+	"github.com/google/git-appraise/review/request"
+	"sort"
+	"testing"
+)
+
+func TestCommentSorting(t *testing.T) {
+	sampleComments := []*comment.Comment{
+		&comment.Comment{
+			Timestamp:   "012400",
+			Description: "Fourth",
+		},
+		&comment.Comment{
+			Timestamp:   "012400",
+			Description: "Fifth",
+		},
+		&comment.Comment{
+			Timestamp:   "012346",
+			Description: "Second",
+		},
+		&comment.Comment{
+			Timestamp:   "012345",
+			Description: "First",
+		},
+		&comment.Comment{
+			Timestamp:   "012347",
+			Description: "Third",
+		},
+	}
+	sort.Stable(commentsByTimestamp(sampleComments))
+	descriptions := []string{}
+	for _, comment := range sampleComments {
+		descriptions = append(descriptions, comment.Description)
+	}
+	if !(descriptions[0] == "First" && descriptions[1] == "Second" && descriptions[2] == "Third" && descriptions[3] == "Fourth" && descriptions[4] == "Fifth") {
+		t.Fatalf("Comment ordering failed. Got %v", sampleComments)
+	}
+}
+
+func TestThreadSorting(t *testing.T) {
+	sampleThreads := []CommentThread{
+		CommentThread{
+			Comment: comment.Comment{
+				Timestamp:   "012400",
+				Description: "Fourth",
+			},
+		},
+		CommentThread{
+			Comment: comment.Comment{
+				Timestamp:   "012400",
+				Description: "Fifth",
+			},
+		},
+		CommentThread{
+			Comment: comment.Comment{
+				Timestamp:   "012346",
+				Description: "Second",
+			},
+		},
+		CommentThread{
+			Comment: comment.Comment{
+				Timestamp:   "012345",
+				Description: "First",
+			},
+		},
+		CommentThread{
+			Comment: comment.Comment{
+				Timestamp:   "012347",
+				Description: "Third",
+			},
+		},
+	}
+	sort.Stable(byTimestamp(sampleThreads))
+	descriptions := []string{}
+	for _, thread := range sampleThreads {
+		descriptions = append(descriptions, thread.Comment.Description)
+	}
+	if !(descriptions[0] == "First" && descriptions[1] == "Second" && descriptions[2] == "Third" && descriptions[3] == "Fourth" && descriptions[4] == "Fifth") {
+		t.Fatalf("Comment thread ordering failed. Got %v", sampleThreads)
+	}
+}
+
+func TestRequestSorting(t *testing.T) {
+	sampleRequests := []request.Request{
+		request.Request{
+			Timestamp:   "012400",
+			Description: "Fourth",
+		},
+		request.Request{
+			Timestamp:   "012400",
+			Description: "Fifth",
+		},
+		request.Request{
+			Timestamp:   "012346",
+			Description: "Second",
+		},
+		request.Request{
+			Timestamp:   "012345",
+			Description: "First",
+		},
+		request.Request{
+			Timestamp:   "012347",
+			Description: "Third",
+		},
+	}
+	sort.Stable(requestsByTimestamp(sampleRequests))
+	descriptions := []string{}
+	for _, r := range sampleRequests {
+		descriptions = append(descriptions, r.Description)
+	}
+	if !(descriptions[0] == "First" && descriptions[1] == "Second" && descriptions[2] == "Third" && descriptions[3] == "Fourth" && descriptions[4] == "Fifth") {
+		t.Fatalf("Review request ordering failed. Got %v", sampleRequests)
+	}
+}
+
+func validateUnresolved(t *testing.T, resolved *bool) {
+	if resolved != nil {
+		t.Fatalf("Expected resolved status to be unset, but instead it was %v", *resolved)
+	}
+}
+
+func validateAccepted(t *testing.T, resolved *bool) {
+	if resolved == nil {
+		t.Fatal("Expected resolved status to be true, but it was unset")
+	}
+	if !*resolved {
+		t.Fatal("Expected resolved status to be true, but it was false")
+	}
+}
+
+func validateRejected(t *testing.T, resolved *bool) {
+	if resolved == nil {
+		t.Fatal("Expected resolved status to be false, but it was unset")
+	}
+	if *resolved {
+		t.Fatal("Expected resolved status to be false, but it was true")
+	}
+}
+
+func (commentThread *CommentThread) validateUnresolved(t *testing.T) {
+	validateUnresolved(t, commentThread.Resolved)
+}
+
+func (commentThread *CommentThread) validateAccepted(t *testing.T) {
+	validateAccepted(t, commentThread.Resolved)
+}
+
+func (commentThread *CommentThread) validateRejected(t *testing.T) {
+	validateRejected(t, commentThread.Resolved)
+}
+
+func TestSimpleAcceptedThreadStatus(t *testing.T) {
+	resolved := true
+	simpleThread := CommentThread{
+		Comment: comment.Comment{
+			Resolved: &resolved,
+		},
+	}
+	simpleThread.updateResolvedStatus()
+	simpleThread.validateAccepted(t)
+}
+
+func TestSimpleRejectedThreadStatus(t *testing.T) {
+	resolved := false
+	simpleThread := CommentThread{
+		Comment: comment.Comment{
+			Resolved: &resolved,
+		},
+	}
+	simpleThread.updateResolvedStatus()
+	simpleThread.validateRejected(t)
+}
+
+func TestFYIThenAcceptedThreadStatus(t *testing.T) {
+	accepted := true
+	sampleThread := CommentThread{
+		Comment: comment.Comment{
+			Resolved: nil,
+		},
+		Children: []CommentThread{
+			CommentThread{
+				Comment: comment.Comment{
+					Timestamp: "012345",
+					Resolved:  &accepted,
+				},
+			},
+		},
+	}
+	sampleThread.updateResolvedStatus()
+	sampleThread.validateUnresolved(t)
+}
+
+func TestFYIThenFYIThreadStatus(t *testing.T) {
+	sampleThread := CommentThread{
+		Comment: comment.Comment{
+			Resolved: nil,
+		},
+		Children: []CommentThread{
+			CommentThread{
+				Comment: comment.Comment{
+					Timestamp: "012345",
+					Resolved:  nil,
+				},
+			},
+		},
+	}
+	sampleThread.updateResolvedStatus()
+	sampleThread.validateUnresolved(t)
+}
+
+func TestFYIThenRejectedThreadStatus(t *testing.T) {
+	rejected := false
+	sampleThread := CommentThread{
+		Comment: comment.Comment{
+			Resolved: nil,
+		},
+		Children: []CommentThread{
+			CommentThread{
+				Comment: comment.Comment{
+					Timestamp: "012345",
+					Resolved:  &rejected,
+				},
+			},
+		},
+	}
+	sampleThread.updateResolvedStatus()
+	sampleThread.validateRejected(t)
+}
+
+func TestAcceptedThenAcceptedThreadStatus(t *testing.T) {
+	accepted := true
+	sampleThread := CommentThread{
+		Comment: comment.Comment{
+			Resolved: &accepted,
+		},
+		Children: []CommentThread{
+			CommentThread{
+				Comment: comment.Comment{
+					Timestamp: "012345",
+					Resolved:  &accepted,
+				},
+			},
+		},
+	}
+	sampleThread.updateResolvedStatus()
+	sampleThread.validateAccepted(t)
+}
+
+func TestAcceptedThenFYIThreadStatus(t *testing.T) {
+	accepted := true
+	sampleThread := CommentThread{
+		Comment: comment.Comment{
+			Resolved: &accepted,
+		},
+		Children: []CommentThread{
+			CommentThread{
+				Comment: comment.Comment{
+					Timestamp: "012345",
+					Resolved:  nil,
+				},
+			},
+		},
+	}
+	sampleThread.updateResolvedStatus()
+	sampleThread.validateAccepted(t)
+}
+
+func TestAcceptedThenRejectedThreadStatus(t *testing.T) {
+	accepted := true
+	rejected := false
+	sampleThread := CommentThread{
+		Comment: comment.Comment{
+			Resolved: &accepted,
+		},
+		Children: []CommentThread{
+			CommentThread{
+				Comment: comment.Comment{
+					Timestamp: "012345",
+					Resolved:  &rejected,
+				},
+			},
+		},
+	}
+	sampleThread.updateResolvedStatus()
+	sampleThread.validateRejected(t)
+}
+
+func TestRejectedThenAcceptedThreadStatus(t *testing.T) {
+	accepted := true
+	rejected := false
+	sampleThread := CommentThread{
+		Comment: comment.Comment{
+			Resolved: &rejected,
+		},
+		Children: []CommentThread{
+			CommentThread{
+				Comment: comment.Comment{
+					Timestamp: "012345",
+					Resolved:  &accepted,
+				},
+			},
+		},
+	}
+	sampleThread.updateResolvedStatus()
+	sampleThread.validateUnresolved(t)
+}
+
+func TestRejectedThenFYIThreadStatus(t *testing.T) {
+	rejected := false
+	sampleThread := CommentThread{
+		Comment: comment.Comment{
+			Resolved: &rejected,
+		},
+		Children: []CommentThread{
+			CommentThread{
+				Comment: comment.Comment{
+					Timestamp: "012345",
+					Resolved:  nil,
+				},
+			},
+		},
+	}
+	sampleThread.updateResolvedStatus()
+	sampleThread.validateRejected(t)
+}
+
+func TestRejectedThenRejectedThreadStatus(t *testing.T) {
+	rejected := false
+	sampleThread := CommentThread{
+		Comment: comment.Comment{
+			Resolved: &rejected,
+		},
+		Children: []CommentThread{
+			CommentThread{
+				Comment: comment.Comment{
+					Timestamp: "012345",
+					Resolved:  &rejected,
+				},
+			},
+		},
+	}
+	sampleThread.updateResolvedStatus()
+	sampleThread.validateRejected(t)
+}
+
+func TestRejectedThenAcceptedThreadsStatus(t *testing.T) {
+	accepted := true
+	rejected := false
+	threads := []CommentThread{
+		CommentThread{
+			Comment: comment.Comment{
+				Timestamp: "012345",
+				Resolved:  &rejected,
+			},
+		},
+		CommentThread{
+			Comment: comment.Comment{
+				Timestamp: "012346",
+				Resolved:  &accepted,
+			},
+		},
+	}
+	status := updateThreadsStatus(threads)
+	validateRejected(t, status)
+}
+
+func TestRejectedThenFYIThreadsStatus(t *testing.T) {
+	rejected := false
+	threads := []CommentThread{
+		CommentThread{
+			Comment: comment.Comment{
+				Timestamp: "012345",
+				Resolved:  &rejected,
+			},
+		},
+		CommentThread{
+			Comment: comment.Comment{
+				Timestamp: "012346",
+				Resolved:  nil,
+			},
+		},
+	}
+	status := updateThreadsStatus(threads)
+	validateRejected(t, status)
+}
+
+func TestRejectedThenRejectedThreadsStatus(t *testing.T) {
+	rejected := false
+	threads := []CommentThread{
+		CommentThread{
+			Comment: comment.Comment{
+				Timestamp: "012345",
+				Resolved:  &rejected,
+			},
+		},
+		CommentThread{
+			Comment: comment.Comment{
+				Timestamp: "012346",
+				Resolved:  &rejected,
+			},
+		},
+	}
+	status := updateThreadsStatus(threads)
+	validateRejected(t, status)
+}
+
+func TestAcceptedThenAcceptedThreadsStatus(t *testing.T) {
+	accepted := true
+	threads := []CommentThread{
+		CommentThread{
+			Comment: comment.Comment{
+				Timestamp: "012345",
+				Resolved:  &accepted,
+			},
+		},
+		CommentThread{
+			Comment: comment.Comment{
+				Timestamp: "012346",
+				Resolved:  &accepted,
+			},
+		},
+	}
+	status := updateThreadsStatus(threads)
+	validateAccepted(t, status)
+}
+
+func TestAcceptedThenFYIThreadsStatus(t *testing.T) {
+	accepted := true
+	threads := []CommentThread{
+		CommentThread{
+			Comment: comment.Comment{
+				Timestamp: "012345",
+				Resolved:  &accepted,
+			},
+		},
+		CommentThread{
+			Comment: comment.Comment{
+				Timestamp: "012346",
+				Resolved:  nil,
+			},
+		},
+	}
+	status := updateThreadsStatus(threads)
+	validateAccepted(t, status)
+}
+
+func TestAcceptedThenRejectedThreadsStatus(t *testing.T) {
+	accepted := true
+	rejected := false
+	threads := []CommentThread{
+		CommentThread{
+			Comment: comment.Comment{
+				Timestamp: "012345",
+				Resolved:  &accepted,
+			},
+		},
+		CommentThread{
+			Comment: comment.Comment{
+				Timestamp: "012346",
+				Resolved:  &rejected,
+			},
+		},
+	}
+	status := updateThreadsStatus(threads)
+	validateRejected(t, status)
+}
+
+func TestFYIThenAcceptedThreadsStatus(t *testing.T) {
+	accepted := true
+	threads := []CommentThread{
+		CommentThread{
+			Comment: comment.Comment{
+				Timestamp: "012345",
+				Resolved:  nil,
+			},
+		},
+		CommentThread{
+			Comment: comment.Comment{
+				Timestamp: "012346",
+				Resolved:  &accepted,
+			},
+		},
+	}
+	status := updateThreadsStatus(threads)
+	validateAccepted(t, status)
+}
+
+func TestFYIThenFYIThreadsStatus(t *testing.T) {
+	threads := []CommentThread{
+		CommentThread{
+			Comment: comment.Comment{
+				Timestamp: "012345",
+				Resolved:  nil,
+			},
+		},
+		CommentThread{
+			Comment: comment.Comment{
+				Timestamp: "012346",
+				Resolved:  nil,
+			},
+		},
+	}
+	status := updateThreadsStatus(threads)
+	validateUnresolved(t, status)
+}
+
+func TestFYIThenRejectedThreadsStatus(t *testing.T) {
+	rejected := false
+	threads := []CommentThread{
+		CommentThread{
+			Comment: comment.Comment{
+				Timestamp: "012345",
+				Resolved:  nil,
+			},
+		},
+		CommentThread{
+			Comment: comment.Comment{
+				Timestamp: "012346",
+				Resolved:  &rejected,
+			},
+		},
+	}
+	status := updateThreadsStatus(threads)
+	validateRejected(t, status)
+}
+
+func TestBuildCommentThreads(t *testing.T) {
+	rejected := false
+	accepted := true
+	root := comment.Comment{
+		Timestamp:   "012345",
+		Resolved:    nil,
+		Description: "root",
+	}
+	rootHash, err := root.Hash()
+	if err != nil {
+		t.Fatal(err)
+	}
+	child := comment.Comment{
+		Timestamp:   "012346",
+		Resolved:    nil,
+		Parent:      rootHash,
+		Description: "child",
+	}
+	childHash, err := child.Hash()
+	updatedChild := comment.Comment{
+		Timestamp:   "012346",
+		Resolved:    &rejected,
+		Original:    childHash,
+		Description: "updated child",
+	}
+	updatedChildHash, err := updatedChild.Hash()
+	if err != nil {
+		t.Fatal(err)
+	}
+	leaf := comment.Comment{
+		Timestamp:   "012347",
+		Resolved:    &accepted,
+		Parent:      childHash,
+		Description: "leaf",
+	}
+	leafHash, err := leaf.Hash()
+	if err != nil {
+		t.Fatal(err)
+	}
+	commentsByHash := map[string]comment.Comment{
+		rootHash:         root,
+		childHash:        child,
+		updatedChildHash: updatedChild,
+		leafHash:         leaf,
+	}
+	threads := buildCommentThreads(commentsByHash)
+	if len(threads) != 1 {
+		t.Fatalf("Unexpected threads: %v", threads)
+	}
+	rootThread := threads[0]
+	if rootThread.Comment.Description != "root" {
+		t.Fatalf("Unexpected root thread: %v", rootThread)
+	}
+	if !rootThread.Edited {
+		t.Fatalf("Unexpected root thread edited status: %v", rootThread)
+	}
+	if len(rootThread.Children) != 1 {
+		t.Fatalf("Unexpected root children: %v", rootThread.Children)
+	}
+	rootChild := rootThread.Children[0]
+	if rootChild.Comment.Description != "updated child" {
+		t.Fatalf("Unexpected updated child: %v", rootChild)
+	}
+	if rootChild.Original.Description != "child" {
+		t.Fatalf("Unexpected original child: %v", rootChild)
+	}
+	if len(rootChild.Edits) != 1 {
+		t.Fatalf("Unexpected child history: %v", rootChild.Edits)
+	}
+	if len(rootChild.Children) != 1 {
+		t.Fatalf("Unexpected leaves: %v", rootChild.Children)
+	}
+	threadLeaf := rootChild.Children[0]
+	if threadLeaf.Comment.Description != "leaf" {
+		t.Fatalf("Unexpected leaf: %v", threadLeaf)
+	}
+	if len(threadLeaf.Children) != 0 {
+		t.Fatalf("Unexpected leaf children: %v", threadLeaf.Children)
+	}
+	if threadLeaf.Edited {
+		t.Fatalf("Unexpected leaf edited status: %v", threadLeaf)
+	}
+}
+
+func TestGetHeadCommit(t *testing.T) {
+	repo := repository.NewMockRepoForTest()
+
+	submittedSimpleReview, err := Get(repo, repository.TestCommitB)
+	if err != nil {
+		t.Fatal(err)
+	}
+	submittedSimpleReviewHead, err := submittedSimpleReview.GetHeadCommit()
+	if err != nil {
+		t.Fatal("Unable to compute the head commit for a known review of a simple commit: ", err)
+	}
+	if submittedSimpleReviewHead != repository.TestCommitB {
+		t.Fatal("Unexpected head commit computed for a known review of a simple commit.")
+	}
+
+	submittedModifiedReview, err := Get(repo, repository.TestCommitD)
+	if err != nil {
+		t.Fatal(err)
+	}
+	submittedModifiedReviewHead, err := submittedModifiedReview.GetHeadCommit()
+	if err != nil {
+		t.Fatal("Unable to compute the head commit for a known, multi-commit review: ", err)
+	}
+	if submittedModifiedReviewHead != repository.TestCommitE {
+		t.Fatal("Unexpected head commit for a known, multi-commit review.")
+	}
+
+	pendingReview, err := Get(repo, repository.TestCommitG)
+	if err != nil {
+		t.Fatal(err)
+	}
+	pendingReviewHead, err := pendingReview.GetHeadCommit()
+	if err != nil {
+		t.Fatal("Unable to compute the head commit for a known review of a merge commit: ", err)
+	}
+	if pendingReviewHead != repository.TestCommitI {
+		t.Fatal("Unexpected head commit computed for a pending review.")
+	}
+}
+
+func TestGetBaseCommit(t *testing.T) {
+	repo := repository.NewMockRepoForTest()
+
+	submittedSimpleReview, err := Get(repo, repository.TestCommitB)
+	if err != nil {
+		t.Fatal(err)
+	}
+	submittedSimpleReviewBase, err := submittedSimpleReview.GetBaseCommit()
+	if err != nil {
+		t.Fatal("Unable to compute the base commit for a known review of a simple commit: ", err)
+	}
+	if submittedSimpleReviewBase != repository.TestCommitA {
+		t.Fatal("Unexpected base commit computed for a known review of a simple commit.")
+	}
+
+	submittedMergeReview, err := Get(repo, repository.TestCommitD)
+	if err != nil {
+		t.Fatal(err)
+	}
+	submittedMergeReviewBase, err := submittedMergeReview.GetBaseCommit()
+	if err != nil {
+		t.Fatal("Unable to compute the base commit for a known review of a merge commit: ", err)
+	}
+	if submittedMergeReviewBase != repository.TestCommitC {
+		t.Fatal("Unexpected base commit computed for a known review of a merge commit.")
+	}
+
+	pendingReview, err := Get(repo, repository.TestCommitG)
+	if err != nil {
+		t.Fatal(err)
+	}
+	pendingReviewBase, err := pendingReview.GetBaseCommit()
+	if err != nil {
+		t.Fatal("Unable to compute the base commit for a known review of a merge commit: ", err)
+	}
+	if pendingReviewBase != repository.TestCommitF {
+		t.Fatal("Unexpected base commit computed for a pending review.")
+	}
+
+	abandonRequest := pendingReview.Request
+	abandonRequest.TargetRef = ""
+	abandonNote, err := abandonRequest.Write()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := repo.AppendNote(request.Ref, repository.TestCommitG, abandonNote); err != nil {
+		t.Fatal(err)
+	}
+	abandonedReview, err := Get(repo, repository.TestCommitG)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if abandonedReview.IsOpen() {
+		t.Fatal("Failed to update a review to be abandoned")
+	}
+	abandonedReviewBase, err := abandonedReview.GetBaseCommit()
+	if err != nil {
+		t.Fatal("Unable to compute the base commit for an abandoned review: ", err)
+	}
+	if abandonedReviewBase != repository.TestCommitE {
+		t.Fatal("Unexpected base commit computed for an abandoned review.")
+	}
+}
+
+func TestGetRequests(t *testing.T) {
+	repo := repository.NewMockRepoForTest()
+	pendingReview, err := Get(repo, repository.TestCommitG)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(pendingReview.AllRequests) != 3 || pendingReview.Request.Description != "Final description of G" {
+		t.Fatal("Unexpected requests for a pending review: ", pendingReview.AllRequests, pendingReview.Request)
+	}
+}
+
+func TestRebase(t *testing.T) {
+	repo := repository.NewMockRepoForTest()
+	pendingReview, err := Get(repo, repository.TestCommitG)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// Rebase the review and then confirm that it has been updated correctly.
+	if err := pendingReview.Rebase(true); err != nil {
+		t.Fatal(err)
+	}
+	reviewJSON, err := pendingReview.GetJSON()
+	if err != nil {
+		t.Fatal(err)
+	}
+	headRef, err := repo.GetHeadRef()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if headRef != pendingReview.Request.ReviewRef {
+		t.Fatal("Failed to switch to the review ref during a rebase")
+	}
+	isAncestor, err := repo.IsAncestor(pendingReview.Revision, archiveRef)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !isAncestor {
+		t.Fatalf("Commit %q is not archived", pendingReview.Revision)
+	}
+	reviewCommit, err := repo.GetCommitHash(pendingReview.Request.ReviewRef)
+	if err != nil {
+		t.Fatal(err)
+	}
+	reviewAlias := pendingReview.Request.Alias
+	if reviewAlias == "" || reviewAlias == pendingReview.Revision || reviewCommit != reviewAlias {
+		t.Fatalf("Failed to set the review alias: %q", reviewJSON)
+	}
+
+	// Submit the review.
+	if err := repo.SwitchToRef(pendingReview.Request.TargetRef); err != nil {
+		t.Fatal(err)
+	}
+	if err := repo.MergeRef(pendingReview.Request.ReviewRef, true); err != nil {
+		t.Fatal(err)
+	}
+
+	// Reread the review and confirm that it has been submitted.
+	submittedReview, err := Get(repo, pendingReview.Revision)
+	if err != nil {
+		t.Fatal(err)
+	}
+	submittedReviewJSON, err := submittedReview.GetJSON()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !submittedReview.Submitted {
+		t.Fatalf("Failed to submit the review: %q", submittedReviewJSON)
+	}
+}
+
+func TestRebaseDetachedHead(t *testing.T) {
+	repo := repository.NewMockRepoForTest()
+	pendingReview, err := Get(repo, repository.TestCommitG)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// Switch the review to having a review ref that is not a branch.
+	pendingReview.Request.ReviewRef = repository.TestAlternateReviewRef
+	newNote, err := pendingReview.Request.Write()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := repo.AppendNote(request.Ref, pendingReview.Revision, newNote); err != nil {
+		t.Fatal(err)
+	}
+	pendingReview, err = Get(repo, repository.TestCommitG)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// Rebase the review and then confirm that it has been updated correctly.
+	if err := pendingReview.Rebase(true); err != nil {
+		t.Fatal(err)
+	}
+	headRef, err := repo.GetHeadRef()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if headRef != pendingReview.Request.Alias {
+		t.Fatal("Failed to switch to a detached head during a rebase")
+	}
+	isAncestor, err := repo.IsAncestor(pendingReview.Revision, archiveRef)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !isAncestor {
+		t.Fatalf("Commit %q is not archived", pendingReview.Revision)
+	}
+
+	// Submit the review.
+	if err := repo.SwitchToRef(pendingReview.Request.TargetRef); err != nil {
+		t.Fatal(err)
+	}
+	reviewHead, err := pendingReview.GetHeadCommit()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := repo.MergeRef(reviewHead, true); err != nil {
+		t.Fatal(err)
+	}
+
+	// Reread the review and confirm that it has been submitted.
+	submittedReview, err := Get(repo, pendingReview.Revision)
+	if err != nil {
+		t.Fatal(err)
+	}
+	submittedReviewJSON, err := submittedReview.GetJSON()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !submittedReview.Submitted {
+		t.Fatalf("Failed to submit the review: %q", submittedReviewJSON)
+	}
+}
diff --git a/third_party/go/git-appraise/schema/analysis.json b/third_party/go/git-appraise/schema/analysis.json
new file mode 100644
index 0000000000..cbecb5416b
--- /dev/null
+++ b/third_party/go/git-appraise/schema/analysis.json
@@ -0,0 +1,61 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "type": "object",
+
+  "properties": {
+    "timestamp": {
+      "description": "the number of seconds since the Unix epoch",
+      "type": "string",
+      "minLength": 10,
+      "maxLength": 10,
+      "pattern": "[0-9]{10,10}"
+    },
+
+    "status": {
+      "description": "represents the overall status of all messages from the analysis results",
+      "oneOf": [{
+        "$ref": "#/definitions/lgtm"
+      }, {
+        "$ref": "#/definitions/fyi"
+      }, {
+        "$ref": "#/definitions/nmw"
+      }]
+    },
+
+    "url": {
+      "description": "a publicly readable file, which contains JSON formatted analysis results. Those results should conform to the JSON format of the ShipshapeResponse protocol buffer message defined https://github.com/google/shipshape/blob/master/shipshape/proto/shipshape_rpc.proto",
+      "type": "string"
+    },
+
+    "v": {
+      "type": "integer",
+      "enum": [0]
+    }
+  },
+
+  "required": [
+    "timestamp",
+    "url"
+  ],
+
+  "definitions": {
+    "lgtm": {
+      "title": "Looks Good To Me",
+      "description": "indicates the analysis produced no messages",
+      "type": "string",
+      "enum": ["lgtm"]
+    },
+    "fyi": {
+      "title": "For your information",
+      "description": "indicates the analysis produced some messages, but none of them indicate errors",
+      "type": "string",
+      "enum": ["fyi"]
+    },
+    "nmw": {
+      "title": "Needs more work",
+      "description": "indicates the analysis produced at least one message indicating an error",
+      "type": "string",
+      "enum": ["nmw"]
+    }
+  }
+}
diff --git a/third_party/go/git-appraise/schema/ci.json b/third_party/go/git-appraise/schema/ci.json
new file mode 100644
index 0000000000..7436408290
--- /dev/null
+++ b/third_party/go/git-appraise/schema/ci.json
@@ -0,0 +1,42 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "type": "object",
+
+  "properties": {
+    "timestamp": {
+      "description": "the number of seconds since the Unix epoch",
+      "type": "string",
+      "minLength": 10,
+      "maxLength": 10,
+      "pattern": "[0-9]{10,10}"
+    },
+
+    "agent": {
+      "description": "a free-form string that identifies the build and test runner",
+      "type": "string"
+    },
+
+    "status": {
+      "description": "the final status of a build or test",
+      "type": "string",
+      "enum": [
+        "success",
+        "failure"
+      ]
+    },
+
+    "url": {
+      "type": "string"
+    },
+
+    "v": {
+      "type": "integer",
+      "enum": [0]
+    }
+  },
+
+  "required": [
+    "timestamp",
+    "agent"
+  ]
+}
diff --git a/third_party/go/git-appraise/schema/comment.json b/third_party/go/git-appraise/schema/comment.json
new file mode 100644
index 0000000000..a39b1a2e67
--- /dev/null
+++ b/third_party/go/git-appraise/schema/comment.json
@@ -0,0 +1,75 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "type": "object",
+
+  "properties": {
+    "timestamp": {
+      "description": "the number of seconds since the Unix epoch",
+      "type": "string",
+      "minLength": 10,
+      "maxLength": 10,
+      "pattern": "[0-9]{10,10}"
+    },
+
+    "author": {
+      "type": "string"
+    },
+
+    "original": {
+      "description": "the SHA1 hash of another comment on the same revision, and it means this comment is an updated version of that comment",
+      "type": "string"
+    },
+
+    "parent": {
+      "description": "the SHA1 hash of another comment on the same revision, and it means this comment is a reply to that comment",
+      "type": "string"
+    },
+
+    "location": {
+      "type": "object",
+      "properties": {
+        "commit": {
+          "type": "string"
+        },
+        "path": {
+          "type": "string"
+        },
+        "range": {
+          "type": "object",
+          "properties": {
+            "startLine": {
+              "type": "integer"
+            },
+            "startColumn": {
+              "type": "integer"
+            },
+            "endLine": {
+              "type": "integer"
+            },
+            "endColumn": {
+              "type": "integer"
+            }
+          }
+        }
+      }
+    },
+
+    "description": {
+      "type": "string"
+    },
+
+    "resolved": {
+      "type": "boolean"
+    },
+
+    "v": {
+      "type": "integer",
+      "enum": [0]
+    }
+  },
+
+  "required": [
+    "timestamp",
+    "author"
+  ]
+}
diff --git a/third_party/go/git-appraise/schema/request.json b/third_party/go/git-appraise/schema/request.json
new file mode 100644
index 0000000000..9ec022a16e
--- /dev/null
+++ b/third_party/go/git-appraise/schema/request.json
@@ -0,0 +1,58 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "type": "object",
+
+  "properties": {
+    "timestamp": {
+      "description": "the number of seconds since the Unix epoch",
+      "type": "string",
+      "minLength": 10,
+      "maxLength": 10,
+      "pattern": "[0-9]{10,10}"
+    },
+
+    "requester": {
+      "type": "string"
+    },
+
+    "baseCommit": {
+      "type": "string"
+    },
+
+    "reviewRef": {
+      "description": "used to specify a git ref that tracks the current revision under review",
+      "type": "string"
+    },
+
+    "targetRef": {
+      "description": "used to specify the git ref that should be updated once the review is approved",
+      "type": "string"
+    },
+
+    "reviewers": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+
+    "description": {
+      "type": "string"
+    },
+
+    "v": {
+      "type": "integer",
+      "enum": [0]
+    },
+
+    "alias": {
+      "description": "used to specify a post-rebase commit hash for the review",
+      "type": "string"
+    }
+  },
+
+  "required": [
+    "timestamp",
+    "requester"
+  ]
+}