Initial checkin of codereview plugin.

The master copy is going to live elsewhere,
but weAPOSTROPHEll keep a copy in the Go tree so that
developers donAPOSTROPHEt have to check out two
different repositories.

R=r
CC=go-dev
http://go/go-review/1012006

1 files changed, 2575 insertions, 0 deletions

diff --git a/lib/codereview/codereview.py b/lib/codereview/codereview.py
new file mode 100644
index 000000000..23b573330
--- /dev/null
+++ b/lib/codereview/codereview.py
@@ -0,0 +1,2575 @@
+#!/usr/bin/env python
+#
+# 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 it, set the following options in
+your repository's .hg/hgrc file.
+
+    [extensions]
+    codereview = path/to/codereview.py
+
+    [codereview]
+    project = project-url        # optional
+
+If the project URL is specified, codereview will fetch
+default the reviewer and cc list from that URL each time
+it runs an "upload" command.
+'''
+
+from mercurial import cmdutil, commands, hg, util, error, match
+from mercurial.node import nullrev, hex, nullid, short
+import os, re
+import stat
+from HTMLParser import HTMLParser
+
+try:
+	hgversion = util.version()
+except Exception, e:
+	from mercurial.version import version as v
+	hgversion = v.get_version()
+
+
+# To experiment with Mercurial in the python interpreter: 
+#    >>> repo = hg.repository(ui.ui(), path = ".")
+
+#######################################################################
+# Normally I would split this into multiple files, but it simplifies
+# import path headaches to keep it all in one file.  Sorry.
+
+import sys
+if __name__ == "__main__":
+	print >>sys.stderr, "This is a Mercurial extension and should not be invoked directly."
+	sys.exit(2)
+
+
+#######################################################################
+# 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.
+
+class CL(object):
+	def __init__(self, name):
+		self.name = name
+		self.desc = ''
+		self.files = []
+		self.reviewer = []
+		self.cc = []
+		self.url = ''
+		self.local = False
+		self.web = False
+
+	def DiskText(self):
+		cl = self
+		s = ""
+		s += "Description:\n"
+		s += Indent(cl.desc, "\t")
+		s += "Files:\n"
+		for f in cl.files:
+			s += "\t" + f + "\n"
+		return s
+
+	def EditorText(self):
+		cl = self
+		s = _change_prolog
+		s += "\n"
+		if cl.url != '':
+			s += 'URL: ' + cl.url + '	# cannot edit\n\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"
+		s += "Files:\n"
+		for f in cl.files:
+			s += "\t" + f + "\n"
+		s += "\n"
+		return s
+	
+	def PendingText(self):
+		cl = self
+		s = cl.name + ":" + "\n"
+		s += Indent(cl.desc, "\t")
+		s += "\n"
+		s += "\tReviewer: " + JoinComma(cl.reviewer) + "\n"
+		s += "\tCC: " + JoinComma(cl.cc) + "\n"
+		s += "\tFiles:\n"
+		for f in cl.files:
+			s += "\t\t" + f + "\n"
+		return s
+	
+	def Flush(self, ui, repo):
+		if self.name == "new":
+			self.Upload(ui, repo)
+		dir = CodeReviewDir(ui, repo)
+		path = dir + '/cl.' + self.name
+		f = open(path+'!', "w")
+		f.write(self.DiskText())
+		f.close()
+		os.rename(path+'!', path)
+		if self.web:
+			EditDesc(self.name, subject=line1(self.desc), desc=self.desc,
+				reviewers=JoinComma(self.reviewer), cc=JoinComma(self.cc))
+	
+	def Delete(self, ui, repo):
+		dir = CodeReviewDir(ui, repo)
+		os.unlink(dir + "/cl." + self.name)
+
+	def Upload(self, ui, repo, send_mail=False):
+		os.chdir(repo.root)
+		form_fields = [
+			("content_upload", "1"),
+			("reviewers", JoinComma(self.reviewer)),
+			("cc", JoinComma(self.cc)),
+			("description", self.desc),
+			("base_hashes", ""),
+			("subject", line1(self.desc)),
+		]
+
+		# NOTE(rsc): This duplicates too much of RealMain,
+		# but RealMain doesn't have the nicest interface in the world.
+		if self.name != "new":
+			form_fields.append(("issue", self.name))
+		vcs = GuessVCS(upload_options)
+		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)]
+		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:]]
+		ui.status("uploaded: " + msg + "\n")
+		if not response_body.startswith("Issue created.") and not response_body.startswith("Issue updated."):
+			print response_body
+			raise "failed to update issue"
+		issue = msg[msg.rfind("/")+1:]
+		self.name = issue
+		if not uploaded_diff_file:
+			patches = UploadSeparatePatches(issue, rpc, patchset, data, upload_options)
+		vcs.UploadBaseFiles(issue, rpc, patches, patchset, upload_options, files)
+		if send_mail:
+			MySend("/" + issue + "/mail", payload="")
+		self.web = True
+		self.Flush(ui, repo)
+		return
+
+def GoodCLName(name):
+	return re.match("^[0-9]+$", name)	
+
+def ParseCL(text, name):
+	sname = None
+	lineno = 0
+	sections = {
+		'Description': '',
+		'Files': '',
+		'URL': '',
+		'Reviewer': '',
+		'CC': '',
+	}
+	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)
+	cl.desc = sections['Description']
+	for line in sections['Files'].split('\n'):
+		i = line.find('#')
+		if i >= 0:
+			line = line[0:i].rstrip()
+		if line == '':
+			continue
+		cl.files.append(line)
+	cl.reviewer = SplitCommaSpace(sections['Reviewer'])
+	cl.cc = SplitCommaSpace(sections['CC'])
+	cl.url = sections['URL']
+	if cl.desc == '<enter description here>':
+		cl.desc = '';
+	return cl, 0, ''
+
+def SplitCommaSpace(s):
+	return s.replace(",", " ").split()
+
+def JoinComma(l):
+	return ", ".join(l)
+
+# Load CL from disk and/or the web.
+def LoadCL(ui, repo, name, web=True):
+	if not GoodCLName(name):
+		return None, "invalid CL name"
+	dir = CodeReviewDir(ui, repo)
+	path = dir + "cl." + name
+	try:
+		ff = open(path)
+		text = ff.read()
+		ff.close()
+		cl, lineno, err = ParseCL(text, name)
+		if err != "":
+			return None, "malformed CL data"
+		cl.local = True
+	except Exception, e:
+		cl = CL(name)
+	if web:
+		try:
+			f = GetSettings(name)
+		except Exception, e:
+			return None, "cannot load CL data from code review server"
+		cl.reviewer = SplitCommaSpace(f['reviewers'])
+		cl.cc = SplitCommaSpace(f['cc'])
+		cl.desc = f['description']
+		cl.url = server_url_base + name
+		cl.web = True
+	return cl, ''
+
+# Load all the CLs from this repository.
+def LoadAllCL(ui, repo, web=True):
+	dir = CodeReviewDir(ui, repo)
+	m = {}
+	for f in os.listdir(dir):
+		if f.startswith('cl.'):
+			cl, err = LoadCL(ui, repo, f[3:], web=web)
+			if err != '':
+				ui.warn("loading "+dir+f+": " + err + "\n")
+				continue
+			m[cl.name] = 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]
+	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 Exception, e:
+			ui.warn('cannot mkdir %s: %s\n' % (dir, e))
+			return None
+	return dir
+
+# Strip maximal common leading white space prefix from text
+def StripCommon(text):
+	ws = None
+	for line in text.split('\n'):
+		line = line.rstrip()
+		if line == '':
+			continue
+		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()
+		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]
+	return t
+
+# Indent text with indent.
+def Indent(text, indent):
+	t = ''
+	for line in text.split('\n'):
+		t += indent + line + '\n'
+	return t
+
+# Return the first line of l
+def line1(text):
+	return text.split('\n')[0]
+
+_change_prolog = """# Change list.
+# Lines beginning with # are ignored.
+# Multi-line values should be indented.
+"""
+
+#######################################################################
+# Mercurial helper functions
+
+# Return list of changed files in repository that match pats.
+def ChangedFiles(ui, repo, pats, opts):
+	# Find list of files being operated on.
+	# TODO(rsc): The cutoff might not be 1.3.
+	# Definitely after 1.0.2.
+	try:
+		matcher = cmdutil.match(repo, pats, opts)
+		node1, node2 = cmdutil.revpair(repo, None)
+		modified, added, removed = repo.status(node1, node2, matcher)[:3]
+	except AttributeError, e:
+		# Probably in earlier Mercurial, say 1.0.2.
+		_, matcher, _ = cmdutil.matchpats(repo, pats, opts)
+		node1, node2 = cmdutil.revpair(repo, None)
+		modified, added, removed = repo.status(node1, node2, match=matcher)[:3]
+	return modified + added + removed
+
+# Return list of files claimed by existing CLs
+def TakenFiles(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, opts):
+	return Sub(ChangedFiles(ui, repo, pats, opts), TakenFiles(ui, repo))
+
+def Sub(l1, l2):
+	return [l for l in l1 if l not in l2]
+
+def Add(l1, l2):
+	return l1 + Sub(l2, l1)
+
+def Intersect(l1, l2):
+	return [l for l in l1 if l in l2]
+
+def Incoming(ui, repo, opts, op):
+	source, _, _ = hg.parseurl(ui.expandpath("default"), None)
+	try:
+		other = hg.repository(cmdutil.remoteui(repo, opts), source)
+		_, incoming, _ = repo.findcommonincoming(other)
+	except AttributeError, e:
+		other = hg.repository(ui, source)
+		incoming = repo.findincoming(other)
+	return incoming
+
+def EditCL(ui, repo, cl):
+	s = cl.EditorText()
+	while True:
+		s = ui.edit(s, ui.username())
+		clx, line, err = ParseCL(s, cl.name)
+		if err != '':
+			# TODO(rsc): another 1.3 inconsistency
+			if ui.prompt("error parsing change list: line %d: %s\nre-edit (y/n)?" % (line, err), ["&yes", "&no"], "y") == "n":
+				return "change list not modified"
+			continue
+		cl.desc = clx.desc;
+		cl.reviewer = clx.reviewer
+		cl.cc = clx.cc
+		cl.files = clx.files
+		if cl.desc == '':
+			if ui.prompt("change list should have description\nre-edit (y/n)?", ["&yes", "&no"], "y") != "n":
+				continue
+		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):
+	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)
+	else:
+		cl = CL("new")
+		cl.local = True
+		cl.files = Sub(ChangedFiles(ui, repo, pats, opts), TakenFiles(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 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, ""
+
+#######################################################################
+# Mercurial commands
+
+# until done debugging
+server = "localhost:1"
+# server = "codereview.appspot.com"
+
+server_url_base = None
+
+# every command must take a ui and and repo as arguments.
+# opts is a dict where you can find other command line flags
+#
+# Other parameters are taken in order from items on the command line that
+# don't start with a dash.  If no default value is given in the parameter list,
+# they are required.
+# 
+
+# Change command.
+def change(ui, repo, *pats, **opts):
+	"""create or edit a change list
+	
+	Create or edit 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.  
+	"""
+	
+	if opts["add"] and opts["delete"]:
+		return "cannot use -a with -d"
+
+	if (opts["add"] or opts["delete"]) and (opts["stdin"] or opts["stdout"]):
+		return "cannot use -a/-d with -i/-o"
+
+	dirty = {}
+	if len(pats) > 0 and GoodCLName(pats[0]):
+		name = pats[0]
+		pats = pats[1:]
+		cl, err = LoadCL(ui, repo, name, web=True)
+		if err != '':
+			return err
+		if not cl.local and (opts["add"] or opts["delete"] or opts["stdin"] or not opts["stdout"]):
+			return "cannot change non-local CL " + name
+	else:
+		if opts["add"] or opts["delete"]:
+			return "cannot use -a/-d when creating CL"
+		name = "new"
+		cl = CL("new")
+		dirty[cl] = True
+	
+	files = ChangedFiles(ui, repo, pats, opts)
+	taken = TakenFiles(ui, repo)
+	files = Sub(files, taken)
+
+	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 opts["add"]:
+		newfiles = Sub(files, cl.files)
+		stolen = Intersect(newfiles, taken)
+		if stolen:
+			ui.status("# Taking files from other CLs.  To undo:\n")
+			for f in stolen:
+				ocl = taken[f]
+				ui.status("#	hg change -a %s %s\n" % (ocl.name, f))
+				ocl.files = Sub(ocl.files, [f])
+				dirty[ocl] = True
+		not_stolen = Sub(newfiles, stolen)
+		if not_stolen:
+			ui.status("# Add files to CL.  To undo:\n")
+			for f in not_stolen:
+				ui.status("#	hg change -d %s %s\n" % (cl.name, f))
+		if newfiles:
+			cl.files += newfiles
+			dirty[cl] = True
+
+	if opts["delete"]:
+		oldfiles = Intersect(files, cl.files)
+		if oldfiles:
+			ui.status("# Removing files from CL.  To undo:\n")
+			for f in oldfiles:
+				ui.status("#	hg change -a %s %s\n" % (cl.name, f))
+			cl.files = Sub(cl.files, oldfiles)
+			dirty[cl] = True
+
+	if not opts["add"] and not opts["delete"] and 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():
+		d.Flush(ui, repo)
+	
+	if opts["stdout"]:
+		ui.write(cl.EditorText())
+	elif name == "new":
+		if ui.quiet:
+			ui.write(cl.name)
+		else:
+			ui.write("URL: " + cl.url)
+	return
+
+def pending(ui, repo, *pats, **opts):
+	m = LoadAllCL(ui, repo, web=True)
+	names = m.keys()
+	names.sort()
+	for name in names:
+		cl = m[name]
+		ui.write(cl.PendingText() + "\n")
+
+	files = DefaultFiles(ui, repo, [], opts)
+	if len(files) > 0:
+		s = "Changed files not in any CL:\n"
+		for f in files:
+			s += "\t" + f + "\n"
+		ui.write(s)
+
+def upload(ui, repo, name, **opts):
+	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
+
+def mail(ui, repo, *pats, **opts):
+	cl, err = CommandLineCL(ui, repo, pats, opts)
+	if err != "":
+		return err
+	if not cl.reviewer:
+		return "no reviewers listed in CL"
+	cl.Upload(ui, repo)
+	pmsg = "Hello " + JoinComma(cl.reviewer) + ",\n"
+	pmsg += "\n"
+	pmsg += "I'd like you to review the following change.\n"
+	PostMessage(cl.name, pmsg, send_mail="checked", subject="code review: " + line1(cl.desc))
+	
+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.
+	"""
+	repo.ui.quiet = True
+	if not opts["no_incoming"] and Incoming(ui, repo, opts, "submit"):
+		return "local repository out of date; must sync before submit"
+
+	cl, err = CommandLineCL(ui, repo, pats, opts)
+	if err != "":
+		return err
+	
+	about = ""
+	if cl.reviewer:
+		about += "R=" + JoinComma(cl.reviewer) + "\n"
+	if opts.get('tbr'):
+		tbr = SplitCommaSpace(opts.get('tbr'))
+		cl.reviewer = Add(cl.reviewer, tbr)
+		about += "TBR=" + JoinComma(tbr) + "\n"
+	if cl.cc:
+		about += "CC=" + JoinComma(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.
+	cl.Upload(ui, repo)
+	about += "%s%s\n" % (server_url_base, cl.name)
+
+	# submit changes locally
+	date = opts.get('date')
+	if date:
+		opts['date'] = util.parsedate(date)
+	opts['message'] = cl.desc.rstrip() + "\n\n" + about
+	try:
+		m = match.exact(repo.root, repo.getcwd(), cl.files)
+		node = repo.commit(opts['message'], opts.get('user'), opts.get('date'), m)
+	except Exception, e:
+		_, m, _ = util._matcher(repo.root, repo.getcwd(), cl.files, None, None, 'path', None)
+		node = repo.commit(text=opts['message'], user=opts.get('user'), date=opts.get('date'), match=m)
+	if not node:
+		return "nothing changed"
+
+	log = repo.changelog
+	rev = log.rev(node)
+	parents = log.parentrevs(rev)
+	if (rev-1 not in parents and
+			(parents == (nullrev, nullrev) or
+			len(log.heads(log.node(parents[0]))) > 1 and
+			(parents[1] == nullrev or len(log.heads(log.node(parents[1]))) > 1))):
+		repo.rollback()
+		return "local repository out of date (created new head); must sync before submit"
+
+	# push changes to remote.
+	# if it works, we're committed.
+	# if not, roll back
+	dest, _, _ = hg.parseurl(ui.expandpath("default"), None)
+	try:
+		other = hg.repository(cmdutil.remoteui(repo, opts), dest)
+	except AttributeError, e:
+		other = hg.repository(ui, dest)
+	r = repo.push(other, False, None)
+	if r == 0:
+		repo.rollback()
+		return "local repository out of date; must sync before submit"
+
+	# we're committed. upload final patch, close review, add commit message
+	changeURL = short(node)
+	url = other.url()
+	m = re.match("^https?://([^@/]+@)?([^.]+)\.googlecode\.com/hg/", url)
+	if m:
+		changeURL = "http://code.google.com/p/%s/source/detail?r=%s" % (m.group(2), changeURL)
+	else:
+		print >>sys.stderr, "URL: ", url
+	pmsg = "*** Submitted as " + changeURL + " ***\n\n" + opts['message']
+	PostMessage(cl.name, pmsg, send_mail="checked")
+	EditDesc(cl.name, closed="checked")
+	cl.Delete(ui, repo)
+
+def sync(ui, repo, **opts):
+	"""synchronize with remote repository
+	
+	Incorporates recent changes from the remote repository
+	into the local repository.
+	
+	Equivalent to the Mercurial command "hg pull -u".
+	"""
+	repo.ui.quiet = True
+	source, _, _ = hg.parseurl(ui.expandpath("default"), None)
+	try:
+		other = hg.repository(cmdutil.remoteui(repo, opts), source)
+	except AttributeError, e:
+		other = hg.repository(ui, source)
+	modheads = repo.pull(other)
+	return commands.postincoming(ui, repo, modheads, True, "tip")
+
+def uisetup(ui):
+	if "^commit|ci" in commands.table:
+		commands.table["^commit|ci"] = (nocommit, [], "")
+	RietveldSetup(ui)
+
+def nocommit(ui, repo, *pats, **opts):
+	return "The codereview extension is enabled; do not use commit."
+
+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.
+
+	# TODO: Should change upload?
+	"^change": (
+		change,
+		[
+			('a', 'add', None, 'add files to change list'),
+			('d', 'delete', None, 'remove files from change list'),
+			('o', 'stdout', None, 'print change list to standard output'),
+			('i', 'stdin', None, 'read change list from standard input'),
+		],
+		"[-a | -d | [-i] [-o]] [change#] [FILE ...]"
+	),
+	"^pending|p": (
+		pending,
+		[],
+		"[FILE ...]"
+	),
+
+	# TODO: cdiff - steal diff options and command line
+
+	"^upload": (
+		upload,
+		[],
+		"change#"
+	),
+	
+	"^mail": (
+		mail,
+		review_opts + [
+		] + commands.walkopts,
+		"[-r reviewer] [--cc cc] [change# | file ...]"
+	),
+
+	"^submit": (
+		submit,
+		review_opts + [
+			('', 'no_incoming', None, 'disable initial incoming check (for testing)'),
+		] + commands.walkopts + commands.commitopts + commands.commitopts2,
+		"[-r reviewer] [--cc cc] [change# | file ...]"
+	),
+	
+	"^sync": (
+		sync,
+		[],
+		"",
+	),
+	
+	"commit|ci": (
+		nocommit,
+		[],
+		"",
+	),
+}
+
+
+#######################################################################
+# Wrappers around upload.py for interacting with Rietveld
+
+emptydiff = """Index: ~rietveld~placeholder~
+===================================================================
+diff --git a/~rietveld~placeholder~ b/~rietveld~placeholder~
+new file mode 100644
+"""
+
+# 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):
+		import unicodedata
+		char = unicodedata.name(unichr(int(name)))
+		self.handle_data(char)
+	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
+
+# 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 MySend(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.
+    global rpc
+    if rpc == None:
+    	rpc = GetRpcServer(upload_options)
+    self = rpc
+    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:
+            self._Authenticate()
+          elif e.code == 302:
+            loc = e.info()["location"]
+            if not loc.startswith('https://www.google.com/accounts/ServiceLogin'):
+              return ''
+            self._Authenticate()
+          else:
+            raise
+    finally:
+      socket.setdefaulttimeout(old_timeout)
+
+def GetForm(url):
+	f = FormParser()
+	f.feed(MySend(url))
+	f.close()
+	for k,v in f.map.items():
+		f.map[k] = v.replace("\r\n", "\n");
+	return f.map
+
+def GetSettings(issue):
+	f = GetForm("/" + issue + "/edit")
+	if not f:
+		print "PUB"
+		f = GetForm("/" + issue + "/publish")
+	return f
+
+def CreateIssue(subject, desc):
+	form_fields = [
+		("content_upload", "1"),
+#		("user", upload_options.email),
+		("reviewers", ''),
+		("cc", ''),
+		("description", desc),
+		("base_hashes", ""),
+		("subject", subject),
+	]
+	uploaded_diff_file = [
+		("data", "data.diff", emptydiff),
+	]
+	ctype, body = EncodeMultipartFormData(form_fields, uploaded_diff_file)
+	response = MySend("/upload", body, content_type=ctype)
+	if response != "":
+		print >>sys.stderr, "Error creating issue:\n" + response
+		sys.exit(2)
+
+def EditDesc(issue, subject=None, desc=None, reviewers=None, cc=None, closed=None):
+	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 is not None:
+		form_fields['closed'] = closed
+	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(issue, message, reviewers=None, cc=None, send_mail=None, subject=None):
+	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 is not None:
+		form_fields['send_mail'] = send_mail
+	if subject is not None:
+		form_fields['subject'] = subject
+	form_fields['message'] = message
+	form_fields['message_only'] = '1'
+	ctype, body = EncodeMultipartFormData(form_fields.items(), [])
+	response = MySend("/" + issue + "/publish", body, content_type=ctype)
+	if response != "":
+		print response
+		sys.exit(2)
+
+class opt(object):
+	pass
+
+def RietveldSetup(ui):
+	global upload_options, rpc, server, server_url_base
+
+	# TODO(rsc): If the repository config has no codereview section,
+	# do not enable the extension.  This allows users to
+	# put the extension in their global .hgrc but only
+	# enable it for some repositories.
+	# if not ui.has_section("codereview"):
+	# 	cmdtable = {}
+	# 	return
+
+	# 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
+
+	cc = None
+	x = ui.config("codereview", "cc")
+	if x is not None:
+		cc = x
+	
+	server_url_base = "http://" + server + "/"
+	x = ui.config("codereview", "server_url_base")
+	if x is not None:
+		server_url_base = x
+	if not server_url_base.endswith("/"):
+		server_url_base += "/"
+
+	testing = ui.config("codereview", "testing")
+
+	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 = cc
+	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
+
+#######################################################################
+# We keep a full copy of upload.py here to avoid import path hell.
+# It would be nice if hg added the hg repository root
+# to the default PYTHONPATH.
+
+# Edit .+2,<hget http://codereview.appspot.com/static/upload.py
+
+#!/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
+
+# Constants for version control names.  Used by GuessVCSName.
+VCS_GIT = "Git"
+VCS_MERCURIAL = "Mercurial"
+VCS_SUBVERSION = "Subversion"
+VCS_UNKNOWN = "Unknown"
+
+# 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']
+
+VCS_ABBREVIATIONS = {
+  VCS_MERCURIAL.lower(): VCS_MERCURIAL,
+  "hg": VCS_MERCURIAL,
+  VCS_SUBVERSION.lower(): VCS_SUBVERSION,
+  "svn": VCS_SUBVERSION,
+  VCS_GIT.lower(): VCS_GIT,
+}
+
+
+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"):
+      # 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()
+##           elif e.code >= 500 and e.code < 600:
+##             # Server Error - try again.
+##             continue
+          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
+
+
+parser = optparse.OptionParser(usage="%prog [options] [-- diff_options]")
+parser.add_option("-y", "--assume_yes", action="store_true",
+                  dest="assume_yes", default=False,
+                  help="Assume that the answer to yes/no questions is 'yes'.")
+# Logging
+group = parser.add_option_group("Logging options")
+group.add_option("-q", "--quiet", action="store_const", const=0,
+                 dest="verbose", help="Print errors only.")
+group.add_option("-v", "--verbose", action="store_const", const=2,
+                 dest="verbose", default=1,
+                 help="Print info level logs (default).")
+group.add_option("--noisy", action="store_const", const=3,
+                 dest="verbose", help="Print all logs.")
+# Review server
+group = parser.add_option_group("Review server options")
+group.add_option("-s", "--server", action="store", dest="server",
+                 default="codereview.appspot.com",
+                 metavar="SERVER",
+                 help=("The server to upload to. The format is host[:port]. "
+                       "Defaults to '%default'."))
+group.add_option("-e", "--email", action="store", dest="email",
+                 metavar="EMAIL", default=None,
+                 help="The username to use. Will prompt if omitted.")
+group.add_option("-H", "--host", action="store", dest="host",
+                 metavar="HOST", default=None,
+                 help="Overrides the Host header sent with all RPCs.")
+group.add_option("--no_cookies", action="store_false",
+                 dest="save_cookies", default=True,
+                 help="Do not save authentication cookies to local disk.")
+# Issue
+group = parser.add_option_group("Issue options")
+group.add_option("-d", "--description", action="store", dest="description",
+                 metavar="DESCRIPTION", default=None,
+                 help="Optional description when creating an issue.")
+group.add_option("-f", "--description_file", action="store",
+                 dest="description_file", metavar="DESCRIPTION_FILE",
+                 default=None,
+                 help="Optional path of a file that contains "
+                      "the description when creating an issue.")
+group.add_option("-r", "--reviewers", action="store", dest="reviewers",
+                 metavar="REVIEWERS", default=None,
+                 help="Add reviewers (comma separated email addresses).")
+group.add_option("--cc", action="store", dest="cc",
+                 metavar="CC", default=None,
+                 help="Add CC (comma separated email addresses).")
+group.add_option("--private", action="store_true", dest="private",
+                 default=False,
+                 help="Make the issue restricted to reviewers and those CCed")
+# Upload options
+group = parser.add_option_group("Patch options")
+group.add_option("-m", "--message", action="store", dest="message",
+                 metavar="MESSAGE", default=None,
+                 help="A message to identify the patch. "
+                      "Will prompt if omitted.")
+group.add_option("-i", "--issue", type="int", action="store",
+                 metavar="ISSUE", default=None,
+                 help="Issue number to which to add. Defaults to new issue.")
+group.add_option("--download_base", action="store_true",
+                 dest="download_base", default=False,
+                 help="Base files will be downloaded by the server "
+                 "(side-by-side diffs may not work on files with CRs).")
+group.add_option("--rev", action="store", dest="revision",
+                 metavar="REV", default=None,
+                 help="Branch/tree/revision to diff against (used by DVCS).")
+group.add_option("--send_mail", action="store_true",
+                 dest="send_mail", default=False,
+                 help="Send notification email to reviewers.")
+group.add_option("--vcs", action="store", dest="vcs",
+                 metavar="VCS", default=None,
+                 help=("Version control system (optional, usually upload.py "
+                       "already guesses the right VCS)."))
+
+
+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."""
+    email = options.email
+    if email is None:
+      email = GetEmail("Email (login for uploading to %s)" % options.server)
+    password = getpass.getpass("Password for %s: " % email)
+    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:
+    lines.append('--' + BOUNDARY)
+    lines.append('Content-Disposition: form-data; name="%s"' % key)
+    lines.append('')
+    lines.append(value)
+  for (key, filename, value) in files:
+    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 = filename.strip().replace('\\', '/')
+        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."""
+      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)
+
+    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:
+        UploadFile(filename, file_id, base_content, is_binary, status, True)
+      if new_content != None:
+        UploadFile(filename, file_id, new_content, is_binary, status, False)
+
+  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 SubversionVCS(VersionControlSystem):
+  """Implementation of the VersionControlSystem interface for Subversion."""
+
+  def __init__(self, options):
+    super(SubversionVCS, self).__init__(options)
+    if self.options.revision:
+      match = re.match(r"(\d+)(:(\d+))?", self.options.revision)
+      if not match:
+        ErrorExit("Invalid Subversion revision %s." % self.options.revision)
+      self.rev_start = match.group(1)
+      self.rev_end = match.group(3)
+    else:
+      self.rev_start = self.rev_end = None
+    # Cache output from "svn list -r REVNO dirname".
+    # Keys: dirname, Values: 2-tuple (ouput for start rev and end rev).
+    self.svnls_cache = {}
+    # SVN base URL is required to fetch files deleted in an older revision.
+    # Result is cached to not guess it over and over again in GetBaseFile().
+    required = self.options.download_base or self.options.revision is not None
+    self.svn_base = self._GuessBase(required)
+
+  def GuessBase(self, required):
+    """Wrapper for _GuessBase."""
+    return self.svn_base
+
+  def _GuessBase(self, required):
+    """Returns the SVN base URL.
+
+    Args:
+      required: If true, exits if the url can't be guessed, otherwise None is
+        returned.
+    """
+    info = RunShell(["svn", "info"])
+    for line in info.splitlines():
+      words = line.split()
+      if len(words) == 2 and words[0] == "URL:":
+        url = words[1]
+        scheme, netloc, path, params, query, fragment = urlparse.urlparse(url)
+        username, netloc = urllib.splituser(netloc)
+        if username:
+          logging.info("Removed username from base URL")
+        if netloc.endswith("svn.python.org"):
+          if netloc == "svn.python.org":
+            if path.startswith("/projects/"):
+              path = path[9:]
+          elif netloc != "pythondev@svn.python.org":
+            ErrorExit("Unrecognized Python URL: %s" % url)
+          base = "http://svn.python.org/view/*checkout*%s/" % path
+          logging.info("Guessed Python base = %s", base)
+        elif netloc.endswith("svn.collab.net"):
+          if path.startswith("/repos/"):
+            path = path[6:]
+          base = "http://svn.collab.net/viewvc/*checkout*%s/" % path
+          logging.info("Guessed CollabNet base = %s", base)
+        elif netloc.endswith(".googlecode.com"):
+          path = path + "/"
+          base = urlparse.urlunparse(("http", netloc, path, params,
+                                      query, fragment))
+          logging.info("Guessed Google Code base = %s", base)
+        else:
+          path = path + "/"
+          base = urlparse.urlunparse((scheme, netloc, path, params,
+                                      query, fragment))
+          logging.info("Guessed base = %s", base)
+        return base
+    if required:
+      ErrorExit("Can't find URL in output from svn info")
+    return None
+
+  def GenerateDiff(self, args):
+    cmd = ["svn", "diff"]
+    if self.options.revision:
+      cmd += ["-r", self.options.revision]
+    cmd.extend(args)
+    data = RunShell(cmd)
+    count = 0
+    for line in data.splitlines():
+      if line.startswith("Index:") or line.startswith("Property changes on:"):
+        count += 1
+        logging.info(line)
+    if not count:
+      ErrorExit("No valid patches found in output from svn diff")
+    return data
+
+  def _CollapseKeywords(self, content, keyword_str):
+    """Collapses SVN keywords."""
+    # svn cat translates keywords but svn diff doesn't. As a result of this
+    # behavior patching.PatchChunks() fails with a chunk mismatch error.
+    # This part was originally written by the Review Board development team
+    # who had the same problem (http://reviews.review-board.org/r/276/).
+    # Mapping of keywords to known aliases
+    svn_keywords = {
+      # Standard keywords
+      'Date':                ['Date', 'LastChangedDate'],
+      'Revision':            ['Revision', 'LastChangedRevision', 'Rev'],
+      'Author':              ['Author', 'LastChangedBy'],
+      'HeadURL':             ['HeadURL', 'URL'],
+      'Id':                  ['Id'],
+
+      # Aliases
+      'LastChangedDate':     ['LastChangedDate', 'Date'],
+      'LastChangedRevision': ['LastChangedRevision', 'Rev', 'Revision'],
+      'LastChangedBy':       ['LastChangedBy', 'Author'],
+      'URL':                 ['URL', 'HeadURL'],
+    }
+
+    def repl(m):
+       if m.group(2):
+         return "$%s::%s$" % (m.group(1), " " * len(m.group(3)))
+       return "$%s$" % m.group(1)
+    keywords = [keyword
+                for name in keyword_str.split(" ")
+                for keyword in svn_keywords.get(name, [])]
+    return re.sub(r"\$(%s):(:?)([^\$]+)\$" % '|'.join(keywords), repl, content)
+
+  def GetUnknownFiles(self):
+    status = RunShell(["svn", "status", "--ignore-externals"], silent_ok=True)
+    unknown_files = []
+    for line in status.split("\n"):
+      if line and line[0] == "?":
+        unknown_files.append(line)
+    return unknown_files
+
+  def ReadFile(self, filename):
+    """Returns the contents of a file."""
+    file = open(filename, 'rb')
+    result = ""
+    try:
+      result = file.read()
+    finally:
+      file.close()
+    return result
+
+  def GetStatus(self, filename):
+    """Returns the status of a file."""
+    if not self.options.revision:
+      status = RunShell(["svn", "status", "--ignore-externals", filename])
+      if not status:
+        ErrorExit("svn status returned no output for %s" % filename)
+      status_lines = status.splitlines()
+      # If file is in a cl, the output will begin with
+      # "\n--- Changelist 'cl_name':\n".  See
+      # http://svn.collab.net/repos/svn/trunk/notes/changelist-design.txt
+      if (len(status_lines) == 3 and
+          not status_lines[0] and
+          status_lines[1].startswith("--- Changelist")):
+        status = status_lines[2]
+      else:
+        status = status_lines[0]
+    # If we have a revision to diff against we need to run "svn list"
+    # for the old and the new revision and compare the results to get
+    # the correct status for a file.
+    else:
+      dirname, relfilename = os.path.split(filename)
+      if dirname not in self.svnls_cache:
+        cmd = ["svn", "list", "-r", self.rev_start, dirname or "."]
+        out, returncode = RunShellWithReturnCode(cmd)
+        if returncode:
+          ErrorExit("Failed to get status for %s." % filename)
+        old_files = out.splitlines()
+        args = ["svn", "list"]
+        if self.rev_end:
+          args += ["-r", self.rev_end]
+        cmd = args + [dirname or "."]
+        out, returncode = RunShellWithReturnCode(cmd)
+        if returncode:
+          ErrorExit("Failed to run command %s" % cmd)
+        self.svnls_cache[dirname] = (old_files, out.splitlines())
+      old_files, new_files = self.svnls_cache[dirname]
+      if relfilename in old_files and relfilename not in new_files:
+        status = "D   "
+      elif relfilename in old_files and relfilename in new_files:
+        status = "M   "
+      else:
+        status = "A   "
+    return status
+
+  def GetBaseFile(self, filename):
+    status = self.GetStatus(filename)
+    base_content = None
+    new_content = None
+
+    # If a file is copied its status will be "A  +", which signifies
+    # "addition-with-history".  See "svn st" for more information.  We need to
+    # upload the original file or else diff parsing will fail if the file was
+    # edited.
+    if status[0] == "A" and status[3] != "+":
+      # We'll need to upload the new content if we're adding a binary file
+      # since diff's output won't contain it.
+      mimetype = RunShell(["svn", "propget", "svn:mime-type", filename],
+                          silent_ok=True)
+      base_content = ""
+      is_binary = bool(mimetype) and not mimetype.startswith("text/")
+      if is_binary and self.IsImage(filename):
+        new_content = self.ReadFile(filename)
+    elif (status[0] in ("M", "D", "R") or
+          (status[0] == "A" and status[3] == "+") or  # Copied file.
+          (status[0] == " " and status[1] == "M")):  # Property change.
+      args = []
+      if self.options.revision:
+        url = "%s/%s@%s" % (self.svn_base, filename, self.rev_start)
+      else:
+        # Don't change filename, it's needed later.
+        url = filename
+        args += ["-r", "BASE"]
+      cmd = ["svn"] + args + ["propget", "svn:mime-type", url]
+      mimetype, returncode = RunShellWithReturnCode(cmd)
+      if returncode:
+        # File does not exist in the requested revision.
+        # Reset mimetype, it contains an error message.
+        mimetype = ""
+      get_base = False
+      is_binary = bool(mimetype) and not mimetype.startswith("text/")
+      if status[0] == " ":
+        # Empty base content just to force an upload.
+        base_content = ""
+      elif is_binary:
+        if self.IsImage(filename):
+          get_base = True
+          if status[0] == "M":
+            if not self.rev_end:
+              new_content = self.ReadFile(filename)
+            else:
+              url = "%s/%s@%s" % (self.svn_base, filename, self.rev_end)
+              new_content = RunShell(["svn", "cat", url],
+                                     universal_newlines=True, silent_ok=True)
+        else:
+          base_content = ""
+      else:
+        get_base = True
+
+      if get_base:
+        if is_binary:
+          universal_newlines = False
+        else:
+          universal_newlines = True
+        if self.rev_start:
+          # "svn cat -r REV delete_file.txt" doesn't work. cat requires
+          # the full URL with "@REV" appended instead of using "-r" option.
+          url = "%s/%s@%s" % (self.svn_base, filename, self.rev_start)
+          base_content = RunShell(["svn", "cat", url],
+                                  universal_newlines=universal_newlines,
+                                  silent_ok=True)
+        else:
+          base_content = RunShell(["svn", "cat", filename],
+                                  universal_newlines=universal_newlines,
+                                  silent_ok=True)
+        if not is_binary:
+          args = []
+          if self.rev_start:
+            url = "%s/%s@%s" % (self.svn_base, filename, self.rev_start)
+          else:
+            url = filename
+            args += ["-r", "BASE"]
+          cmd = ["svn"] + args + ["propget", "svn:keywords", url]
+          keywords, returncode = RunShellWithReturnCode(cmd)
+          if keywords and not returncode:
+            base_content = self._CollapseKeywords(base_content, keywords)
+    else:
+      StatusUpdate("svn status returned unexpected output: %s" % status)
+      sys.exit(1)
+    return base_content, new_content, is_binary, status[0:5]
+
+
+class GitVCS(VersionControlSystem):
+  """Implementation of the VersionControlSystem interface for Git."""
+
+  def __init__(self, options):
+    super(GitVCS, self).__init__(options)
+    # Map of filename -> (hash before, hash after) of base file.
+    # Hashes for "no such file" are represented as None.
+    self.hashes = {}
+    # Map of new filename -> old filename for renames.
+    self.renames = {}
+
+  def GenerateDiff(self, extra_args):
+    # This is more complicated than svn's GenerateDiff because we must convert
+    # the diff output to include an svn-style "Index:" line as well as record
+    # the hashes of the files, so we can upload them along with our diff.
+
+    # Special used by git to indicate "no such content".
+    NULL_HASH = "0"*40
+
+    extra_args = extra_args[:]
+    if self.options.revision:
+      extra_args = [self.options.revision] + extra_args
+    extra_args.append('-M')
+
+    # --no-ext-diff is broken in some versions of Git, so try to work around
+    # this by overriding the environment (but there is still a problem if the
+    # git config key "diff.external" is used).
+    env = os.environ.copy()
+    if 'GIT_EXTERNAL_DIFF' in env: del env['GIT_EXTERNAL_DIFF']
+    gitdiff = RunShell(["git", "diff", "--no-ext-diff", "--full-index"]
+                       + extra_args, env=env)
+    svndiff = []
+    filecount = 0
+    filename = None
+    for line in gitdiff.splitlines():
+      match = re.match(r"diff --git a/(.*) b/(.*)$", line)
+      if match:
+        filecount += 1
+        # Intentionally use the "after" filename so we can show renames.
+        filename = match.group(2)
+        svndiff.append("Index: %s\n" % filename)
+        if match.group(1) != match.group(2):
+          self.renames[match.group(2)] = match.group(1)
+      else:
+        # The "index" line in a git diff looks like this (long hashes elided):
+        #   index 82c0d44..b2cee3f 100755
+        # We want to save the left hash, as that identifies the base file.
+        match = re.match(r"index (\w+)\.\.(\w+)", line)
+        if match:
+          before, after = (match.group(1), match.group(2))
+          if before == NULL_HASH:
+            before = None
+          if after == NULL_HASH:
+            after = None
+          self.hashes[filename] = (before, after)
+      svndiff.append(line + "\n")
+    if not filecount:
+      ErrorExit("No valid patches found in output from git diff")
+    return "".join(svndiff)
+
+  def GetUnknownFiles(self):
+    status = RunShell(["git", "ls-files", "--exclude-standard", "--others"],
+                      silent_ok=True)
+    return status.splitlines()
+
+  def GetFileContent(self, file_hash, is_binary):
+    """Returns the content of a file identified by its git hash."""
+    data, retcode = RunShellWithReturnCode(["git", "show", file_hash],
+                                            universal_newlines=not is_binary)
+    if retcode:
+      ErrorExit("Got error status from 'git show %s'" % file_hash)
+    return data
+
+  def GetBaseFile(self, filename):
+    hash_before, hash_after = self.hashes.get(filename, (None,None))
+    base_content = None
+    new_content = None
+    is_binary = self.IsBinary(filename)
+    status = None
+
+    if filename in self.renames:
+      status = "A +"  # Match svn attribute name for renames.
+      if filename not in self.hashes:
+        # If a rename doesn't change the content, we never get a hash.
+        base_content = RunShell(["git", "show", filename])
+    elif not hash_before:
+      status = "A"
+      base_content = ""
+    elif not hash_after:
+      status = "D"
+    else:
+      status = "M"
+
+    is_image = self.IsImage(filename)
+
+    # Grab the before/after content if we need it.
+    # We should include file contents if it's text or it's an image.
+    if not is_binary or is_image:
+      # Grab the base content if we don't have it already.
+      if base_content is None and hash_before:
+        base_content = self.GetFileContent(hash_before, is_binary)
+      # Only include the "after" file if it's an image; otherwise it
+      # it is reconstructed from the diff.
+      if is_image and hash_after:
+        new_content = self.GetFileContent(hash_after, is_binary)
+
+    return (base_content, new_content, is_binary, status)
+
+
+class MercurialVCS(VersionControlSystem):
+  """Implementation of the VersionControlSystem interface for Mercurial."""
+
+  def __init__(self, options, repo_dir):
+    super(MercurialVCS, self).__init__(options)
+    # Absolute path to repository (we can be in a subdir)
+    self.repo_dir = os.path.normpath(repo_dir)
+    # 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:
+      self.base_rev = RunShell(["hg", "parent", "-q"]).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 GetBaseFile(self, 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)
+    # "hg status -C" returns two lines for moved/copied files, one otherwise
+    out = RunShell(["hg", "status", "-C", "--rev", self.base_rev, relpath])
+    out = out.splitlines()
+    # HACK: strip error message about missing file/directory if it isn't in
+    # the working copy
+    if out[0].startswith('%s: ' % relpath):
+      out = out[1:]
+    if len(out) > 1:
+      # Moved/copied => considered as modified, use old filename to
+      # retrieve base contents
+      oldrelpath = out[1].strip()
+      status = "M"
+    else:
+      status, _ = out[0].split(' ', 1)
+    if ":" in self.base_rev:
+      base_rev = self.base_rev.split(":", 1)[0]
+    else:
+      base_rev = self.base_rev
+    if status != "A":
+      base_content = RunShell(["hg", "cat", "-r", base_rev, oldrelpath],
+        silent_ok=True)
+      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:
+      # 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 = temp_filename.strip().replace('\\', '/')
+      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:
+    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
+
+
+def GuessVCSName():
+  """Helper to guess the version control system.
+
+  This examines the current directory, guesses which VersionControlSystem
+  we're using, and returns an string indicating which VCS is detected.
+
+  Returns:
+    A pair (vcs, output).  vcs is a string indicating which VCS was detected
+    and is one of VCS_GIT, VCS_MERCURIAL, VCS_SUBVERSION, or VCS_UNKNOWN.
+    output is a string containing any interesting output from the vcs
+    detection routine, or None if there is nothing interesting.
+  """
+  # Mercurial has a command to get the base directory of a repository
+  # Try running it, but don't die if we don't have hg installed.
+  # NOTE: we try Mercurial first as it can sit on top of an SVN working copy.
+  try:
+    out, returncode = RunShellWithReturnCode(["hg", "root"])
+    if returncode == 0:
+      return (VCS_MERCURIAL, out.strip())
+  except OSError, (errno, message):
+    if errno != 2:  # ENOENT -- they don't have hg installed.
+      raise
+
+  # Subversion has a .svn in all working directories.
+  if os.path.isdir('.svn'):
+    logging.info("Guessed VCS = Subversion")
+    return (VCS_SUBVERSION, None)
+
+  # Git has a command to test if you're in a git tree.
+  # Try running it, but don't die if we don't have git installed.
+  try:
+    out, returncode = RunShellWithReturnCode(["git", "rev-parse",
+                                              "--is-inside-work-tree"])
+    if returncode == 0:
+      return (VCS_GIT, None)
+  except OSError, (errno, message):
+    if errno != 2:  # ENOENT -- they don't have git installed.
+      raise
+
+  return (VCS_UNKNOWN, None)
+
+
+def GuessVCS(options):
+  """Helper to guess the version control system.
+
+  This verifies any user-specified VersionControlSystem (by command line
+  or environment variable).  If the user didn't specify one, this examines
+  the current directory, guesses which VersionControlSystem we're using,
+  and returns an instance of the appropriate class.  Exit with an error
+  if we can't figure it out.
+
+  Returns:
+    A VersionControlSystem instance. Exits if the VCS can't be guessed.
+  """
+  vcs = options.vcs
+  if not vcs:
+    vcs = os.environ.get("CODEREVIEW_VCS")
+  if vcs:
+    v = VCS_ABBREVIATIONS.get(vcs.lower())
+    if v is None:
+      ErrorExit("Unknown version control system %r specified." % vcs)
+    (vcs, extra_output) = (v, None)
+  else:
+    (vcs, extra_output) = GuessVCSName()
+
+  if vcs == VCS_MERCURIAL:
+    if extra_output is None:
+      extra_output = RunShell(["hg", "root"]).strip()
+    return MercurialVCS(options, extra_output)
+  elif vcs == VCS_SUBVERSION:
+    return SubversionVCS(options)
+  elif vcs == VCS_GIT:
+    return GitVCS(options)
+
+  ErrorExit(("Could not guess version control system. "
+             "Are you in a working copy directory?"))
+
+
+def RealMain(argv, data=None):
+  """The real main function.
+
+  Args:
+    argv: Command line arguments.
+    data: Diff contents. If None (default) the diff is generated by
+      the VersionControlSystem implementation returned by GuessVCS().
+
+  Returns:
+    A 2-tuple (issue id, patchset id).
+    The patchset id is None if the base files are not uploaded by this
+    script (applies only to SVN checkouts).
+  """
+  logging.basicConfig(format=("%(asctime).19s %(levelname)s %(filename)s:"
+                              "%(lineno)s %(message)s "))
+  os.environ['LC_ALL'] = 'C'
+  options, args = parser.parse_args(argv[1:])
+  global verbosity
+  verbosity = options.verbose
+  if verbosity >= 3:
+    logging.getLogger().setLevel(logging.DEBUG)
+  elif verbosity >= 2:
+    logging.getLogger().setLevel(logging.INFO)
+  vcs = GuessVCS(options)
+  if isinstance(vcs, SubversionVCS):
+    # base field is only allowed for Subversion.
+    # Note: Fetching base files may become deprecated in future releases.
+    base = vcs.GuessBase(options.download_base)
+  else:
+    base = None
+  if not base and options.download_base:
+    options.download_base = True
+    logging.info("Enabled upload of base file")
+  if not options.assume_yes:
+    vcs.CheckForUnknownFiles()
+  if data is None:
+    data = vcs.GenerateDiff(args)
+  files = vcs.GetBaseFiles(data)
+  if verbosity >= 1:
+    print "Upload server:", options.server, "(change with -s/--server)"
+  if options.issue:
+    prompt = "Message describing this patch set: "
+  else:
+    prompt = "New issue subject: "
+  message = options.message or raw_input(prompt).strip()
+  if not message:
+    ErrorExit("A non-empty message is required")
+  rpc_server = GetRpcServer(options)
+  form_fields = [("subject", message)]
+  if base:
+    form_fields.append(("base", base))
+  if options.issue:
+    form_fields.append(("issue", str(options.issue)))
+  if options.email:
+    form_fields.append(("user", options.email))
+  if options.reviewers:
+    for reviewer in options.reviewers.split(','):
+      if "@" in reviewer and not reviewer.split("@")[1].count(".") == 1:
+        ErrorExit("Invalid email address: %s" % reviewer)
+    form_fields.append(("reviewers", options.reviewers))
+  if options.cc:
+    for cc in options.cc.split(','):
+      if "@" in cc and not cc.split("@")[1].count(".") == 1:
+        ErrorExit("Invalid email address: %s" % cc)
+    form_fields.append(("cc", options.cc))
+  description = options.description
+  if options.description_file:
+    if options.description:
+      ErrorExit("Can't specify description and description_file")
+    file = open(options.description_file, 'r')
+    description = file.read()
+    file.close()
+  if description:
+    form_fields.append(("description", description))
+  # Send a hash of all the base file so the server can determine if a copy
+  # already exists in an earlier patchset.
+  base_hashes = ""
+  for file, info in files.iteritems():
+    if not info[0] is None:
+      checksum = md5(info[0]).hexdigest()
+      if base_hashes:
+        base_hashes += "|"
+      base_hashes += checksum + ":" + file
+  form_fields.append(("base_hashes", base_hashes))
+  if options.private:
+    if options.issue:
+      print "Warning: Private flag ignored when updating an existing issue."
+    else:
+      form_fields.append(("private", "1"))
+  # If we're uploading base files, don't send the email before the uploads, so
+  # that it contains the file status.
+  if options.send_mail and options.download_base:
+    form_fields.append(("send_mail", "1"))
+  if not options.download_base:
+    form_fields.append(("content_upload", "1"))
+  if len(data) > MAX_UPLOAD_SIZE:
+    print "Patch is large, so uploading file patches separately."
+    uploaded_diff_file = []
+    form_fields.append(("separate_patches", "1"))
+  else:
+    uploaded_diff_file = [("data", "data.diff", data)]
+  ctype, body = EncodeMultipartFormData(form_fields, uploaded_diff_file)
+  response_body = rpc_server.Send("/upload", body, content_type=ctype)
+  patchset = None
+  if not options.download_base or not uploaded_diff_file:
+    lines = response_body.splitlines()
+    if len(lines) >= 2:
+      msg = lines[0]
+      patchset = lines[1].strip()
+      patches = [x.split(" ", 1) for x in lines[2:]]
+    else:
+      msg = response_body
+  else:
+    msg = response_body
+  StatusUpdate(msg)
+  if not response_body.startswith("Issue created.") and \
+  not response_body.startswith("Issue updated."):
+    sys.exit(0)
+  issue = msg[msg.rfind("/")+1:]
+
+  if not uploaded_diff_file:
+    result = UploadSeparatePatches(issue, rpc_server, patchset, data, options)
+    if not options.download_base:
+      patches = result
+
+  if not options.download_base:
+    vcs.UploadBaseFiles(issue, rpc_server, patches, patchset, options, files)
+    if options.send_mail:
+      rpc_server.Send("/" + issue + "/mail", payload="")
+  return issue, patchset
+
+
+def main():
+  try:
+    RealMain(sys.argv)
+  except KeyboardInterrupt:
+    print
+    StatusUpdate("Interrupted.")
+    sys.exit(1)
+