Include RE2 library

third_party/re2/lib/codereview/codereview.py

+# coding=utf-8
+# (The line above is necessary so that I can use 世界 in the
+# *comment* below without Python getting all bent out of shape.)
+
+# Copyright 2007-2009 Google Inc.
+#
+# 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.
+
+'''Mercurial interface to codereview.appspot.com.
+
+To configure, set the following options in
+your repository's .hg/hgrc file.
+
+        [extensions]
+        codereview = /path/to/codereview.py
+
+        [codereview]
+        server = codereview.appspot.com
+
+The server should be running Rietveld; see http://code.google.com/p/rietveld/.
+
+In addition to the new commands, this extension introduces
+the file pattern syntax @nnnnnn, where nnnnnn is a change list
+number, to mean the files included in that change list, which
+must be associated with the current client.
+
+For example, if change 123456 contains the files x.go and y.go,
+"hg diff @123456" is equivalent to"hg diff x.go y.go".
+'''
+
+import sys
+
+if __name__ == "__main__":
+        print >>sys.stderr, "This is a Mercurial extension and should not be invoked directly."
+        sys.exit(2)
+
+# We require Python 2.6 for the json package.
+if sys.version < '2.6':
+        print >>sys.stderr, "The codereview extension requires Python 2.6 or newer."
+        print >>sys.stderr, "You are running Python " + sys.version
+        sys.exit(2)
+
+import json
+import os
+import re
+import stat
+import subprocess
+import threading
+import time
+
+from mercurial import commands as hg_commands
+from mercurial import util as hg_util
+
+defaultcc = None
+codereview_disabled = None
+real_rollback = None
+releaseBranch = None
+server = "codereview.appspot.com"
+server_url_base = None
+
+#######################################################################
+# Normally I would split this into multiple files, but it simplifies
+# import path headaches to keep it all in one file.  Sorry.
+# The different parts of the file are separated by banners like this one.
+
+#######################################################################
+# Helpers
+
+def RelativePath(path, cwd):
+        n = len(cwd)
+        if path.startswith(cwd) and path[n] == '/':
+                return path[n+1:]
+        return path
+
+def Sub(l1, l2):
+        return [l for l in l1 if l not in l2]
+
+def Add(l1, l2):
+        l = l1 + Sub(l2, l1)
+        l.sort()
+        return l
+
+def Intersect(l1, l2):
+        return [l for l in l1 if l in l2]
+
+#######################################################################
+# RE: UNICODE STRING HANDLING
+#
+# Python distinguishes between the str (string of bytes)
+# and unicode (string of code points) types.  Most operations
+# work on either one just fine, but some (like regexp matching)
+# require unicode, and others (like write) require str.
+#
+# As befits the language, Python hides the distinction between
+# unicode and str by converting between them silently, but
+# *only* if all the bytes/code points involved are 7-bit ASCII.
+# This means that if you're not careful, your program works
+# fine on "hello, world" and fails on "hello, 世界".  And of course,
+# the obvious way to be careful - use static types - is unavailable.
+# So the only way is trial and error to find where to put explicit
+# conversions.
+#
+# Because more functions do implicit conversion to str (string of bytes)
+# than do implicit conversion to unicode (string of code points),
+# the convention in this module is to represent all text as str,
+# converting to unicode only when calling a unicode-only function
+# and then converting back to str as soon as possible.
+
+def typecheck(s, t):
+        if type(s) != t:
+                raise hg_util.Abort("type check failed: %s has type %s != %s" % (repr(s), type(s), t))
+
+# If we have to pass unicode instead of str, ustr does that conversion clearly.
+def ustr(s):
+        typecheck(s, str)
+        return s.decode("utf-8")
+
+# Even with those, Mercurial still sometimes turns unicode into str
+# and then tries to use it as ascii.  Change Mercurial's default.
+def set_mercurial_encoding_to_utf8():
+        from mercurial import encoding
+        encoding.encoding = 'utf-8'
+
+set_mercurial_encoding_to_utf8()
+
+# Even with those we still run into problems.
+# I tried to do things by the book but could not convince
+# Mercurial to let me check in a change with UTF-8 in the
+# CL description or author field, no matter how many conversions
+# between str and unicode I inserted and despite changing the
+# default encoding.  I'm tired of this game, so set the default
+# encoding for all of Python to 'utf-8', not 'ascii'.
+def default_to_utf8():
+        import sys
+        stdout, __stdout__ = sys.stdout, sys.__stdout__
+        reload(sys)  # site.py deleted setdefaultencoding; get it back
+        sys.stdout, sys.__stdout__ = stdout, __stdout__
+        sys.setdefaultencoding('utf-8')
+
+default_to_utf8()
+
+#######################################################################
+# Status printer for long-running commands
+
+global_status = None
+
+def set_status(s):
+        # print >>sys.stderr, "\t", time.asctime(), s
+        global global_status
+        global_status = s
+
+class StatusThread(threading.Thread):
+        def __init__(self):
+                threading.Thread.__init__(self)
+        def run(self):
+                # pause a reasonable amount of time before
+                # starting to display status messages, so that
+                # most hg commands won't ever see them.
+                time.sleep(30)
+
+                # now show status every 15 seconds
+                while True:
+                        time.sleep(15 - time.time() % 15)
+                        s = global_status
+                        if s is None:
+                                continue
+                        if s == "":
+                                s = "(unknown status)"
+                        print >>sys.stderr, time.asctime(), s
+
+def start_status_thread():
+        t = StatusThread()
+        t.setDaemon(True)  # allowed to exit if t is still running
+        t.start()
+
+#######################################################################
+# Change list parsing.
+#
+# Change lists are stored in .hg/codereview/cl.nnnnnn
+# where nnnnnn is the number assigned by the code review server.
+# Most data about a change list is stored on the code review server
+# too: the description, reviewer, and cc list are all stored there.
+# The only thing in the cl.nnnnnn file is the list of relevant files.
+# Also, the existence of the cl.nnnnnn file marks this repository
+# as the one where the change list lives.
+
+emptydiff = """Index: ~rietveld~placeholder~
+===================================================================
+diff --git a/~rietveld~placeholder~ b/~rietveld~placeholder~
+new file mode 100644
+"""
+
+class CL(object):
+        def __init__(self, name):
+                typecheck(name, str)
+                self.name = name
+                self.desc = ''
+                self.files = []
+                self.reviewer = []
+                self.cc = []
+                self.url = ''
+                self.local = False
+                self.web = False
+                self.copied_from = None # None means current user
+                self.mailed = False
+                self.private = False
+                self.lgtm = []
+
+        def DiskText(self):
+                cl = self
+                s = ""
+                if cl.copied_from:
+                        s += "Author: " + cl.copied_from + "\n\n"
+                if cl.private:
+                        s += "Private: " + str(self.private) + "\n"
+                s += "Mailed: " + str(self.mailed) + "\n"
+                s += "Description:\n"
+                s += Indent(cl.desc, "\t")
+                s += "Files:\n"
+                for f in cl.files:
+                        s += "\t" + f + "\n"
+                typecheck(s, str)
+                return s
+
+        def EditorText(self):
+                cl = self
+                s = _change_prolog
+                s += "\n"
+                if cl.copied_from:
+                        s += "Author: " + cl.copied_from + "\n"
+                if cl.url != '':
+                        s += 'URL: ' + cl.url + '       # cannot edit\n\n'
+                if cl.private:
+                        s += "Private: True\n"
+                s += "Reviewer: " + JoinComma(cl.reviewer) + "\n"
+                s += "CC: " + JoinComma(cl.cc) + "\n"
+                s += "\n"
+                s += "Description:\n"
+                if cl.desc == '':
+                        s += "\t<enter description here>\n"
+                else:
+                        s += Indent(cl.desc, "\t")
+                s += "\n"
+                if cl.local or cl.name == "new":
+                        s += "Files:\n"
+                        for f in cl.files:
+                                s += "\t" + f + "\n"
+                        s += "\n"
+                typecheck(s, str)
+                return s
+
+        def PendingText(self, quick=False):
+                cl = self
+                s = cl.name + ":" + "\n"
+                s += Indent(cl.desc, "\t")
+                s += "\n"
+                if cl.copied_from:
+                        s += "\tAuthor: " + cl.copied_from + "\n"
+                if not quick:
+                        s += "\tReviewer: " + JoinComma(cl.reviewer) + "\n"
+                        for (who, line) in cl.lgtm:
+                                s += "\t\t" + who + ": " + line + "\n"
+                        s += "\tCC: " + JoinComma(cl.cc) + "\n"
+                s += "\tFiles:\n"
+                for f in cl.files:
+                        s += "\t\t" + f + "\n"
+                typecheck(s, str)
+                return s
+
+        def Flush(self, ui, repo):
+                if self.name == "new":
+                        self.Upload(ui, repo, gofmt_just_warn=True, creating=True)
+                dir = CodeReviewDir(ui, repo)
+                path = dir + '/cl.' + self.name
+                f = open(path+'!', "w")
+                f.write(self.DiskText())
+                f.close()
+                if sys.platform == "win32" and os.path.isfile(path):
+                        os.remove(path)
+                os.rename(path+'!', path)
+                if self.web and not self.copied_from:
+                        EditDesc(self.name, desc=self.desc,
+                                reviewers=JoinComma(self.reviewer), cc=JoinComma(self.cc),
+                                private=self.private)
+
+        def Delete(self, ui, repo):
+                dir = CodeReviewDir(ui, repo)
+                os.unlink(dir + "/cl." + self.name)
+
+        def Subject(self):
+                s = line1(self.desc)
+                if len(s) > 60:
+                        s = s[0:55] + "..."
+                if self.name != "new":
+                        s = "code review %s: %s" % (self.name, s)
+                typecheck(s, str)
+                return s
+
+        def Upload(self, ui, repo, send_mail=False, gofmt=True, gofmt_just_warn=False, creating=False, quiet=False):
+                if not self.files and not creating:
+                        ui.warn("no files in change list\n")
+                if ui.configbool("codereview", "force_gofmt", True) and gofmt:
+                        CheckFormat(ui, repo, self.files, just_warn=gofmt_just_warn)
+                set_status("uploading CL metadata + diffs")
+                os.chdir(repo.root)
+                form_fields = [
+                        ("content_upload", "1"),
+                        ("reviewers", JoinComma(self.reviewer)),
+                        ("cc", JoinComma(self.cc)),
+                        ("description", self.desc),
+                        ("base_hashes", ""),
+                ]
+
+                if self.name != "new":
+                        form_fields.append(("issue", self.name))
+                vcs = None
+                # We do not include files when creating the issue,
+                # because we want the patch sets to record the repository
+                # and base revision they are diffs against.  We use the patch
+                # set message for that purpose, but there is no message with
+                # the first patch set.  Instead the message gets used as the
+                # new CL's overall subject.  So omit the diffs when creating
+                # and then we'll run an immediate upload.
+                # This has the effect that every CL begins with an empty "Patch set 1".
+                if self.files and not creating:
+                        vcs = MercurialVCS(upload_options, ui, repo)
+                        data = vcs.GenerateDiff(self.files)
+                        files = vcs.GetBaseFiles(data)
+                        if len(data) > MAX_UPLOAD_SIZE:
+                                uploaded_diff_file = []
+                                form_fields.append(("separate_patches", "1"))
+                        else:
+                                uploaded_diff_file = [("data", "data.diff", data)]
+                else:
+                        uploaded_diff_file = [("data", "data.diff", emptydiff)]
+                
+                if vcs and self.name != "new":
+                        form_fields.append(("subject", "diff -r " + vcs.base_rev + " " + ui.expandpath("default")))
+                else:
+                        # First upload sets the subject for the CL itself.
+                        form_fields.append(("subject", self.Subject()))
+                ctype, body = EncodeMultipartFormData(form_fields, uploaded_diff_file)
+                response_body = MySend("/upload", body, content_type=ctype)
+                patchset = None
+                msg = response_body
+                lines = msg.splitlines()
+                if len(lines) >= 2:
+                        msg = lines[0]
+                        patchset = lines[1].strip()
+                        patches = [x.split(" ", 1) for x in lines[2:]]
+                if response_body.startswith("Issue updated.") and quiet:
+                        pass
+                else:
+                        ui.status(msg + "\n")
+                set_status("uploaded CL metadata + diffs")
+                if not response_body.startswith("Issue created.") and not response_body.startswith("Issue updated."):
+                        raise hg_util.Abort("failed to update issue: " + response_body)
+                issue = msg[msg.rfind("/")+1:]
+                self.name = issue
+                if not self.url:
+                        self.url = server_url_base + self.name
+                if not uploaded_diff_file:
+                        set_status("uploading patches")
+                        patches = UploadSeparatePatches(issue, rpc, patchset, data, upload_options)
+                if vcs:
+                        set_status("uploading base files")
+                        vcs.UploadBaseFiles(issue, rpc, patches, patchset, upload_options, files)
+                if send_mail:
+                        set_status("sending mail")
+                        MySend("/" + issue + "/mail", payload="")
+                self.web = True
+                set_status("flushing changes to disk")
+                self.Flush(ui, repo)
+                return
+
+        def Mail(self, ui, repo):
+                pmsg = "Hello " + JoinComma(self.reviewer)
+                if self.cc:
+                        pmsg += " (cc: %s)" % (', '.join(self.cc),)
+                pmsg += ",\n"
+                pmsg += "\n"
+                repourl = ui.expandpath("default")
+                if not self.mailed:
+                        pmsg += "I'd like you to review this change to\n" + repourl + "\n"
+                else:
+                        pmsg += "Please take another look.\n"
+                typecheck(pmsg, str)
+                PostMessage(ui, self.name, pmsg, subject=self.Subject())
+                self.mailed = True
+                self.Flush(ui, repo)
+
+def GoodCLName(name):
+        typecheck(name, str)
+        return re.match("^[0-9]+$", name)
+
+def ParseCL(text, name):
+        typecheck(text, str)
+        typecheck(name, str)
+        sname = None
+        lineno = 0
+        sections = {
+                'Author': '',
+                'Description': '',
+                'Files': '',
+                'URL': '',
+                'Reviewer': '',
+                'CC': '',
+                'Mailed': '',
+                'Private': '',
+        }
+        for line in text.split('\n'):
+                lineno += 1
+                line = line.rstrip()
+                if line != '' and line[0] == '#':
+                        continue
+                if line == '' or line[0] == ' ' or line[0] == '\t':
+                        if sname == None and line != '':
+                                return None, lineno, 'text outside section'
+                        if sname != None:
+                                sections[sname] += line + '\n'
+                        continue
+                p = line.find(':')
+                if p >= 0:
+                        s, val = line[:p].strip(), line[p+1:].strip()
+                        if s in sections:
+                                sname = s
+                                if val != '':
+                                        sections[sname] += val + '\n'
+                                continue
+                return None, lineno, 'malformed section header'
+
+        for k in sections:
+                sections[k] = StripCommon(sections[k]).rstrip()
+
+        cl = CL(name)
+        if sections['Author']:
+                cl.copied_from = sections['Author']
+        cl.desc = sections['Description']
+        for line in sections['Files'].split('\n'):
+                i = line.find('#')
+                if i >= 0:
+                        line = line[0:i].rstrip()
+                line = line.strip()
+                if line == '':
+                        continue
+                cl.files.append(line)
+        cl.reviewer = SplitCommaSpace(sections['Reviewer'])
+        cl.cc = SplitCommaSpace(sections['CC'])
+        cl.url = sections['URL']
+        if sections['Mailed'] != 'False':
+                # Odd default, but avoids spurious mailings when
+                # reading old CLs that do not have a Mailed: line.
+                # CLs created with this update will always have 
+                # Mailed: False on disk.
+                cl.mailed = True
+        if sections['Private'] in ('True', 'true', 'Yes', 'yes'):
+                cl.private = True
+        if cl.desc == '<enter description here>':
+                cl.desc = ''
+        return cl, 0, ''
+
+def SplitCommaSpace(s):
+        typecheck(s, str)
+        s = s.strip()
+        if s == "":
+                return []
+        return re.split(", *", s)
+
+def CutDomain(s):
+        typecheck(s, str)
+        i = s.find('@')
+        if i >= 0:
+                s = s[0:i]
+        return s
+
+def JoinComma(l):
+        for s in l:
+                typecheck(s, str)
+        return ", ".join(l)
+
+def ExceptionDetail():
+        s = str(sys.exc_info()[0])
+        if s.startswith("<type '") and s.endswith("'>"):
+                s = s[7:-2]
+        elif s.startswith("<class '") and s.endswith("'>"):
+                s = s[8:-2]
+        arg = str(sys.exc_info()[1])
+        if len(arg) > 0:
+                s += ": " + arg
+        return s
+
+def IsLocalCL(ui, repo, name):
+        return GoodCLName(name) and os.access(CodeReviewDir(ui, repo) + "/cl." + name, 0)
+
+# Load CL from disk and/or the web.
+def LoadCL(ui, repo, name, web=True):
+        typecheck(name, str)
+        set_status("loading CL " + name)
+        if not GoodCLName(name):
+                return None, "invalid CL name"
+        dir = CodeReviewDir(ui, repo)
+        path = dir + "cl." + name
+        if os.access(path, 0):
+                ff = open(path)
+                text = ff.read()
+                ff.close()
+                cl, lineno, err = ParseCL(text, name)
+                if err != "":
+                        return None, "malformed CL data: "+err
+                cl.local = True
+        else:
+                cl = CL(name)
+        if web:
+                set_status("getting issue metadata from web")
+                d = JSONGet(ui, "/api/" + name + "?messages=true")
+                set_status(None)
+                if d is None:
+                        return None, "cannot load CL %s from server" % (name,)
+                if 'owner_email' not in d or 'issue' not in d or str(d['issue']) != name:
+                        return None, "malformed response loading CL data from code review server"
+                cl.dict = d
+                cl.reviewer = d.get('reviewers', [])
+                cl.cc = d.get('cc', [])
+                if cl.local and cl.copied_from and cl.desc:
+                        # local copy of CL written by someone else
+                        # and we saved a description.  use that one,
+                        # so that committers can edit the description
+                        # before doing hg submit.
+                        pass
+                else:
+                        cl.desc = d.get('description', "")
+                cl.url = server_url_base + name
+                cl.web = True
+                cl.private = d.get('private', False) != False
+                cl.lgtm = []
+                for m in d.get('messages', []):
+                        if m.get('approval', False) == True:
+                                who = re.sub('@.*', '', m.get('sender', ''))
+                                text = re.sub("\n(.|\n)*", '', m.get('text', ''))
+                                cl.lgtm.append((who, text))
+
+        set_status("loaded CL " + name)
+        return cl, ''
+
+class LoadCLThread(threading.Thread):
+        def __init__(self, ui, repo, dir, f, web):
+                threading.Thread.__init__(self)
+                self.ui = ui
+                self.repo = repo
+                self.dir = dir
+                self.f = f
+                self.web = web
+                self.cl = None
+        def run(self):
+                cl, err = LoadCL(self.ui, self.repo, self.f[3:], web=self.web)
+                if err != '':
+                        self.ui.warn("loading "+self.dir+self.f+": " + err + "\n")
+                        return
+                self.cl = cl
+
+# Load all the CLs from this repository.
+def LoadAllCL(ui, repo, web=True):
+        dir = CodeReviewDir(ui, repo)
+        m = {}
+        files = [f for f in os.listdir(dir) if f.startswith('cl.')]
+        if not files:
+                return m
+        active = []
+        first = True
+        for f in files:
+                t = LoadCLThread(ui, repo, dir, f, web)
+                t.start()
+                if web and first:
+                        # first request: wait in case it needs to authenticate
+                        # otherwise we get lots of user/password prompts
+                        # running in parallel.
+                        t.join()
+                        if t.cl:
+                                m[t.cl.name] = t.cl
+                        first = False
+                else:
+                        active.append(t)
+        for t in active:
+                t.join()
+                if t.cl:
+                        m[t.cl.name] = t.cl
+        return m
+
+# Find repository root.  On error, ui.warn and return None
+def RepoDir(ui, repo):
+        url = repo.url();
+        if not url.startswith('file:'):
+                ui.warn("repository %s is not in local file system\n" % (url,))
+                return None
+        url = url[5:]
+        if url.endswith('/'):
+                url = url[:-1]
+        typecheck(url, str)
+        return url
+
+# Find (or make) code review directory.  On error, ui.warn and return None
+def CodeReviewDir(ui, repo):
+        dir = RepoDir(ui, repo)
+        if dir == None:
+                return None
+        dir += '/.hg/codereview/'
+        if not os.path.isdir(dir):
+                try:
+                        os.mkdir(dir, 0700)
+                except:
+                        ui.warn('cannot mkdir %s: %s\n' % (dir, ExceptionDetail()))
+                        return None
+        typecheck(dir, str)
+        return dir
+
+# Turn leading tabs into spaces, so that the common white space
+# prefix doesn't get confused when people's editors write out 
+# some lines with spaces, some with tabs.  Only a heuristic
+# (some editors don't use 8 spaces either) but a useful one.
+def TabsToSpaces(line):
+        i = 0
+        while i < len(line) and line[i] == '\t':
+                i += 1
+        return ' '*(8*i) + line[i:]
+
+# Strip maximal common leading white space prefix from text
+def StripCommon(text):
+        typecheck(text, str)
+        ws = None
+        for line in text.split('\n'):
+                line = line.rstrip()
+                if line == '':
+                        continue
+                line = TabsToSpaces(line)
+                white = line[:len(line)-len(line.lstrip())]
+                if ws == None:
+                        ws = white
+                else:
+                        common = ''
+                        for i in range(min(len(white), len(ws))+1):
+                                if white[0:i] == ws[0:i]:
+                                        common = white[0:i]
+                        ws = common
+                if ws == '':
+                        break
+        if ws == None:
+                return text
+        t = ''
+        for line in text.split('\n'):
+                line = line.rstrip()
+                line = TabsToSpaces(line)
+                if line.startswith(ws):
+                        line = line[len(ws):]
+                if line == '' and t == '':
+                        continue
+                t += line + '\n'
+        while len(t) >= 2 and t[-2:] == '\n\n':
+                t = t[:-1]
+        typecheck(t, str)
+        return t
+
+# Indent text with indent.
+def Indent(text, indent):
+        typecheck(text, str)
+        typecheck(indent, str)
+        t = ''
+        for line in text.split('\n'):
+                t += indent + line + '\n'
+        typecheck(t, str)
+        return t
+
+# Return the first line of l
+def line1(text):
+        typecheck(text, str)
+        return text.split('\n')[0]
+
+_change_prolog = """# Change list.
+# Lines beginning with # are ignored.
+# Multi-line values should be indented.
+"""
+
+desc_re = '^(.+: |(tag )?(release|weekly)\.|fix build|undo CL)'
+
+desc_msg = '''Your CL description appears not to use the standard form.
+
+The first line of your change description is conventionally a
+one-line summary of the change, prefixed by the primary affected package,
+and is used as the subject for code review mail; the rest of the description
+elaborates.
+
+Examples:
+
+        encoding/rot13: new package
+
+        math: add IsInf, IsNaN
+        
+        net: fix cname in LookupHost
+
+        unicode: update to Unicode 5.0.2
+
+'''
+
+def promptyesno(ui, msg):
+        return ui.promptchoice(msg, ["&yes", "&no"], 0) == 0
+
+def promptremove(ui, repo, f):
+        if promptyesno(ui, "hg remove %s (y/n)?" % (f,)):
+                if hg_commands.remove(ui, repo, 'path:'+f) != 0:
+                        ui.warn("error removing %s" % (f,))
+
+def promptadd(ui, repo, f):
+        if promptyesno(ui, "hg add %s (y/n)?" % (f,)):
+                if hg_commands.add(ui, repo, 'path:'+f) != 0:
+                        ui.warn("error adding %s" % (f,))
+
+def EditCL(ui, repo, cl):
+        set_status(None)        # do not show status
+        s = cl.EditorText()
+        while True:
+                s = ui.edit(s, ui.username())
+                
+                # We can't trust Mercurial + Python not to die before making the change,
+                # so, by popular demand, just scribble the most recent CL edit into
+                # $(hg root)/last-change so that if Mercurial does die, people
+                # can look there for their work.
+                try:
+                        f = open(repo.root+"/last-change", "w")
+                        f.write(s)
+                        f.close()
+                except:
+                        pass
+
+                clx, line, err = ParseCL(s, cl.name)
+                if err != '':
+                        if not promptyesno(ui, "error parsing change list: line %d: %s\nre-edit (y/n)?" % (line, err)):
+                                return "change list not modified"
+                        continue
+                
+                # Check description.
+                if clx.desc == '':
+                        if promptyesno(ui, "change list should have a description\nre-edit (y/n)?"):
+                                continue
+                elif re.search('<enter reason for undo>', clx.desc):
+                        if promptyesno(ui, "change list description omits reason for undo\nre-edit (y/n)?"):
+                                continue
+                elif not re.match(desc_re, clx.desc.split('\n')[0]):
+                        if promptyesno(ui, desc_msg + "re-edit (y/n)?"):
+                                continue
+
+                # Check file list for files that need to be hg added or hg removed
+                # or simply aren't understood.
+                pats = ['path:'+f for f in clx.files]
+                changed = hg_matchPattern(ui, repo, *pats, modified=True, added=True, removed=True)
+                deleted = hg_matchPattern(ui, repo, *pats, deleted=True)
+                unknown = hg_matchPattern(ui, repo, *pats, unknown=True)
+                ignored = hg_matchPattern(ui, repo, *pats, ignored=True)
+                clean = hg_matchPattern(ui, repo, *pats, clean=True)
+                files = []
+                for f in clx.files:
+                        if f in changed:
+                                files.append(f)
+                                continue
+                        if f in deleted:
+                                promptremove(ui, repo, f)
+                                files.append(f)
+                                continue
+                        if f in unknown:
+                                promptadd(ui, repo, f)
+                                files.append(f)
+                                continue
+                        if f in ignored:
+                                ui.warn("error: %s is excluded by .hgignore; omitting\n" % (f,))
+                                continue
+                        if f in clean:
+                                ui.warn("warning: %s is listed in the CL but unchanged\n" % (f,))
+                                files.append(f)
+                                continue
+                        p = repo.root + '/' + f
+                        if os.path.isfile(p):
+                                ui.warn("warning: %s is a file but not known to hg\n" % (f,))
+                                files.append(f)
+                                continue
+                        if os.path.isdir(p):
+                                ui.warn("error: %s is a directory, not a file; omitting\n" % (f,))
+                                continue
+                        ui.warn("error: %s does not exist; omitting\n" % (f,))
+                clx.files = files
+
+                cl.desc = clx.desc
+                cl.reviewer = clx.reviewer
+                cl.cc = clx.cc
+                cl.files = clx.files
+                cl.private = clx.private
+                break
+        return ""
+
+# For use by submit, etc. (NOT by change)
+# Get change list number or list of files from command line.
+# If files are given, make a new change list.
+def CommandLineCL(ui, repo, pats, opts, defaultcc=None):
+        if len(pats) > 0 and GoodCLName(pats[0]):
+                if len(pats) != 1:
+                        return None, "cannot specify change number and file names"
+                if opts.get('message'):
+                        return None, "cannot use -m with existing CL"
+                cl, err = LoadCL(ui, repo, pats[0], web=True)
+                if err != "":
+                        return None, err
+        else:
+                cl = CL("new")
+                cl.local = True
+                cl.files = ChangedFiles(ui, repo, pats, taken=Taken(ui, repo))
+                if not cl.files:
+                        return None, "no files changed"
+        if opts.get('reviewer'):
+                cl.reviewer = Add(cl.reviewer, SplitCommaSpace(opts.get('reviewer')))
+        if opts.get('cc'):
+                cl.cc = Add(cl.cc, SplitCommaSpace(opts.get('cc')))
+        if defaultcc:
+                cl.cc = Add(cl.cc, defaultcc)
+        if cl.name == "new":
+                if opts.get('message'):
+                        cl.desc = opts.get('message')
+                else:
+                        err = EditCL(ui, repo, cl)
+                        if err != '':
+                                return None, err
+        return cl, ""
+
+#######################################################################
+# Change list file management
+
+# Return list of changed files in repository that match pats.
+# The patterns came from the command line, so we warn
+# if they have no effect or cannot be understood.
+def ChangedFiles(ui, repo, pats, taken=None):
+        taken = taken or {}
+        # Run each pattern separately so that we can warn about
+        # patterns that didn't do anything useful.
+        for p in pats:
+                for f in hg_matchPattern(ui, repo, p, unknown=True):
+                        promptadd(ui, repo, f)
+                for f in hg_matchPattern(ui, repo, p, removed=True):
+                        promptremove(ui, repo, f)
+                files = hg_matchPattern(ui, repo, p, modified=True, added=True, removed=True)
+                for f in files:
+                        if f in taken:
+                                ui.warn("warning: %s already in CL %s\n" % (f, taken[f].name))
+                if not files:
+                        ui.warn("warning: %s did not match any modified files\n" % (p,))
+
+        # Again, all at once (eliminates duplicates)
+        l = hg_matchPattern(ui, repo, *pats, modified=True, added=True, removed=True)
+        l.sort()
+        if taken:
+                l = Sub(l, taken.keys())
+        return l
+
+# Return list of changed files in repository that match pats and still exist.
+def ChangedExistingFiles(ui, repo, pats, opts):
+        l = hg_matchPattern(ui, repo, *pats, modified=True, added=True)
+        l.sort()
+        return l
+
+# Return list of files claimed by existing CLs
+def Taken(ui, repo):
+        all = LoadAllCL(ui, repo, web=False)
+        taken = {}
+        for _, cl in all.items():
+                for f in cl.files:
+                        taken[f] = cl
+        return taken
+
+# Return list of changed files that are not claimed by other CLs
+def DefaultFiles(ui, repo, pats):
+        return ChangedFiles(ui, repo, pats, taken=Taken(ui, repo))
+
+#######################################################################
+# File format checking.
+
+def CheckFormat(ui, repo, files, just_warn=False):
+        set_status("running gofmt")
+        CheckGofmt(ui, repo, files, just_warn)
+        CheckTabfmt(ui, repo, files, just_warn)
+
+# Check that gofmt run on the list of files does not change them
+def CheckGofmt(ui, repo, files, just_warn):
+        files = gofmt_required(files)
+        if not files:
+                return
+        cwd = os.getcwd()
+        files = [RelativePath(repo.root + '/' + f, cwd) for f in files]
+        files = [f for f in files if os.access(f, 0)]
+        if not files:
+                return
+        try:
+                cmd = subprocess.Popen(["gofmt", "-l"] + files, shell=False, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, close_fds=sys.platform != "win32")
+                cmd.stdin.close()
+        except:
+                raise hg_util.Abort("gofmt: " + ExceptionDetail())
+        data = cmd.stdout.read()
+        errors = cmd.stderr.read()
+        cmd.wait()
+        set_status("done with gofmt")
+        if len(errors) > 0:
+                ui.warn("gofmt errors:\n" + errors.rstrip() + "\n")
+                return
+        if len(data) > 0:
+                msg = "gofmt needs to format these files (run hg gofmt):\n" + Indent(data, "\t").rstrip()
+                if just_warn:
+                        ui.warn("warning: " + msg + "\n")
+                else:
+                        raise hg_util.Abort(msg)
+        return
+
+# Check that *.[chys] files indent using tabs.
+def CheckTabfmt(ui, repo, files, just_warn):
+        files = [f for f in files if f.startswith('src/') and re.search(r"\.[chys]$", f) and not re.search(r"\.tab\.[ch]$", f)]
+        if not files:
+                return
+        cwd = os.getcwd()
+        files = [RelativePath(repo.root + '/' + f, cwd) for f in files]
+        files = [f for f in files if os.access(f, 0)]
+        badfiles = []
+        for f in files:
+                try:
+                        for line in open(f, 'r'):
+                                # Four leading spaces is enough to complain about,
+                                # except that some Plan 9 code uses four spaces as the label indent,
+                                # so allow that.
+                                if line.startswith('    ') and not re.match('    [A-Za-z0-9_]+:', line):
+                                        badfiles.append(f)
+                                        break
+                except:
+                        # ignore cannot open file, etc.
+                        pass
+        if len(badfiles) > 0:
+                msg = "these files use spaces for indentation (use tabs instead):\n\t" + "\n\t".join(badfiles)
+                if just_warn:
+                        ui.warn("warning: " + msg + "\n")
+                else:
+                        raise hg_util.Abort(msg)
+        return
+
+#######################################################################
+# CONTRIBUTORS file parsing
+
+contributorsCache = None
+contributorsURL = None
+
+def ReadContributors(ui, repo):
+        global contributorsCache
+        if contributorsCache is not None:
+                return contributorsCache
+
+        try:
+                if contributorsURL is not None:
+                        opening = contributorsURL
+                        f = urllib2.urlopen(contributorsURL)
+                else:
+                        opening = repo.root + '/CONTRIBUTORS'
+                        f = open(repo.root + '/CONTRIBUTORS', 'r')
+        except:
+                ui.write("warning: cannot open %s: %s\n" % (opening, ExceptionDetail()))
+                return
+
+        contributors = {}
+        for line in f:
+                # CONTRIBUTORS is a list of lines like:
+                #       Person <email>
+                #       Person <email> <alt-email>
+                # The first email address is the one used in commit logs.
+                if line.startswith('#'):
+                        continue
+                m = re.match(r"([^<>]+\S)\s+(<[^<>\s]+>)((\s+<[^<>\s]+>)*)\s*$", line)
+                if m:
+                        name = m.group(1)
+                        email = m.group(2)[1:-1]
+                        contributors[email.lower()] = (name, email)
+                        for extra in m.group(3).split():
+                                contributors[extra[1:-1].lower()] = (name, email)
+
+        contributorsCache = contributors
+        return contributors
+
+def CheckContributor(ui, repo, user=None):
+        set_status("checking CONTRIBUTORS file")
+        user, userline = FindContributor(ui, repo, user, warn=False)
+        if not userline:
+                raise hg_util.Abort("cannot find %s in CONTRIBUTORS" % (user,))
+        return userline
+
+def FindContributor(ui, repo, user=None, warn=True):
+        if not user:
+                user = ui.config("ui", "username")
+                if not user:
+                        raise hg_util.Abort("[ui] username is not configured in .hgrc")
+        user = user.lower()
+        m = re.match(r".*<(.*)>", user)
+        if m:
+                user = m.group(1)
+
+        contributors = ReadContributors(ui, repo)
+        if user not in contributors:
+                if warn:
+                        ui.warn("warning: cannot find %s in CONTRIBUTORS\n" % (user,))
+                return user, None
+        
+        user, email = contributors[user]
+        return email, "%s <%s>" % (user, email)
+
+#######################################################################
+# Mercurial helper functions.
+# Read http://mercurial.selenic.com/wiki/MercurialApi before writing any of these.
+# We use the ui.pushbuffer/ui.popbuffer + hg_commands.xxx tricks for all interaction
+# with Mercurial.  It has proved the most stable as they make changes.
+
+hgversion = hg_util.version()
+
+# We require Mercurial 1.9 and suggest Mercurial 2.0.
+# The details of the scmutil package changed then,
+# so allowing earlier versions would require extra band-aids below.
+# Ubuntu 11.10 ships with Mercurial 1.9.1 as the default version.
+hg_required = "1.9"
+hg_suggested = "2.0"
+
+old_message = """
+
+The code review extension requires Mercurial """+hg_required+""" or newer.
+You are using Mercurial """+hgversion+""".
+
+To install a new Mercurial, use
+
+        sudo easy_install mercurial=="""+hg_suggested+"""
+
+or visit http://mercurial.selenic.com/downloads/.
+"""
+
+linux_message = """
+You may need to clear your current Mercurial installation by running:
+
+        sudo apt-get remove mercurial mercurial-common
+        sudo rm -rf /etc/mercurial
+"""
+
+if hgversion < hg_required:
+        msg = old_message
+        if os.access("/etc/mercurial", 0):
+                msg += linux_message
+        raise hg_util.Abort(msg)
+
+from mercurial.hg import clean as hg_clean
+from mercurial import cmdutil as hg_cmdutil
+from mercurial import error as hg_error
+from mercurial import match as hg_match
+from mercurial import node as hg_node
+
+class uiwrap(object):
+        def __init__(self, ui):
+                self.ui = ui
+                ui.pushbuffer()
+                self.oldQuiet = ui.quiet
+                ui.quiet = True
+                self.oldVerbose = ui.verbose
+                ui.verbose = False
+        def output(self):
+                ui = self.ui
+                ui.quiet = self.oldQuiet
+                ui.verbose = self.oldVerbose
+                return ui.popbuffer()
+
+def to_slash(path):
+        if sys.platform == "win32":
+                return path.replace('\\', '/')
+        return path
+
+def hg_matchPattern(ui, repo, *pats, **opts):
+        w = uiwrap(ui)
+        hg_commands.status(ui, repo, *pats, **opts)
+        text = w.output()
+        ret = []
+        prefix = to_slash(os.path.realpath(repo.root))+'/'
+        for line in text.split('\n'):
+                f = line.split()
+                if len(f) > 1:
+                        if len(pats) > 0:
+                                # Given patterns, Mercurial shows relative to cwd
+                                p = to_slash(os.path.realpath(f[1]))
+                                if not p.startswith(prefix):
+                                        print >>sys.stderr, "File %s not in repo root %s.\n" % (p, prefix)
+                                else:
+                                        ret.append(p[len(prefix):])
+                        else:
+                                # Without patterns, Mercurial shows relative to root (what we want)
+                                ret.append(to_slash(f[1]))
+        return ret
+
+def hg_heads(ui, repo):
+        w = uiwrap(ui)
+        hg_commands.heads(ui, repo)
+        return w.output()
+
+noise = [
+        "",
+        "resolving manifests",
+        "searching for changes",
+        "couldn't find merge tool hgmerge",
+        "adding changesets",
+        "adding manifests",
+        "adding file changes",
+        "all local heads known remotely",
+]
+
+def isNoise(line):
+        line = str(line)
+        for x in noise:
+                if line == x:
+                        return True
+        return False
+
+def hg_incoming(ui, repo):
+        w = uiwrap(ui)
+        ret = hg_commands.incoming(ui, repo, force=False, bundle="")
+        if ret and ret != 1:
+                raise hg_util.Abort(ret)
+        return w.output()
+
+def hg_log(ui, repo, **opts):
+        for k in ['date', 'keyword', 'rev', 'user']:
+                if not opts.has_key(k):
+                        opts[k] = ""
+        w = uiwrap(ui)
+        ret = hg_commands.log(ui, repo, **opts)
+        if ret:
+                raise hg_util.Abort(ret)
+        return w.output()
+
+def hg_outgoing(ui, repo, **opts):
+        w = uiwrap(ui)
+        ret = hg_commands.outgoing(ui, repo, **opts)
+        if ret and ret != 1:
+                raise hg_util.Abort(ret)
+        return w.output()
+
+def hg_pull(ui, repo, **opts):
+        w = uiwrap(ui)
+        ui.quiet = False
+        ui.verbose = True  # for file list
+        err = hg_commands.pull(ui, repo, **opts)
+        for line in w.output().split('\n'):
+                if isNoise(line):
+                        continue
+                if line.startswith('moving '):
+                        line = 'mv ' + line[len('moving '):]
+                if line.startswith('getting ') and line.find(' to ') >= 0:
+                        line = 'mv ' + line[len('getting '):]
+                if line.startswith('getting '):
+                        line = '+ ' + line[len('getting '):]
+                if line.startswith('removing '):
+                        line = '- ' + line[len('removing '):]
+                ui.write(line + '\n')
+        return err
+
+def hg_push(ui, repo, **opts):
+        w = uiwrap(ui)
+        ui.quiet = False
+        ui.verbose = True
+        err = hg_commands.push(ui, repo, **opts)
+        for line in w.output().split('\n'):
+                if not isNoise(line):
+                        ui.write(line + '\n')
+        return err
+
+def hg_commit(ui, repo, *pats, **opts):
+        return hg_commands.commit(ui, repo, *pats, **opts)
+
+#######################################################################
+# Mercurial precommit hook to disable commit except through this interface.
+
+commit_okay = False
+
+def precommithook(ui, repo, **opts):
+        if commit_okay:
+                return False  # False means okay.
+        ui.write("\ncodereview extension enabled; use mail, upload, or submit instead of commit\n\n")
+        return True
+
+#######################################################################
+# @clnumber file pattern support
+
+# We replace scmutil.match with the MatchAt wrapper to add the @clnumber pattern.
+
+match_repo = None
+match_ui = None
+match_orig = None
+
+def InstallMatch(ui, repo):
+        global match_repo
+        global match_ui
+        global match_orig
+
+        match_ui = ui
+        match_repo = repo
+
+        from mercurial import scmutil
+        match_orig = scmutil.match
+        scmutil.match = MatchAt
+
+def MatchAt(ctx, pats=None, opts=None, globbed=False, default='relpath'):
+        taken = []
+        files = []
+        pats = pats or []
+        opts = opts or {}
+        
+        for p in pats:
+                if p.startswith('@'):
+                        taken.append(p)
+                        clname = p[1:]
+                        if clname == "default":
+                                files = DefaultFiles(match_ui, match_repo, [])
+                        else:
+                                if not GoodCLName(clname):
+                                        raise hg_util.Abort("invalid CL name " + clname)
+                                cl, err = LoadCL(match_repo.ui, match_repo, clname, web=False)
+                                if err != '':
+                                        raise hg_util.Abort("loading CL " + clname + ": " + err)
+                                if not cl.files:
+                                        raise hg_util.Abort("no files in CL " + clname)
+                                files = Add(files, cl.files)
+        pats = Sub(pats, taken) + ['path:'+f for f in files]
+
+        # work-around for http://selenic.com/hg/rev/785bbc8634f8
+        if not hasattr(ctx, 'match'):
+                ctx = ctx[None]
+        return match_orig(ctx, pats=pats, opts=opts, globbed=globbed, default=default)
+
+#######################################################################
+# Commands added by code review extension.
+
+# As of Mercurial 2.1 the commands are all required to return integer
+# exit codes, whereas earlier versions allowed returning arbitrary strings
+# to be printed as errors.  We wrap the old functions to make sure we
+# always return integer exit codes now.  Otherwise Mercurial dies
+# with a TypeError traceback (unsupported operand type(s) for &: 'str' and 'int').
+# Introduce a Python decorator to convert old functions to the new
+# stricter convention.
+
+def hgcommand(f):
+        def wrapped(ui, repo, *pats, **opts):
+                err = f(ui, repo, *pats, **opts)
+                if type(err) is int:
+                        return err
+                if not err:
+                        return 0
+                raise hg_util.Abort(err)
+        wrapped.__doc__ = f.__doc__
+        return wrapped
+
+#######################################################################
+# hg change
+
+@hgcommand
+def change(ui, repo, *pats, **opts):
+        """create, edit or delete a change list
+
+        Create, edit or delete a change list.
+        A change list is a group of files to be reviewed and submitted together,
+        plus a textual description of the change.
+        Change lists are referred to by simple alphanumeric names.
+
+        Changes must be reviewed before they can be submitted.
+
+        In the absence of options, the change command opens the
+        change list for editing in the default editor.
+
+        Deleting a change with the -d or -D flag does not affect
+        the contents of the files listed in that change.  To revert
+        the files listed in a change, use
+
+                hg revert @123456
+
+        before running hg change -d 123456.
+        """
+
+        if codereview_disabled:
+                return codereview_disabled
+        
+        dirty = {}
+        if len(pats) > 0 and GoodCLName(pats[0]):
+                name = pats[0]
+                if len(pats) != 1:
+                        return "cannot specify CL name and file patterns"
+                pats = pats[1:]
+                cl, err = LoadCL(ui, repo, name, web=True)
+                if err != '':
+                        return err
+                if not cl.local and (opts["stdin"] or not opts["stdout"]):
+                        return "cannot change non-local CL " + name
+        else:
+                name = "new"
+                cl = CL("new")
+                if repo[None].branch() != "default":
+                        return "cannot create CL outside default branch; switch with 'hg update default'"
+                dirty[cl] = True
+                files = ChangedFiles(ui, repo, pats, taken=Taken(ui, repo))
+
+        if opts["delete"] or opts["deletelocal"]:
+                if opts["delete"] and opts["deletelocal"]:
+                        return "cannot use -d and -D together"
+                flag = "-d"
+                if opts["deletelocal"]:
+                        flag = "-D"
+                if name == "new":
+                        return "cannot use "+flag+" with file patterns"
+                if opts["stdin"] or opts["stdout"]:
+                        return "cannot use "+flag+" with -i or -o"
+                if not cl.local:
+                        return "cannot change non-local CL " + name
+                if opts["delete"]:
+                        if cl.copied_from:
+                                return "original author must delete CL; hg change -D will remove locally"
+                        PostMessage(ui, cl.name, "*** Abandoned ***", send_mail=cl.mailed)
+                        EditDesc(cl.name, closed=True, private=cl.private)
+                cl.Delete(ui, repo)
+                return
+
+        if opts["stdin"]:
+                s = sys.stdin.read()
+                clx, line, err = ParseCL(s, name)
+                if err != '':
+                        return "error parsing change list: line %d: %s" % (line, err)
+                if clx.desc is not None:
+                        cl.desc = clx.desc;
+                        dirty[cl] = True
+                if clx.reviewer is not None:
+                        cl.reviewer = clx.reviewer
+                        dirty[cl] = True
+                if clx.cc is not None:
+                        cl.cc = clx.cc
+                        dirty[cl] = True
+                if clx.files is not None:
+                        cl.files = clx.files
+                        dirty[cl] = True
+                if clx.private != cl.private:
+                        cl.private = clx.private
+                        dirty[cl] = True
+
+        if not opts["stdin"] and not opts["stdout"]:
+                if name == "new":
+                        cl.files = files
+                err = EditCL(ui, repo, cl)
+                if err != "":
+                        return err
+                dirty[cl] = True
+
+        for d, _ in dirty.items():
+                name = d.name
+                d.Flush(ui, repo)
+                if name == "new":
+                        d.Upload(ui, repo, quiet=True)
+
+        if opts["stdout"]:
+                ui.write(cl.EditorText())
+        elif opts["pending"]:
+                ui.write(cl.PendingText())
+        elif name == "new":
+                if ui.quiet:
+                        ui.write(cl.name)
+                else:
+                        ui.write("CL created: " + cl.url + "\n")
+        return
+
+#######################################################################
+# hg code-login (broken?)
+
+@hgcommand
+def code_login(ui, repo, **opts):
+        """log in to code review server
+
+        Logs in to the code review server, saving a cookie in
+        a file in your home directory.
+        """
+        if codereview_disabled:
+                return codereview_disabled
+
+        MySend(None)
+
+#######################################################################
+# hg clpatch / undo / release-apply / download
+# All concerned with applying or unapplying patches to the repository.
+
+@hgcommand
+def clpatch(ui, repo, clname, **opts):
+        """import a patch from the code review server
+
+        Imports a patch from the code review server into the local client.
+        If the local client has already modified any of the files that the
+        patch modifies, this command will refuse to apply the patch.
+
+        Submitting an imported patch will keep the original author's
+        name as the Author: line but add your own name to a Committer: line.
+        """
+        if repo[None].branch() != "default":
+                return "cannot run hg clpatch outside default branch"
+        return clpatch_or_undo(ui, repo, clname, opts, mode="clpatch")
+
+@hgcommand
+def undo(ui, repo, clname, **opts):
+        """undo the effect of a CL
+        
+        Creates a new CL that undoes an earlier CL.
+        After creating the CL, opens the CL text for editing so that
+        you can add the reason for the undo to the description.
+        """
+        if repo[None].branch() != "default":
+                return "cannot run hg undo outside default branch"
+        return clpatch_or_undo(ui, repo, clname, opts, mode="undo")
+
+@hgcommand
+def release_apply(ui, repo, clname, **opts):
+        """apply a CL to the release branch
+
+        Creates a new CL copying a previously committed change
+        from the main branch to the release branch.
+        The current client must either be clean or already be in
+        the release branch.
+        
+        The release branch must be created by starting with a
+        clean client, disabling the code review plugin, and running:
+        
+                hg update weekly.YYYY-MM-DD
+                hg branch release-branch.rNN
+                hg commit -m 'create release-branch.rNN'
+                hg push --new-branch
+        
+        Then re-enable the code review plugin.
+        
+        People can test the release branch by running
+        
+                hg update release-branch.rNN
+        
+        in a clean client.  To return to the normal tree,
+        
+                hg update default
+        
+        Move changes since the weekly into the release branch 
+        using hg release-apply followed by the usual code review
+        process and hg submit.
+
+        When it comes time to tag the release, record the
+        final long-form tag of the release-branch.rNN
+        in the *default* branch's .hgtags file.  That is, run
+        
+                hg update default
+        
+        and then edit .hgtags as you would for a weekly.
+                
+        """
+        c = repo[None]
+        if not releaseBranch:
+                return "no active release branches"
+        if c.branch() != releaseBranch:
+                if c.modified() or c.added() or c.removed():
+                        raise hg_util.Abort("uncommitted local changes - cannot switch branches")
+                err = hg_clean(repo, releaseBranch)
+                if err:
+                        return err
+        try:
+                err = clpatch_or_undo(ui, repo, clname, opts, mode="backport")
+                if err:
+                        raise hg_util.Abort(err)
+        except Exception, e:
+                hg_clean(repo, "default")
+                raise e
+        return None
+
+def rev2clname(rev):
+        # Extract CL name from revision description.
+        # The last line in the description that is a codereview URL is the real one.
+        # Earlier lines might be part of the user-written description.
+        all = re.findall('(?m)^http://codereview.appspot.com/([0-9]+)$', rev.description())
+        if len(all) > 0:
+                return all[-1]
+        return ""
+
+undoHeader = """undo CL %s / %s
+
+<enter reason for undo>
+
+««« original CL description
+"""
+
+undoFooter = """
+»»»
+"""
+
+backportHeader = """[%s] %s
+
+««« CL %s / %s
+"""
+
+backportFooter = """
+»»»
+"""
+
+# Implementation of clpatch/undo.
+def clpatch_or_undo(ui, repo, clname, opts, mode):
+        if codereview_disabled:
+                return codereview_disabled
+
+        if mode == "undo" or mode == "backport":
+                # Find revision in Mercurial repository.
+                # Assume CL number is 7+ decimal digits.
+                # Otherwise is either change log sequence number (fewer decimal digits),
+                # hexadecimal hash, or tag name.
+                # Mercurial will fall over long before the change log
+                # sequence numbers get to be 7 digits long.
+                if re.match('^[0-9]{7,}$', clname):
+                        found = False
+                        for r in hg_log(ui, repo, keyword="codereview.appspot.com/"+clname, limit=100, template="{node}\n").split():
+                                rev = repo[r]
+                                # Last line with a code review URL is the actual review URL.
+                                # Earlier ones might be part of the CL description.
+                                n = rev2clname(rev)
+                                if n == clname:
+                                        found = True
+                                        break
+                        if not found:
+                                return "cannot find CL %s in local repository" % clname
+                else:
+                        rev = repo[clname]
+                        if not rev:
+                                return "unknown revision %s" % clname
+                        clname = rev2clname(rev)
+                        if clname == "":
+                                return "cannot find CL name in revision description"
+                
+                # Create fresh CL and start with patch that would reverse the change.
+                vers = hg_node.short(rev.node())
+                cl = CL("new")
+                desc = str(rev.description())
+                if mode == "undo":
+                        cl.desc = (undoHeader % (clname, vers)) + desc + undoFooter
+                else:
+                        cl.desc = (backportHeader % (releaseBranch, line1(desc), clname, vers)) + desc + undoFooter
+                v1 = vers
+                v0 = hg_node.short(rev.parents()[0].node())
+                if mode == "undo":
+                        arg = v1 + ":" + v0
+                else:
+                        vers = v0
+                        arg = v0 + ":" + v1
+                patch = RunShell(["hg", "diff", "--git", "-r", arg])
+
+        else:  # clpatch
+                cl, vers, patch, err = DownloadCL(ui, repo, clname)
+                if err != "":
+                        return err
+                if patch == emptydiff:
+                        return "codereview issue %s has no diff" % clname
+
+        # find current hg version (hg identify)
+        ctx = repo[None]
+        parents = ctx.parents()
+        id = '+'.join([hg_node.short(p.node()) for p in parents])
+
+        # if version does not match the patch version,
+        # try to update the patch line numbers.
+        if vers != "" and id != vers:
+                # "vers in repo" gives the wrong answer
+                # on some versions of Mercurial.  Instead, do the actual
+                # lookup and catch the exception.
+                try:
+                        repo[vers].description()
+                except:
+                        return "local repository is out of date; sync to get %s" % (vers)
+                patch1, err = portPatch(repo, patch, vers, id)
+                if err != "":
+                        if not opts["ignore_hgpatch_failure"]:
+                                return "codereview issue %s is out of date: %s (%s->%s)" % (clname, err, vers, id)
+                else:
+                        patch = patch1
+        argv = ["hgpatch"]
+        if opts["no_incoming"] or mode == "backport":
+                argv += ["--checksync=false"]
+        try:
+                cmd = subprocess.Popen(argv, shell=False, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=None, close_fds=sys.platform != "win32")
+        except:
+                return "hgpatch: " + ExceptionDetail() + "\nInstall hgpatch with:\n$ go get code.google.com/p/go.codereview/cmd/hgpatch\n"
+
+        out, err = cmd.communicate(patch)
+        if cmd.returncode != 0 and not opts["ignore_hgpatch_failure"]:
+                return "hgpatch failed"
+        cl.local = True
+        cl.files = out.strip().split()
+        if not cl.files and not opts["ignore_hgpatch_failure"]:
+                return "codereview issue %s has no changed files" % clname
+        files = ChangedFiles(ui, repo, [])
+        extra = Sub(cl.files, files)
+        if extra:
+                ui.warn("warning: these files were listed in the patch but not changed:\n\t" + "\n\t".join(extra) + "\n")
+        cl.Flush(ui, repo)
+        if mode == "undo":
+                err = EditCL(ui, repo, cl)
+                if err != "":
+                        return "CL created, but error editing: " + err
+                cl.Flush(ui, repo)
+        else:
+                ui.write(cl.PendingText() + "\n")
+
+# portPatch rewrites patch from being a patch against
+# oldver to being a patch against newver.
+def portPatch(repo, patch, oldver, newver):
+        lines = patch.splitlines(True) # True = keep \n
+        delta = None
+        for i in range(len(lines)):
+                line = lines[i]
+                if line.startswith('--- a/'):
+                        file = line[6:-1]
+                        delta = fileDeltas(repo, file, oldver, newver)
+                if not delta or not line.startswith('@@ '):
+                        continue
+                # @@ -x,y +z,w @@ means the patch chunk replaces
+                # the original file's line numbers x up to x+y with the
+                # line numbers z up to z+w in the new file.
+                # Find the delta from x in the original to the same
+                # line in the current version and add that delta to both
+                # x and z.
+                m = re.match('@@ -([0-9]+),([0-9]+) \+([0-9]+),([0-9]+) @@', line)
+                if not m:
+                        return None, "error parsing patch line numbers"
+                n1, len1, n2, len2 = int(m.group(1)), int(m.group(2)), int(m.group(3)), int(m.group(4))
+                d, err = lineDelta(delta, n1, len1)
+                if err != "":
+                        return "", err
+                n1 += d
+                n2 += d
+                lines[i] = "@@ -%d,%d +%d,%d @@\n" % (n1, len1, n2, len2)
+                
+        newpatch = ''.join(lines)
+        return newpatch, ""
+
+# fileDelta returns the line number deltas for the given file's
+# changes from oldver to newver.
+# The deltas are a list of (n, len, newdelta) triples that say
+# lines [n, n+len) were modified, and after that range the
+# line numbers are +newdelta from what they were before.
+def fileDeltas(repo, file, oldver, newver):
+        cmd = ["hg", "diff", "--git", "-r", oldver + ":" + newver, "path:" + file]
+        data = RunShell(cmd, silent_ok=True)
+        deltas = []
+        for line in data.splitlines():
+                m = re.match('@@ -([0-9]+),([0-9]+) \+([0-9]+),([0-9]+) @@', line)
+                if not m:
+                        continue
+                n1, len1, n2, len2 = int(m.group(1)), int(m.group(2)), int(m.group(3)), int(m.group(4))
+                deltas.append((n1, len1, n2+len2-(n1+len1)))
+        return deltas
+
+# lineDelta finds the appropriate line number delta to apply to the lines [n, n+len).
+# It returns an error if those lines were rewritten by the patch.
+def lineDelta(deltas, n, len):
+        d = 0
+        for (old, oldlen, newdelta) in deltas:
+                if old >= n+len:
+                        break
+                if old+len > n:
+                        return 0, "patch and recent changes conflict"
+                d = newdelta
+        return d, ""
+
+@hgcommand
+def download(ui, repo, clname, **opts):
+        """download a change from the code review server
+
+        Download prints a description of the given change list
+        followed by its diff, downloaded from the code review server.
+        """
+        if codereview_disabled:
+                return codereview_disabled
+
+        cl, vers, patch, err = DownloadCL(ui, repo, clname)
+        if err != "":
+                return err
+        ui.write(cl.EditorText() + "\n")
+        ui.write(patch + "\n")
+        return
+
+#######################################################################
+# hg file
+
+@hgcommand
+def file(ui, repo, clname, pat, *pats, **opts):
+        """assign files to or remove files from a change list
+
+        Assign files to or (with -d) remove files from a change list.
+
+        The -d option only removes files from the change list.
+        It does not edit them or remove them from the repository.
+        """
+        if codereview_disabled:
+                return codereview_disabled
+
+        pats = tuple([pat] + list(pats))
+        if not GoodCLName(clname):
+                return "invalid CL name " + clname
+
+        dirty = {}
+        cl, err = LoadCL(ui, repo, clname, web=False)
+        if err != '':
+                return err
+        if not cl.local:
+                return "cannot change non-local CL " + clname
+
+        files = ChangedFiles(ui, repo, pats)
+
+        if opts["delete"]:
+                oldfiles = Intersect(files, cl.files)
+                if oldfiles:
+                        if not ui.quiet:
+                                ui.status("# Removing files from CL.  To undo:\n")
+                                ui.status("#    cd %s\n" % (repo.root))
+                                for f in oldfiles:
+                                        ui.status("#    hg file %s %s\n" % (cl.name, f))
+                        cl.files = Sub(cl.files, oldfiles)
+                        cl.Flush(ui, repo)
+                else:
+                        ui.status("no such files in CL")
+                return
+
+        if not files:
+                return "no such modified files"
+
+        files = Sub(files, cl.files)
+        taken = Taken(ui, repo)
+        warned = False
+        for f in files:
+                if f in taken:
+                        if not warned and not ui.quiet:
+                                ui.status("# Taking files from other CLs.  To undo:\n")
+                                ui.status("#    cd %s\n" % (repo.root))
+                                warned = True
+                        ocl = taken[f]
+                        if not ui.quiet:
+                                ui.status("#    hg file %s %s\n" % (ocl.name, f))
+                        if ocl not in dirty:
+                                ocl.files = Sub(ocl.files, files)
+                                dirty[ocl] = True
+        cl.files = Add(cl.files, files)
+        dirty[cl] = True
+        for d, _ in dirty.items():
+                d.Flush(ui, repo)
+        return
+
+#######################################################################
+# hg gofmt
+
+@hgcommand
+def gofmt(ui, repo, *pats, **opts):
+        """apply gofmt to modified files
+
+        Applies gofmt to the modified files in the repository that match
+        the given patterns.
+        """
+        if codereview_disabled:
+                return codereview_disabled
+
+        files = ChangedExistingFiles(ui, repo, pats, opts)
+        files = gofmt_required(files)
+        if not files:
+                return "no modified go files"
+        cwd = os.getcwd()
+        files = [RelativePath(repo.root + '/' + f, cwd) for f in files]
+        try:
+                cmd = ["gofmt", "-l"]
+                if not opts["list"]:
+                        cmd += ["-w"]
+                if os.spawnvp(os.P_WAIT, "gofmt", cmd + files) != 0:
+                        raise hg_util.Abort("gofmt did not exit cleanly")
+        except hg_error.Abort, e:
+                raise
+        except:
+                raise hg_util.Abort("gofmt: " + ExceptionDetail())
+        return
+
+def gofmt_required(files):
+        return [f for f in files if (not f.startswith('test/') or f.startswith('test/bench/')) and f.endswith('.go')]
+
+#######################################################################
+# hg mail
+
+@hgcommand
+def mail(ui, repo, *pats, **opts):
+        """mail a change for review
+
+        Uploads a patch to the code review server and then sends mail
+        to the reviewer and CC list asking for a review.
+        """
+        if codereview_disabled:
+                return codereview_disabled
+
+        cl, err = CommandLineCL(ui, repo, pats, opts, defaultcc=defaultcc)
+        if err != "":
+                return err
+        cl.Upload(ui, repo, gofmt_just_warn=True)
+        if not cl.reviewer:
+                # If no reviewer is listed, assign the review to defaultcc.
+                # This makes sure that it appears in the 
+                # codereview.appspot.com/user/defaultcc
+                # page, so that it doesn't get dropped on the floor.
+                if not defaultcc:
+                        return "no reviewers listed in CL"
+                cl.cc = Sub(cl.cc, defaultcc)
+                cl.reviewer = defaultcc
+                cl.Flush(ui, repo)
+
+        if cl.files == []:
+                return "no changed files, not sending mail"
+
+        cl.Mail(ui, repo)               
+
+#######################################################################
+# hg p / hg pq / hg ps / hg pending
+
+@hgcommand
+def ps(ui, repo, *pats, **opts):
+        """alias for hg p --short
+        """
+        opts['short'] = True
+        return pending(ui, repo, *pats, **opts)
+
+@hgcommand
+def pq(ui, repo, *pats, **opts):
+        """alias for hg p --quick
+        """
+        opts['quick'] = True
+        return pending(ui, repo, *pats, **opts)
+
+@hgcommand
+def pending(ui, repo, *pats, **opts):
+        """show pending changes
+
+        Lists pending changes followed by a list of unassigned but modified files.
+        """
+        if codereview_disabled:
+                return codereview_disabled
+
+        quick = opts.get('quick', False)
+        short = opts.get('short', False)
+        m = LoadAllCL(ui, repo, web=not quick and not short)
+        names = m.keys()
+        names.sort()
+        for name in names:
+                cl = m[name]
+                if short:
+                        ui.write(name + "\t" + line1(cl.desc) + "\n")
+                else:
+                        ui.write(cl.PendingText(quick=quick) + "\n")
+
+        if short:
+                return
+        files = DefaultFiles(ui, repo, [])
+        if len(files) > 0:
+                s = "Changed files not in any CL:\n"
+                for f in files:
+                        s += "\t" + f + "\n"
+                ui.write(s)
+
+#######################################################################
+# hg submit
+
+def need_sync():
+        raise hg_util.Abort("local repository out of date; must sync before submit")
+
+@hgcommand
+def submit(ui, repo, *pats, **opts):
+        """submit change to remote repository
+
+        Submits change to remote repository.
+        Bails out if the local repository is not in sync with the remote one.
+        """
+        if codereview_disabled:
+                return codereview_disabled
+
+        # We already called this on startup but sometimes Mercurial forgets.
+        set_mercurial_encoding_to_utf8()
+
+        if not opts["no_incoming"] and hg_incoming(ui, repo):
+                need_sync()
+
+        cl, err = CommandLineCL(ui, repo, pats, opts, defaultcc=defaultcc)
+        if err != "":
+                return err
+
+        user = None
+        if cl.copied_from:
+                user = cl.copied_from
+        userline = CheckContributor(ui, repo, user)
+        typecheck(userline, str)
+
+        about = ""
+        if cl.reviewer:
+                about += "R=" + JoinComma([CutDomain(s) for s in cl.reviewer]) + "\n"
+        if opts.get('tbr'):
+                tbr = SplitCommaSpace(opts.get('tbr'))
+                cl.reviewer = Add(cl.reviewer, tbr)
+                about += "TBR=" + JoinComma([CutDomain(s) for s in tbr]) + "\n"
+        if cl.cc:
+                about += "CC=" + JoinComma([CutDomain(s) for s in cl.cc]) + "\n"
+
+        if not cl.reviewer:
+                return "no reviewers listed in CL"
+
+        if not cl.local:
+                return "cannot submit non-local CL"
+
+        # upload, to sync current patch and also get change number if CL is new.
+        if not cl.copied_from:
+                cl.Upload(ui, repo, gofmt_just_warn=True)
+
+        # check gofmt for real; allowed upload to warn in order to save CL.
+        cl.Flush(ui, repo)
+        CheckFormat(ui, repo, cl.files)
+
+        about += "%s%s\n" % (server_url_base, cl.name)
+
+        if cl.copied_from:
+                about += "\nCommitter: " + CheckContributor(ui, repo, None) + "\n"
+        typecheck(about, str)
+
+        if not cl.mailed and not cl.copied_from:                # in case this is TBR
+                cl.Mail(ui, repo)
+
+        # submit changes locally
+        message = cl.desc.rstrip() + "\n\n" + about
+        typecheck(message, str)
+
+        set_status("pushing " + cl.name + " to remote server")
+
+        if hg_outgoing(ui, repo):
+                raise hg_util.Abort("local repository corrupt or out-of-phase with remote: found outgoing changes")
+        
+        old_heads = len(hg_heads(ui, repo).split())
+
+        global commit_okay
+        commit_okay = True
+        ret = hg_commit(ui, repo, *['path:'+f for f in cl.files], message=message, user=userline)
+        commit_okay = False
+        if ret:
+                return "nothing changed"
+        node = repo["-1"].node()
+        # push to remote; if it fails for any reason, roll back
+        try:
+                new_heads = len(hg_heads(ui, repo).split())
+                if old_heads != new_heads and not (old_heads == 0 and new_heads == 1):
+                        # Created new head, so we weren't up to date.
+                        need_sync()
+
+                # Push changes to remote.  If it works, we're committed.  If not, roll back.
+                try:
+                        hg_push(ui, repo)
+                except hg_error.Abort, e:
+                        if e.message.find("push creates new heads") >= 0:
+                                # Remote repository had changes we missed.
+                                need_sync()
+                        raise
+        except:
+                real_rollback()
+                raise
+
+        # We're committed. Upload final patch, close review, add commit message.
+        changeURL = hg_node.short(node)
+        url = ui.expandpath("default")
+        m = re.match("(^https?://([^@/]+@)?([^.]+)\.googlecode\.com/hg/?)" + "|" +
+                "(^https?://([^@/]+@)?code\.google\.com/p/([^/.]+)(\.[^./]+)?/?)", url)
+        if m:
+                if m.group(1): # prj.googlecode.com/hg/ case
+                        changeURL = "http://code.google.com/p/%s/source/detail?r=%s" % (m.group(3), changeURL)
+                elif m.group(4) and m.group(7): # code.google.com/p/prj.subrepo/ case
+                        changeURL = "http://code.google.com/p/%s/source/detail?r=%s&repo=%s" % (m.group(6), changeURL, m.group(7)[1:])
+                elif m.group(4): # code.google.com/p/prj/ case
+                        changeURL = "http://code.google.com/p/%s/source/detail?r=%s" % (m.group(6), changeURL)
+                else:
+                        print >>sys.stderr, "URL: ", url
+        else:
+                print >>sys.stderr, "URL: ", url
+        pmsg = "*** Submitted as " + changeURL + " ***\n\n" + message
+
+        # When posting, move reviewers to CC line,
+        # so that the issue stops showing up in their "My Issues" page.
+        PostMessage(ui, cl.name, pmsg, reviewers="", cc=JoinComma(cl.reviewer+cl.cc))
+
+        if not cl.copied_from:
+                EditDesc(cl.name, closed=True, private=cl.private)
+        cl.Delete(ui, repo)
+
+        c = repo[None]
+        if c.branch() == releaseBranch and not c.modified() and not c.added() and not c.removed():
+                ui.write("switching from %s to default branch.\n" % releaseBranch)
+                err = hg_clean(repo, "default")
+                if err:
+                        return err
+        return None
+
+#######################################################################
+# hg sync
+
+@hgcommand
+def sync(ui, repo, **opts):
+        """synchronize with remote repository
+
+        Incorporates recent changes from the remote repository
+        into the local repository.
+        """
+        if codereview_disabled:
+                return codereview_disabled
+
+        if not opts["local"]:
+                err = hg_pull(ui, repo, update=True)
+                if err:
+                        return err
+        sync_changes(ui, repo)
+
+def sync_changes(ui, repo):
+        # Look through recent change log descriptions to find
+        # potential references to http://.*/our-CL-number.
+        # Double-check them by looking at the Rietveld log.
+        for rev in hg_log(ui, repo, limit=100, template="{node}\n").split():
+                desc = repo[rev].description().strip()
+                for clname in re.findall('(?m)^http://(?:[^\n]+)/([0-9]+)$', desc):
+                        if IsLocalCL(ui, repo, clname) and IsRietveldSubmitted(ui, clname, repo[rev].hex()):
+                                ui.warn("CL %s submitted as %s; closing\n" % (clname, repo[rev]))
+                                cl, err = LoadCL(ui, repo, clname, web=False)
+                                if err != "":
+                                        ui.warn("loading CL %s: %s\n" % (clname, err))
+                                        continue
+                                if not cl.copied_from:
+                                        EditDesc(cl.name, closed=True, private=cl.private)
+                                cl.Delete(ui, repo)
+
+        # Remove files that are not modified from the CLs in which they appear.
+        all = LoadAllCL(ui, repo, web=False)
+        changed = ChangedFiles(ui, repo, [])
+        for cl in all.values():
+                extra = Sub(cl.files, changed)
+                if extra:
+                        ui.warn("Removing unmodified files from CL %s:\n" % (cl.name,))
+                        for f in extra:
+                                ui.warn("\t%s\n" % (f,))
+                        cl.files = Sub(cl.files, extra)
+                        cl.Flush(ui, repo)
+                if not cl.files:
+                        if not cl.copied_from:
+                                ui.warn("CL %s has no files; delete (abandon) with hg change -d %s\n" % (cl.name, cl.name))
+                        else:
+                                ui.warn("CL %s has no files; delete locally with hg change -D %s\n" % (cl.name, cl.name))
+        return
+
+#######################################################################
+# hg upload
+
+@hgcommand
+def upload(ui, repo, name, **opts):
+        """upload diffs to the code review server
+
+        Uploads the current modifications for a given change to the server.
+        """
+        if codereview_disabled:
+                return codereview_disabled
+
+        repo.ui.quiet = True
+        cl, err = LoadCL(ui, repo, name, web=True)
+        if err != "":
+                return err
+        if not cl.local:
+                return "cannot upload non-local change"
+        cl.Upload(ui, repo)
+        print "%s%s\n" % (server_url_base, cl.name)
+        return
+
+#######################################################################
+# Table of commands, supplied to Mercurial for installation.
+
+review_opts = [
+        ('r', 'reviewer', '', 'add reviewer'),
+        ('', 'cc', '', 'add cc'),
+        ('', 'tbr', '', 'add future reviewer'),
+        ('m', 'message', '', 'change description (for new change)'),
+]
+
+cmdtable = {
+        # The ^ means to show this command in the help text that
+        # is printed when running hg with no arguments.
+        "^change": (
+                change,
+                [
+                        ('d', 'delete', None, 'delete existing change list'),
+                        ('D', 'deletelocal', None, 'delete locally, but do not change CL on server'),
+                        ('i', 'stdin', None, 'read change list from standard input'),
+                        ('o', 'stdout', None, 'print change list to standard output'),
+                        ('p', 'pending', None, 'print pending summary to standard output'),
+                ],
+                "[-d | -D] [-i] [-o] change# or FILE ..."
+        ),
+        "^clpatch": (
+                clpatch,
+                [
+                        ('', 'ignore_hgpatch_failure', None, 'create CL metadata even if hgpatch fails'),
+                        ('', 'no_incoming', None, 'disable check for incoming changes'),
+                ],
+                "change#"
+        ),
+        # Would prefer to call this codereview-login, but then
+        # hg help codereview prints the help for this command
+        # instead of the help for the extension.
+        "code-login": (
+                code_login,
+                [],
+                "",
+        ),
+        "^download": (
+                download,
+                [],
+                "change#"
+        ),
+        "^file": (
+                file,
+                [
+                        ('d', 'delete', None, 'delete files from change list (but not repository)'),
+                ],
+                "[-d] change# FILE ..."
+        ),
+        "^gofmt": (
+                gofmt,
+                [
+                        ('l', 'list', None, 'list files that would change, but do not edit them'),
+                ],
+                "FILE ..."
+        ),
+        "^pending|p": (
+                pending,
+                [
+                        ('s', 'short', False, 'show short result form'),
+                        ('', 'quick', False, 'do not consult codereview server'),
+                ],
+                "[FILE ...]"
+        ),
+        "^ps": (
+                ps,
+                [],
+                "[FILE ...]"
+        ),
+        "^pq": (
+                pq,
+                [],
+                "[FILE ...]"
+        ),
+        "^mail": (
+                mail,
+                review_opts + [
+                ] + hg_commands.walkopts,
+                "[-r reviewer] [--cc cc] [change# | file ...]"
+        ),
+        "^release-apply": (
+                release_apply,
+                [
+                        ('', 'ignore_hgpatch_failure', None, 'create CL metadata even if hgpatch fails'),
+                        ('', 'no_incoming', None, 'disable check for incoming changes'),
+                ],
+                "change#"
+        ),
+        # TODO: release-start, release-tag, weekly-tag
+        "^submit": (
+                submit,
+                review_opts + [
+                        ('', 'no_incoming', None, 'disable initial incoming check (for testing)'),
+                ] + hg_commands.walkopts + hg_commands.commitopts + hg_commands.commitopts2,
+                "[-r reviewer] [--cc cc] [change# | file ...]"
+        ),
+        "^sync": (
+                sync,
+                [
+                        ('', 'local', None, 'do not pull changes from remote repository')
+                ],
+                "[--local]",
+        ),
+        "^undo": (
+                undo,
+                [
+                        ('', 'ignore_hgpatch_failure', None, 'create CL metadata even if hgpatch fails'),
+                        ('', 'no_incoming', None, 'disable check for incoming changes'),
+                ],
+                "change#"
+        ),
+        "^upload": (
+                upload,
+                [],
+                "change#"
+        ),
+}
+
+#######################################################################
+# Mercurial extension initialization
+
+def norollback(*pats, **opts):
+        """(disabled when using this extension)"""
+        raise hg_util.Abort("codereview extension enabled; use undo instead of rollback")
+
+codereview_init = False
+
+def reposetup(ui, repo):
+        global codereview_disabled
+        global defaultcc
+        
+        # reposetup gets called both for the local repository
+        # and also for any repository we are pulling or pushing to.
+        # Only initialize the first time.
+        global codereview_init
+        if codereview_init:
+                return
+        codereview_init = True
+
+        # Read repository-specific options from lib/codereview/codereview.cfg or codereview.cfg.
+        root = ''
+        try:
+                root = repo.root
+        except:
+                # Yes, repo might not have root; see issue 959.
+                codereview_disabled = 'codereview disabled: repository has no root'
+                return
+        
+        repo_config_path = ''
+        p1 = root + '/lib/codereview/codereview.cfg'
+        p2 = root + '/codereview.cfg'
+        if os.access(p1, os.F_OK):
+                repo_config_path = p1
+        else:
+                repo_config_path = p2
+        try:
+                f = open(repo_config_path)
+                for line in f:
+                        if line.startswith('defaultcc:'):
+                                defaultcc = SplitCommaSpace(line[len('defaultcc:'):])
+                        if line.startswith('contributors:'):
+                                global contributorsURL
+                                contributorsURL = line[len('contributors:'):].strip()
+        except:
+                codereview_disabled = 'codereview disabled: cannot open ' + repo_config_path
+                return
+
+        remote = ui.config("paths", "default", "")
+        if remote.find("://") < 0:
+                raise hg_util.Abort("codereview: default path '%s' is not a URL" % (remote,))
+
+        InstallMatch(ui, repo)
+        RietveldSetup(ui, repo)
+
+        # Disable the Mercurial commands that might change the repository.
+        # Only commands in this extension are supposed to do that.
+        ui.setconfig("hooks", "precommit.codereview", precommithook)
+
+        # Rollback removes an existing commit.  Don't do that either.
+        global real_rollback
+        real_rollback = repo.rollback
+        repo.rollback = norollback
+        
+
+#######################################################################
+# Wrappers around upload.py for interacting with Rietveld
+
+from HTMLParser import HTMLParser
+
+# HTML form parser
+class FormParser(HTMLParser):
+        def __init__(self):
+                self.map = {}
+                self.curtag = None
+                self.curdata = None
+                HTMLParser.__init__(self)
+        def handle_starttag(self, tag, attrs):
+                if tag == "input":
+                        key = None
+                        value = ''
+                        for a in attrs:
+                                if a[0] == 'name':
+                                        key = a[1]
+                                if a[0] == 'value':
+                                        value = a[1]
+                        if key is not None:
+                                self.map[key] = value
+                if tag == "textarea":
+                        key = None
+                        for a in attrs:
+                                if a[0] == 'name':
+                                        key = a[1]
+                        if key is not None:
+                                self.curtag = key
+                                self.curdata = ''
+        def handle_endtag(self, tag):
+                if tag == "textarea" and self.curtag is not None:
+                        self.map[self.curtag] = self.curdata
+                        self.curtag = None
+                        self.curdata = None
+        def handle_charref(self, name):
+                self.handle_data(unichr(int(name)))
+        def handle_entityref(self, name):
+                import htmlentitydefs
+                if name in htmlentitydefs.entitydefs:
+                        self.handle_data(htmlentitydefs.entitydefs[name])
+                else:
+                        self.handle_data("&" + name + ";")
+        def handle_data(self, data):
+                if self.curdata is not None:
+                        self.curdata += data
+
+def JSONGet(ui, path):
+        try:
+                data = MySend(path, force_auth=False)
+                typecheck(data, str)
+                d = fix_json(json.loads(data))
+        except:
+                ui.warn("JSONGet %s: %s\n" % (path, ExceptionDetail()))
+                return None
+        return d
+
+# Clean up json parser output to match our expectations:
+#   * all strings are UTF-8-encoded str, not unicode.
+#   * missing fields are missing, not None,
+#     so that d.get("foo", defaultvalue) works.
+def fix_json(x):
+        if type(x) in [str, int, float, bool, type(None)]:
+                pass
+        elif type(x) is unicode:
+                x = x.encode("utf-8")
+        elif type(x) is list:
+                for i in range(len(x)):
+                        x[i] = fix_json(x[i])
+        elif type(x) is dict:
+                todel = []
+                for k in x:
+                        if x[k] is None:
+                                todel.append(k)
+                        else:
+                                x[k] = fix_json(x[k])
+                for k in todel:
+                        del x[k]
+        else:
+                raise hg_util.Abort("unknown type " + str(type(x)) + " in fix_json")
+        if type(x) is str:
+                x = x.replace('\r\n', '\n')
+        return x
+
+def IsRietveldSubmitted(ui, clname, hex):
+        dict = JSONGet(ui, "/api/" + clname + "?messages=true")
+        if dict is None:
+                return False
+        for msg in dict.get("messages", []):
+                text = msg.get("text", "")
+                m = re.match('\*\*\* Submitted as [^*]*?([0-9a-f]+) \*\*\*', text)
+                if m is not None and len(m.group(1)) >= 8 and hex.startswith(m.group(1)):
+                        return True
+        return False
+
+def IsRietveldMailed(cl):
+        for msg in cl.dict.get("messages", []):
+                if msg.get("text", "").find("I'd like you to review this change") >= 0:
+                        return True
+        return False
+
+def DownloadCL(ui, repo, clname):
+        set_status("downloading CL " + clname)
+        cl, err = LoadCL(ui, repo, clname, web=True)
+        if err != "":
+                return None, None, None, "error loading CL %s: %s" % (clname, err)
+
+        # Find most recent diff
+        diffs = cl.dict.get("patchsets", [])
+        if not diffs:
+                return None, None, None, "CL has no patch sets"
+        patchid = diffs[-1]
+
+        patchset = JSONGet(ui, "/api/" + clname + "/" + str(patchid))
+        if patchset is None:
+                return None, None, None, "error loading CL patchset %s/%d" % (clname, patchid)
+        if patchset.get("patchset", 0) != patchid:
+                return None, None, None, "malformed patchset information"
+        
+        vers = ""
+        msg = patchset.get("message", "").split()
+        if len(msg) >= 3 and msg[0] == "diff" and msg[1] == "-r":
+                vers = msg[2]
+        diff = "/download/issue" + clname + "_" + str(patchid) + ".diff"
+
+        diffdata = MySend(diff, force_auth=False)
+        
+        # Print warning if email is not in CONTRIBUTORS file.
+        email = cl.dict.get("owner_email", "")
+        if not email:
+                return None, None, None, "cannot find owner for %s" % (clname)
+        him = FindContributor(ui, repo, email)
+        me = FindContributor(ui, repo, None)
+        if him == me:
+                cl.mailed = IsRietveldMailed(cl)
+        else:
+                cl.copied_from = email
+
+        return cl, vers, diffdata, ""
+
+def MySend(request_path, payload=None,
+                content_type="application/octet-stream",
+                timeout=None, force_auth=True,
+                **kwargs):
+        """Run MySend1 maybe twice, because Rietveld is unreliable."""
+        try:
+                return MySend1(request_path, payload, content_type, timeout, force_auth, **kwargs)
+        except Exception, e:
+                if type(e) != urllib2.HTTPError or e.code != 500:       # only retry on HTTP 500 error
+                        raise
+                print >>sys.stderr, "Loading "+request_path+": "+ExceptionDetail()+"; trying again in 2 seconds."
+                time.sleep(2)
+                return MySend1(request_path, payload, content_type, timeout, force_auth, **kwargs)
+
+# Like upload.py Send but only authenticates when the
+# redirect is to www.google.com/accounts.  This keeps
+# unnecessary redirects from happening during testing.
+def MySend1(request_path, payload=None,
+                                content_type="application/octet-stream",
+                                timeout=None, force_auth=True,
+                                **kwargs):
+        """Sends an RPC and returns the response.
+
+        Args:
+                request_path: The path to send the request to, eg /api/appversion/create.
+                payload: The body of the request, or None to send an empty request.
+                content_type: The Content-Type header to use.
+                timeout: timeout in seconds; default None i.e. no timeout.
+                        (Note: for large requests on OS X, the timeout doesn't work right.)
+                kwargs: Any keyword arguments are converted into query string parameters.
+
+        Returns:
+                The response body, as a string.
+        """
+        # TODO: Don't require authentication.  Let the server say
+        # whether it is necessary.
+        global rpc
+        if rpc == None:
+                rpc = GetRpcServer(upload_options)
+        self = rpc
+        if not self.authenticated and force_auth:
+                self._Authenticate()
+        if request_path is None:
+                return
+
+        old_timeout = socket.getdefaulttimeout()
+        socket.setdefaulttimeout(timeout)
+        try:
+                tries = 0
+                while True:
+                        tries += 1
+                        args = dict(kwargs)
+                        url = "http://%s%s" % (self.host, request_path)
+                        if args:
+                                url += "?" + urllib.urlencode(args)
+                        req = self._CreateRequest(url=url, data=payload)
+                        req.add_header("Content-Type", content_type)
+                        try:
+                                f = self.opener.open(req)
+                                response = f.read()
+                                f.close()
+                                # Translate \r\n into \n, because Rietveld doesn't.
+                                response = response.replace('\r\n', '\n')
+                                # who knows what urllib will give us
+                                if type(response) == unicode:
+                                        response = response.encode("utf-8")
+                                typecheck(response, str)
+                                return response
+                        except urllib2.HTTPError, e:
+                                if tries > 3:
+                                        raise
+                                elif e.code == 401:
+                                        self._Authenticate()
+                                elif e.code == 302:
+                                        loc = e.info()["location"]
+                                        if not loc.startswith('https://www.google.com/a') or loc.find('/ServiceLogin') < 0:
+                                                return ''
+                                        self._Authenticate()
+                                else:
+                                        raise
+        finally:
+                socket.setdefaulttimeout(old_timeout)
+
+def GetForm(url):
+        f = FormParser()
+        f.feed(ustr(MySend(url)))       # f.feed wants unicode
+        f.close()
+        # convert back to utf-8 to restore sanity
+        m = {}
+        for k,v in f.map.items():
+                m[k.encode("utf-8")] = v.replace("\r\n", "\n").encode("utf-8")
+        return m
+
+def EditDesc(issue, subject=None, desc=None, reviewers=None, cc=None, closed=False, private=False):
+        set_status("uploading change to description")
+        form_fields = GetForm("/" + issue + "/edit")
+        if subject is not None:
+                form_fields['subject'] = subject
+        if desc is not None:
+                form_fields['description'] = desc
+        if reviewers is not None:
+                form_fields['reviewers'] = reviewers
+        if cc is not None:
+                form_fields['cc'] = cc
+        if closed:
+                form_fields['closed'] = "checked"
+        if private:
+                form_fields['private'] = "checked"
+        ctype, body = EncodeMultipartFormData(form_fields.items(), [])
+        response = MySend("/" + issue + "/edit", body, content_type=ctype)
+        if response != "":
+                print >>sys.stderr, "Error editing description:\n" + "Sent form: \n", form_fields, "\n", response
+                sys.exit(2)
+
+def PostMessage(ui, issue, message, reviewers=None, cc=None, send_mail=True, subject=None):
+        set_status("uploading message")
+        form_fields = GetForm("/" + issue + "/publish")
+        if reviewers is not None:
+                form_fields['reviewers'] = reviewers
+        if cc is not None:
+                form_fields['cc'] = cc
+        if send_mail:
+                form_fields['send_mail'] = "checked"
+        else:
+                del form_fields['send_mail']
+        if subject is not None:
+                form_fields['subject'] = subject
+        form_fields['message'] = message
+        
+        form_fields['message_only'] = '1'       # Don't include draft comments
+        if reviewers is not None or cc is not None:
+                form_fields['message_only'] = ''        # Must set '' in order to override cc/reviewer
+        ctype = "applications/x-www-form-urlencoded"
+        body = urllib.urlencode(form_fields)
+        response = MySend("/" + issue + "/publish", body, content_type=ctype)
+        if response != "":
+                print response
+                sys.exit(2)
+
+class opt(object):
+        pass
+
+def RietveldSetup(ui, repo):
+        global force_google_account
+        global rpc
+        global server
+        global server_url_base
+        global upload_options
+        global verbosity
+
+        if not ui.verbose:
+                verbosity = 0
+
+        # Config options.
+        x = ui.config("codereview", "server")
+        if x is not None:
+                server = x
+
+        # TODO(rsc): Take from ui.username?
+        email = None
+        x = ui.config("codereview", "email")
+        if x is not None:
+                email = x
+
+        server_url_base = "http://" + server + "/"
+
+        testing = ui.config("codereview", "testing")
+        force_google_account = ui.configbool("codereview", "force_google_account", False)
+
+        upload_options = opt()
+        upload_options.email = email
+        upload_options.host = None
+        upload_options.verbose = 0
+        upload_options.description = None
+        upload_options.description_file = None
+        upload_options.reviewers = None
+        upload_options.cc = None
+        upload_options.message = None
+        upload_options.issue = None
+        upload_options.download_base = False
+        upload_options.revision = None
+        upload_options.send_mail = False
+        upload_options.vcs = None
+        upload_options.server = server
+        upload_options.save_cookies = True
+
+        if testing:
+                upload_options.save_cookies = False
+                upload_options.email = "test@example.com"
+
+        rpc = None
+        
+        global releaseBranch
+        tags = repo.branchtags().keys()
+        if 'release-branch.go10' in tags:
+                # NOTE(rsc): This tags.sort is going to get the wrong
+                # answer when comparing release-branch.go9 with
+                # release-branch.go10.  It will be a while before we care.
+                raise hg_util.Abort('tags.sort needs to be fixed for release-branch.go10')
+        tags.sort()
+        for t in tags:
+                if t.startswith('release-branch.go'):
+                        releaseBranch = t                       
+
+#######################################################################
+# http://codereview.appspot.com/static/upload.py, heavily edited.
+
+#!/usr/bin/env python
+#
+# Copyright 2007 Google Inc.
+#
+# 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.
+
+"""Tool for uploading diffs from a version control system to the codereview app.
+
+Usage summary: upload.py [options] [-- diff_options]
+
+Diff options are passed to the diff command of the underlying system.
+
+Supported version control systems:
+        Git
+        Mercurial
+        Subversion
+
+It is important for Git/Mercurial users to specify a tree/node/branch to diff
+against by using the '--rev' option.
+"""
+# This code is derived from appcfg.py in the App Engine SDK (open source),
+# and from ASPN recipe #146306.
+
+import cookielib
+import getpass
+import logging
+import mimetypes
+import optparse
+import os
+import re
+import socket
+import subprocess
+import sys
+import urllib
+import urllib2
+import urlparse
+
+# The md5 module was deprecated in Python 2.5.
+try:
+        from hashlib import md5
+except ImportError:
+        from md5 import md5
+
+try:
+        import readline
+except ImportError:
+        pass
+
+# The logging verbosity:
+#  0: Errors only.
+#  1: Status messages.
+#  2: Info logs.
+#  3: Debug logs.
+verbosity = 1
+
+# Max size of patch or base file.
+MAX_UPLOAD_SIZE = 900 * 1024
+
+# whitelist for non-binary filetypes which do not start with "text/"
+# .mm (Objective-C) shows up as application/x-freemind on my Linux box.
+TEXT_MIMETYPES = [
+        'application/javascript',
+        'application/x-javascript',
+        'application/x-freemind'
+]
+
+def GetEmail(prompt):
+        """Prompts the user for their email address and returns it.
+
+        The last used email address is saved to a file and offered up as a suggestion
+        to the user. If the user presses enter without typing in anything the last
+        used email address is used. If the user enters a new address, it is saved
+        for next time we prompt.
+
+        """
+        last_email_file_name = os.path.expanduser("~/.last_codereview_email_address")
+        last_email = ""
+        if os.path.exists(last_email_file_name):
+                try:
+                        last_email_file = open(last_email_file_name, "r")
+                        last_email = last_email_file.readline().strip("\n")
+                        last_email_file.close()
+                        prompt += " [%s]" % last_email
+                except IOError, e:
+                        pass
+        email = raw_input(prompt + ": ").strip()
+        if email:
+                try:
+                        last_email_file = open(last_email_file_name, "w")
+                        last_email_file.write(email)
+                        last_email_file.close()
+                except IOError, e:
+                        pass
+        else:
+                email = last_email
+        return email
+
+
+def StatusUpdate(msg):
+        """Print a status message to stdout.
+
+        If 'verbosity' is greater than 0, print the message.
+
+        Args:
+                msg: The string to print.
+        """
+        if verbosity > 0:
+                print msg
+
+
+def ErrorExit(msg):
+        """Print an error message to stderr and exit."""
+        print >>sys.stderr, msg
+        sys.exit(1)
+
+
+class ClientLoginError(urllib2.HTTPError):
+        """Raised to indicate there was an error authenticating with ClientLogin."""
+
+        def __init__(self, url, code, msg, headers, args):
+                urllib2.HTTPError.__init__(self, url, code, msg, headers, None)
+                self.args = args
+                self.reason = args["Error"]
+
+
+class AbstractRpcServer(object):
+        """Provides a common interface for a simple RPC server."""
+
+        def __init__(self, host, auth_function, host_override=None, extra_headers={}, save_cookies=False):
+                """Creates a new HttpRpcServer.
+
+                Args:
+                        host: The host to send requests to.
+                        auth_function: A function that takes no arguments and returns an
+                                (email, password) tuple when called. Will be called if authentication
+                                is required.
+                        host_override: The host header to send to the server (defaults to host).
+                        extra_headers: A dict of extra headers to append to every request.
+                        save_cookies: If True, save the authentication cookies to local disk.
+                                If False, use an in-memory cookiejar instead.  Subclasses must
+                                implement this functionality.  Defaults to False.
+                """
+                self.host = host
+                self.host_override = host_override
+                self.auth_function = auth_function
+                self.authenticated = False
+                self.extra_headers = extra_headers
+                self.save_cookies = save_cookies
+                self.opener = self._GetOpener()
+                if self.host_override:
+                        logging.info("Server: %s; Host: %s", self.host, self.host_override)
+                else:
+                        logging.info("Server: %s", self.host)
+
+        def _GetOpener(self):
+                """Returns an OpenerDirector for making HTTP requests.
+
+                Returns:
+                        A urllib2.OpenerDirector object.
+                """
+                raise NotImplementedError()
+
+        def _CreateRequest(self, url, data=None):
+                """Creates a new urllib request."""
+                logging.debug("Creating request for: '%s' with payload:\n%s", url, data)
+                req = urllib2.Request(url, data=data)
+                if self.host_override:
+                        req.add_header("Host", self.host_override)
+                for key, value in self.extra_headers.iteritems():
+                        req.add_header(key, value)
+                return req
+
+        def _GetAuthToken(self, email, password):
+                """Uses ClientLogin to authenticate the user, returning an auth token.
+
+                Args:
+                        email:    The user's email address
+                        password: The user's password
+
+                Raises:
+                        ClientLoginError: If there was an error authenticating with ClientLogin.
+                        HTTPError: If there was some other form of HTTP error.
+
+                Returns:
+                        The authentication token returned by ClientLogin.
+                """
+                account_type = "GOOGLE"
+                if self.host.endswith(".google.com") and not force_google_account:
+                        # Needed for use inside Google.
+                        account_type = "HOSTED"
+                req = self._CreateRequest(
+                                url="https://www.google.com/accounts/ClientLogin",
+                                data=urllib.urlencode({
+                                                "Email": email,
+                                                "Passwd": password,
+                                                "service": "ah",
+                                                "source": "rietveld-codereview-upload",
+                                                "accountType": account_type,
+                                }),
+                )
+                try:
+                        response = self.opener.open(req)
+                        response_body = response.read()
+                        response_dict = dict(x.split("=") for x in response_body.split("\n") if x)
+                        return response_dict["Auth"]
+                except urllib2.HTTPError, e:
+                        if e.code == 403:
+                                body = e.read()
+                                response_dict = dict(x.split("=", 1) for x in body.split("\n") if x)
+                                raise ClientLoginError(req.get_full_url(), e.code, e.msg, e.headers, response_dict)
+                        else:
+                                raise
+
+        def _GetAuthCookie(self, auth_token):
+                """Fetches authentication cookies for an authentication token.
+
+                Args:
+                        auth_token: The authentication token returned by ClientLogin.
+
+                Raises:
+                        HTTPError: If there was an error fetching the authentication cookies.
+                """
+                # This is a dummy value to allow us to identify when we're successful.
+                continue_location = "http://localhost/"
+                args = {"continue": continue_location, "auth": auth_token}
+                req = self._CreateRequest("http://%s/_ah/login?%s" % (self.host, urllib.urlencode(args)))
+                try:
+                        response = self.opener.open(req)
+                except urllib2.HTTPError, e:
+                        response = e
+                if (response.code != 302 or
+                                response.info()["location"] != continue_location):
+                        raise urllib2.HTTPError(req.get_full_url(), response.code, response.msg, response.headers, response.fp)
+                self.authenticated = True
+
+        def _Authenticate(self):
+                """Authenticates the user.
+
+                The authentication process works as follows:
+                1) We get a username and password from the user
+                2) We use ClientLogin to obtain an AUTH token for the user
+                                (see http://code.google.com/apis/accounts/AuthForInstalledApps.html).
+                3) We pass the auth token to /_ah/login on the server to obtain an
+                                authentication cookie. If login was successful, it tries to redirect
+                                us to the URL we provided.
+
+                If we attempt to access the upload API without first obtaining an
+                authentication cookie, it returns a 401 response (or a 302) and
+                directs us to authenticate ourselves with ClientLogin.
+                """
+                for i in range(3):
+                        credentials = self.auth_function()
+                        try:
+                                auth_token = self._GetAuthToken(credentials[0], credentials[1])
+                        except ClientLoginError, e:
+                                if e.reason == "BadAuthentication":
+                                        print >>sys.stderr, "Invalid username or password."
+                                        continue
+                                if e.reason == "CaptchaRequired":
+                                        print >>sys.stderr, (
+                                                "Please go to\n"
+                                                "https://www.google.com/accounts/DisplayUnlockCaptcha\n"
+                                                "and verify you are a human.  Then try again.")
+                                        break
+                                if e.reason == "NotVerified":
+                                        print >>sys.stderr, "Account not verified."
+                                        break
+                                if e.reason == "TermsNotAgreed":
+                                        print >>sys.stderr, "User has not agreed to TOS."
+                                        break
+                                if e.reason == "AccountDeleted":
+                                        print >>sys.stderr, "The user account has been deleted."
+                                        break
+                                if e.reason == "AccountDisabled":
+                                        print >>sys.stderr, "The user account has been disabled."
+                                        break
+                                if e.reason == "ServiceDisabled":
+                                        print >>sys.stderr, "The user's access to the service has been disabled."
+                                        break
+                                if e.reason == "ServiceUnavailable":
+                                        print >>sys.stderr, "The service is not available; try again later."
+                                        break
+                                raise
+                        self._GetAuthCookie(auth_token)
+                        return
+
+        def Send(self, request_path, payload=None,
+                                        content_type="application/octet-stream",
+                                        timeout=None,
+                                        **kwargs):
+                """Sends an RPC and returns the response.
+
+                Args:
+                        request_path: The path to send the request to, eg /api/appversion/create.
+                        payload: The body of the request, or None to send an empty request.
+                        content_type: The Content-Type header to use.
+                        timeout: timeout in seconds; default None i.e. no timeout.
+                                (Note: for large requests on OS X, the timeout doesn't work right.)
+                        kwargs: Any keyword arguments are converted into query string parameters.
+
+                Returns:
+                        The response body, as a string.
+                """
+                # TODO: Don't require authentication.  Let the server say
+                # whether it is necessary.
+                if not self.authenticated:
+                        self._Authenticate()
+
+                old_timeout = socket.getdefaulttimeout()
+                socket.setdefaulttimeout(timeout)
+                try:
+                        tries = 0
+                        while True:
+                                tries += 1
+                                args = dict(kwargs)
+                                url = "http://%s%s" % (self.host, request_path)
+                                if args:
+                                        url += "?" + urllib.urlencode(args)
+                                req = self._CreateRequest(url=url, data=payload)
+                                req.add_header("Content-Type", content_type)
+                                try:
+                                        f = self.opener.open(req)
+                                        response = f.read()
+                                        f.close()
+                                        return response
+                                except urllib2.HTTPError, e:
+                                        if tries > 3:
+                                                raise
+                                        elif e.code == 401 or e.code == 302:
+                                                self._Authenticate()
+                                        else:
+                                                raise
+                finally:
+                        socket.setdefaulttimeout(old_timeout)
+
+
+class HttpRpcServer(AbstractRpcServer):
+        """Provides a simplified RPC-style interface for HTTP requests."""
+
+        def _Authenticate(self):
+                """Save the cookie jar after authentication."""
+                super(HttpRpcServer, self)._Authenticate()
+                if self.save_cookies:
+                        StatusUpdate("Saving authentication cookies to %s" % self.cookie_file)
+                        self.cookie_jar.save()
+
+        def _GetOpener(self):
+                """Returns an OpenerDirector that supports cookies and ignores redirects.
+
+                Returns:
+                        A urllib2.OpenerDirector object.
+                """
+                opener = urllib2.OpenerDirector()
+                opener.add_handler(urllib2.ProxyHandler())
+                opener.add_handler(urllib2.UnknownHandler())
+                opener.add_handler(urllib2.HTTPHandler())
+                opener.add_handler(urllib2.HTTPDefaultErrorHandler())
+                opener.add_handler(urllib2.HTTPSHandler())
+                opener.add_handler(urllib2.HTTPErrorProcessor())
+                if self.save_cookies:
+                        self.cookie_file = os.path.expanduser("~/.codereview_upload_cookies_" + server)
+                        self.cookie_jar = cookielib.MozillaCookieJar(self.cookie_file)
+                        if os.path.exists(self.cookie_file):
+                                try:
+                                        self.cookie_jar.load()
+                                        self.authenticated = True
+                                        StatusUpdate("Loaded authentication cookies from %s" % self.cookie_file)
+                                except (cookielib.LoadError, IOError):
+                                        # Failed to load cookies - just ignore them.
+                                        pass
+                        else:
+                                # Create an empty cookie file with mode 600
+                                fd = os.open(self.cookie_file, os.O_CREAT, 0600)
+                                os.close(fd)
+                        # Always chmod the cookie file
+                        os.chmod(self.cookie_file, 0600)
+                else:
+                        # Don't save cookies across runs of update.py.
+                        self.cookie_jar = cookielib.CookieJar()
+                opener.add_handler(urllib2.HTTPCookieProcessor(self.cookie_jar))
+                return opener
+
+
+def GetRpcServer(options):
+        """Returns an instance of an AbstractRpcServer.
+
+        Returns:
+                A new AbstractRpcServer, on which RPC calls can be made.
+        """
+
+        rpc_server_class = HttpRpcServer
+
+        def GetUserCredentials():
+                """Prompts the user for a username and password."""
+                # Disable status prints so they don't obscure the password prompt.
+                global global_status
+                st = global_status
+                global_status = None
+
+                email = options.email
+                if email is None:
+                        email = GetEmail("Email (login for uploading to %s)" % options.server)
+                password = getpass.getpass("Password for %s: " % email)
+
+                # Put status back.
+                global_status = st
+                return (email, password)
+
+        # If this is the dev_appserver, use fake authentication.
+        host = (options.host or options.server).lower()
+        if host == "localhost" or host.startswith("localhost:"):
+                email = options.email
+                if email is None:
+                        email = "test@example.com"
+                        logging.info("Using debug user %s.  Override with --email" % email)
+                server = rpc_server_class(
+                                options.server,
+                                lambda: (email, "password"),
+                                host_override=options.host,
+                                extra_headers={"Cookie": 'dev_appserver_login="%s:False"' % email},
+                                save_cookies=options.save_cookies)
+                # Don't try to talk to ClientLogin.
+                server.authenticated = True
+                return server
+
+        return rpc_server_class(options.server, GetUserCredentials,
+                host_override=options.host, save_cookies=options.save_cookies)
+
+
+def EncodeMultipartFormData(fields, files):
+        """Encode form fields for multipart/form-data.
+
+        Args:
+                fields: A sequence of (name, value) elements for regular form fields.
+                files: A sequence of (name, filename, value) elements for data to be
+                                        uploaded as files.
+        Returns:
+                (content_type, body) ready for httplib.HTTP instance.
+
+        Source:
+                http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/146306
+        """
+        BOUNDARY = '-M-A-G-I-C---B-O-U-N-D-A-R-Y-'
+        CRLF = '\r\n'
+        lines = []
+        for (key, value) in fields:
+                typecheck(key, str)
+                typecheck(value, str)
+                lines.append('--' + BOUNDARY)
+                lines.append('Content-Disposition: form-data; name="%s"' % key)
+                lines.append('')
+                lines.append(value)
+        for (key, filename, value) in files:
+                typecheck(key, str)
+                typecheck(filename, str)
+                typecheck(value, str)
+                lines.append('--' + BOUNDARY)
+                lines.append('Content-Disposition: form-data; name="%s"; filename="%s"' % (key, filename))
+                lines.append('Content-Type: %s' % GetContentType(filename))
+                lines.append('')
+                lines.append(value)
+        lines.append('--' + BOUNDARY + '--')
+        lines.append('')
+        body = CRLF.join(lines)
+        content_type = 'multipart/form-data; boundary=%s' % BOUNDARY
+        return content_type, body
+
+
+def GetContentType(filename):
+        """Helper to guess the content-type from the filename."""
+        return mimetypes.guess_type(filename)[0] or 'application/octet-stream'
+
+
+# Use a shell for subcommands on Windows to get a PATH search.
+use_shell = sys.platform.startswith("win")
+
+def RunShellWithReturnCode(command, print_output=False,
+                universal_newlines=True, env=os.environ):
+        """Executes a command and returns the output from stdout and the return code.
+
+        Args:
+                command: Command to execute.
+                print_output: If True, the output is printed to stdout.
+                        If False, both stdout and stderr are ignored.
+                universal_newlines: Use universal_newlines flag (default: True).
+
+        Returns:
+                Tuple (output, return code)
+        """
+        logging.info("Running %s", command)
+        p = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
+                shell=use_shell, universal_newlines=universal_newlines, env=env)
+        if print_output:
+                output_array = []
+                while True:
+                        line = p.stdout.readline()
+                        if not line:
+                                break
+                        print line.strip("\n")
+                        output_array.append(line)
+                output = "".join(output_array)
+        else:
+                output = p.stdout.read()
+        p.wait()
+        errout = p.stderr.read()
+        if print_output and errout:
+                print >>sys.stderr, errout
+        p.stdout.close()
+        p.stderr.close()
+        return output, p.returncode
+
+
+def RunShell(command, silent_ok=False, universal_newlines=True,
+                print_output=False, env=os.environ):
+        data, retcode = RunShellWithReturnCode(command, print_output, universal_newlines, env)
+        if retcode:
+                ErrorExit("Got error status from %s:\n%s" % (command, data))
+        if not silent_ok and not data:
+                ErrorExit("No output from %s" % command)
+        return data
+
+
+class VersionControlSystem(object):
+        """Abstract base class providing an interface to the VCS."""
+
+        def __init__(self, options):
+                """Constructor.
+
+                Args:
+                        options: Command line options.
+                """
+                self.options = options
+
+        def GenerateDiff(self, args):
+                """Return the current diff as a string.
+
+                Args:
+                        args: Extra arguments to pass to the diff command.
+                """
+                raise NotImplementedError(
+                                "abstract method -- subclass %s must override" % self.__class__)
+
+        def GetUnknownFiles(self):
+                """Return a list of files unknown to the VCS."""
+                raise NotImplementedError(
+                                "abstract method -- subclass %s must override" % self.__class__)
+
+        def CheckForUnknownFiles(self):
+                """Show an "are you sure?" prompt if there are unknown files."""
+                unknown_files = self.GetUnknownFiles()
+                if unknown_files:
+                        print "The following files are not added to version control:"
+                        for line in unknown_files:
+                                print line
+                        prompt = "Are you sure to continue?(y/N) "
+                        answer = raw_input(prompt).strip()
+                        if answer != "y":
+                                ErrorExit("User aborted")
+
+        def GetBaseFile(self, filename):
+                """Get the content of the upstream version of a file.
+
+                Returns:
+                        A tuple (base_content, new_content, is_binary, status)
+                                base_content: The contents of the base file.
+                                new_content: For text files, this is empty.  For binary files, this is
+                                        the contents of the new file, since the diff output won't contain
+                                        information to reconstruct the current file.
+                                is_binary: True iff the file is binary.
+                                status: The status of the file.
+                """
+
+                raise NotImplementedError(
+                                "abstract method -- subclass %s must override" % self.__class__)
+
+
+        def GetBaseFiles(self, diff):
+                """Helper that calls GetBase file for each file in the patch.
+
+                Returns:
+                        A dictionary that maps from filename to GetBaseFile's tuple.  Filenames
+                        are retrieved based on lines that start with "Index:" or
+                        "Property changes on:".
+                """
+                files = {}
+                for line in diff.splitlines(True):
+                        if line.startswith('Index:') or line.startswith('Property changes on:'):
+                                unused, filename = line.split(':', 1)
+                                # On Windows if a file has property changes its filename uses '\'
+                                # instead of '/'.
+                                filename = to_slash(filename.strip())
+                                files[filename] = self.GetBaseFile(filename)
+                return files
+
+
+        def UploadBaseFiles(self, issue, rpc_server, patch_list, patchset, options,
+                                                                                        files):
+                """Uploads the base files (and if necessary, the current ones as well)."""
+
+                def UploadFile(filename, file_id, content, is_binary, status, is_base):
+                        """Uploads a file to the server."""
+                        set_status("uploading " + filename)
+                        file_too_large = False
+                        if is_base:
+                                type = "base"
+                        else:
+                                type = "current"
+                        if len(content) > MAX_UPLOAD_SIZE:
+                                print ("Not uploading the %s file for %s because it's too large." %
+                                                        (type, filename))
+                                file_too_large = True
+                                content = ""
+                        checksum = md5(content).hexdigest()
+                        if options.verbose > 0 and not file_too_large:
+                                print "Uploading %s file for %s" % (type, filename)
+                        url = "/%d/upload_content/%d/%d" % (int(issue), int(patchset), file_id)
+                        form_fields = [
+                                ("filename", filename),
+                                ("status", status),
+                                ("checksum", checksum),
+                                ("is_binary", str(is_binary)),
+                                ("is_current", str(not is_base)),
+                        ]
+                        if file_too_large:
+                                form_fields.append(("file_too_large", "1"))
+                        if options.email:
+                                form_fields.append(("user", options.email))
+                        ctype, body = EncodeMultipartFormData(form_fields, [("data", filename, content)])
+                        response_body = rpc_server.Send(url, body, content_type=ctype)
+                        if not response_body.startswith("OK"):
+                                StatusUpdate("  --> %s" % response_body)
+                                sys.exit(1)
+
+                # Don't want to spawn too many threads, nor do we want to
+                # hit Rietveld too hard, or it will start serving 500 errors.
+                # When 8 works, it's no better than 4, and sometimes 8 is
+                # too many for Rietveld to handle.
+                MAX_PARALLEL_UPLOADS = 4
+
+                sema = threading.BoundedSemaphore(MAX_PARALLEL_UPLOADS)
+                upload_threads = []
+                finished_upload_threads = []
+                
+                class UploadFileThread(threading.Thread):
+                        def __init__(self, args):
+                                threading.Thread.__init__(self)
+                                self.args = args
+                        def run(self):
+                                UploadFile(*self.args)
+                                finished_upload_threads.append(self)
+                                sema.release()
+
+                def StartUploadFile(*args):
+                        sema.acquire()
+                        while len(finished_upload_threads) > 0:
+                                t = finished_upload_threads.pop()
+                                upload_threads.remove(t)
+                                t.join()
+                        t = UploadFileThread(args)
+                        upload_threads.append(t)
+                        t.start()
+
+                def WaitForUploads():                   
+                        for t in upload_threads:
+                                t.join()
+
+                patches = dict()
+                [patches.setdefault(v, k) for k, v in patch_list]
+                for filename in patches.keys():
+                        base_content, new_content, is_binary, status = files[filename]
+                        file_id_str = patches.get(filename)
+                        if file_id_str.find("nobase") != -1:
+                                base_content = None
+                                file_id_str = file_id_str[file_id_str.rfind("_") + 1:]
+                        file_id = int(file_id_str)
+                        if base_content != None:
+                                StartUploadFile(filename, file_id, base_content, is_binary, status, True)
+                        if new_content != None:
+                                StartUploadFile(filename, file_id, new_content, is_binary, status, False)
+                WaitForUploads()
+
+        def IsImage(self, filename):
+                """Returns true if the filename has an image extension."""
+                mimetype =  mimetypes.guess_type(filename)[0]
+                if not mimetype:
+                        return False
+                return mimetype.startswith("image/")
+
+        def IsBinary(self, filename):
+                """Returns true if the guessed mimetyped isnt't in text group."""
+                mimetype = mimetypes.guess_type(filename)[0]
+                if not mimetype:
+                        return False  # e.g. README, "real" binaries usually have an extension
+                # special case for text files which don't start with text/
+                if mimetype in TEXT_MIMETYPES:
+                        return False
+                return not mimetype.startswith("text/")
+
+
+class FakeMercurialUI(object):
+        def __init__(self):
+                self.quiet = True
+                self.output = ''
+        
+        def write(self, *args, **opts):
+                self.output += ' '.join(args)
+        def copy(self):
+                return self
+        def status(self, *args, **opts):
+                pass
+
+        def formatter(self, topic, opts):
+                from mercurial.formatter import plainformatter
+                return plainformatter(self, topic, opts)
+        
+        def readconfig(self, *args, **opts):
+                pass
+        def expandpath(self, *args, **opts):
+                return global_ui.expandpath(*args, **opts)
+        def configitems(self, *args, **opts):
+                return global_ui.configitems(*args, **opts)
+        def config(self, *args, **opts):
+                return global_ui.config(*args, **opts)
+
+use_hg_shell = False    # set to True to shell out to hg always; slower
+
+class MercurialVCS(VersionControlSystem):
+        """Implementation of the VersionControlSystem interface for Mercurial."""
+
+        def __init__(self, options, ui, repo):
+                super(MercurialVCS, self).__init__(options)
+                self.ui = ui
+                self.repo = repo
+                self.status = None
+                # Absolute path to repository (we can be in a subdir)
+                self.repo_dir = os.path.normpath(repo.root)
+                # Compute the subdir
+                cwd = os.path.normpath(os.getcwd())
+                assert cwd.startswith(self.repo_dir)
+                self.subdir = cwd[len(self.repo_dir):].lstrip(r"\/")
+                if self.options.revision:
+                        self.base_rev = self.options.revision
+                else:
+                        mqparent, err = RunShellWithReturnCode(['hg', 'log', '--rev', 'qparent', '--template={node}'])
+                        if not err and mqparent != "":
+                                self.base_rev = mqparent
+                        else:
+                                out = RunShell(["hg", "parents", "-q"], silent_ok=True).strip()
+                                if not out:
+                                        # No revisions; use 0 to mean a repository with nothing.
+                                        out = "0:0"
+                                self.base_rev = out.split(':')[1].strip()
+        def _GetRelPath(self, filename):
+                """Get relative path of a file according to the current directory,
+                given its logical path in the repo."""
+                assert filename.startswith(self.subdir), (filename, self.subdir)
+                return filename[len(self.subdir):].lstrip(r"\/")
+
+        def GenerateDiff(self, extra_args):
+                # If no file specified, restrict to the current subdir
+                extra_args = extra_args or ["."]
+                cmd = ["hg", "diff", "--git", "-r", self.base_rev] + extra_args
+                data = RunShell(cmd, silent_ok=True)
+                svndiff = []
+                filecount = 0
+                for line in data.splitlines():
+                        m = re.match("diff --git a/(\S+) b/(\S+)", line)
+                        if m:
+                                # Modify line to make it look like as it comes from svn diff.
+                                # With this modification no changes on the server side are required
+                                # to make upload.py work with Mercurial repos.
+                                # NOTE: for proper handling of moved/copied files, we have to use
+                                # the second filename.
+                                filename = m.group(2)
+                                svndiff.append("Index: %s" % filename)
+                                svndiff.append("=" * 67)
+                                filecount += 1
+                                logging.info(line)
+                        else:
+                                svndiff.append(line)
+                if not filecount:
+                        ErrorExit("No valid patches found in output from hg diff")
+                return "\n".join(svndiff) + "\n"
+
+        def GetUnknownFiles(self):
+                """Return a list of files unknown to the VCS."""
+                args = []
+                status = RunShell(["hg", "status", "--rev", self.base_rev, "-u", "."],
+                                silent_ok=True)
+                unknown_files = []
+                for line in status.splitlines():
+                        st, fn = line.split(" ", 1)
+                        if st == "?":
+                                unknown_files.append(fn)
+                return unknown_files
+
+        def get_hg_status(self, rev, path):
+                # We'd like to use 'hg status -C path', but that is buggy
+                # (see http://mercurial.selenic.com/bts/issue3023).
+                # Instead, run 'hg status -C' without a path
+                # and skim the output for the path we want.
+                if self.status is None:
+                        if use_hg_shell:
+                                out = RunShell(["hg", "status", "-C", "--rev", rev])
+                        else:
+                                fui = FakeMercurialUI()
+                                ret = hg_commands.status(fui, self.repo, *[], **{'rev': [rev], 'copies': True})
+                                if ret:
+                                        raise hg_util.Abort(ret)
+                                out = fui.output
+                        self.status = out.splitlines()
+                for i in range(len(self.status)):
+                        # line is
+                        #       A path
+                        #       M path
+                        # etc
+                        line = to_slash(self.status[i])
+                        if line[2:] == path:
+                                if i+1 < len(self.status) and self.status[i+1][:2] == '  ':
+                                        return self.status[i:i+2]
+                                return self.status[i:i+1]
+                raise hg_util.Abort("no status for " + path)
+        
+        def GetBaseFile(self, filename):
+                set_status("inspecting " + filename)
+                # "hg status" and "hg cat" both take a path relative to the current subdir
+                # rather than to the repo root, but "hg diff" has given us the full path
+                # to the repo root.
+                base_content = ""
+                new_content = None
+                is_binary = False
+                oldrelpath = relpath = self._GetRelPath(filename)
+                out = self.get_hg_status(self.base_rev, relpath)
+                status, what = out[0].split(' ', 1)
+                if len(out) > 1 and status == "A" and what == relpath:
+                        oldrelpath = out[1].strip()
+                        status = "M"
+                if ":" in self.base_rev:
+                        base_rev = self.base_rev.split(":", 1)[0]
+                else:
+                        base_rev = self.base_rev
+                if status != "A":
+                        if use_hg_shell:
+                                base_content = RunShell(["hg", "cat", "-r", base_rev, oldrelpath], silent_ok=True)
+                        else:
+                                base_content = str(self.repo[base_rev][oldrelpath].data())
+                        is_binary = "\0" in base_content  # Mercurial's heuristic
+                if status != "R":
+                        new_content = open(relpath, "rb").read()
+                        is_binary = is_binary or "\0" in new_content
+                if is_binary and base_content and use_hg_shell:
+                        # Fetch again without converting newlines
+                        base_content = RunShell(["hg", "cat", "-r", base_rev, oldrelpath],
+                                silent_ok=True, universal_newlines=False)
+                if not is_binary or not self.IsImage(relpath):
+                        new_content = None
+                return base_content, new_content, is_binary, status
+
+
+# NOTE: The SplitPatch function is duplicated in engine.py, keep them in sync.
+def SplitPatch(data):
+        """Splits a patch into separate pieces for each file.
+
+        Args:
+                data: A string containing the output of svn diff.
+
+        Returns:
+                A list of 2-tuple (filename, text) where text is the svn diff output
+                        pertaining to filename.
+        """
+        patches = []
+        filename = None
+        diff = []
+        for line in data.splitlines(True):
+                new_filename = None
+                if line.startswith('Index:'):
+                        unused, new_filename = line.split(':', 1)
+                        new_filename = new_filename.strip()
+                elif line.startswith('Property changes on:'):
+                        unused, temp_filename = line.split(':', 1)
+                        # When a file is modified, paths use '/' between directories, however
+                        # when a property is modified '\' is used on Windows.  Make them the same
+                        # otherwise the file shows up twice.
+                        temp_filename = to_slash(temp_filename.strip())
+                        if temp_filename != filename:
+                                # File has property changes but no modifications, create a new diff.
+                                new_filename = temp_filename
+                if new_filename:
+                        if filename and diff:
+                                patches.append((filename, ''.join(diff)))
+                        filename = new_filename
+                        diff = [line]
+                        continue
+                if diff is not None:
+                        diff.append(line)
+        if filename and diff:
+                patches.append((filename, ''.join(diff)))
+        return patches
+
+
+def UploadSeparatePatches(issue, rpc_server, patchset, data, options):
+        """Uploads a separate patch for each file in the diff output.
+
+        Returns a list of [patch_key, filename] for each file.
+        """
+        patches = SplitPatch(data)
+        rv = []
+        for patch in patches:
+                set_status("uploading patch for " + patch[0])
+                if len(patch[1]) > MAX_UPLOAD_SIZE:
+                        print ("Not uploading the patch for " + patch[0] +
+                                " because the file is too large.")
+                        continue
+                form_fields = [("filename", patch[0])]
+                if not options.download_base:
+                        form_fields.append(("content_upload", "1"))
+                files = [("data", "data.diff", patch[1])]
+                ctype, body = EncodeMultipartFormData(form_fields, files)
+                url = "/%d/upload_patch/%d" % (int(issue), int(patchset))
+                print "Uploading patch for " + patch[0]
+                response_body = rpc_server.Send(url, body, content_type=ctype)
+                lines = response_body.splitlines()
+                if not lines or lines[0] != "OK":
+                        StatusUpdate("  --> %s" % response_body)
+                        sys.exit(1)
+                rv.append([lines[1], patch[0]])
+        return rv