| # 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 |
|