code review 3989059: codereviwe: make hgpatch working on win32

lib/codereview/codereview.py

 # coding=utf-8
 # (The line above is necessary so that I can use 世界 in the
 # *comment* below without Python getting all bent out of shape.)
 
 # Copyright 2007-2009 Google Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
 #
@@ skipping 235 matching lines @@
                 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"
                 typecheck(s, str)
                 return s
 
         def Flush(self, ui, repo):
                 if self.name == "new":
-                        self.Upload(ui, repo, gofmt_just_warn=True)
+                        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))
 
         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):
-                if not self.files:
+        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", ""),
-                        # Would prefer not to change the subject
-                        # on reupload, but /upload requires it.
-                        ("subject", self.Subject()),
                 ]
 
                 if self.name != "new":
                         form_fields.append(("issue", self.name))
                 vcs = None
-                if self.files:
+                # 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 + " " + getremote(ui, repo, {}).path))
+                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:]]
-                ui.status(msg + "\n")
+                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 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):
+        def Mail(self, ui, repo):
                 pmsg = "Hello " + JoinComma(self.reviewer)
                 if self.cc:
                         pmsg += " (cc: %s)" % (', '.join(self.cc),)
                 pmsg += ",\n"
                 pmsg += "\n"
+                repourl = getremote(ui, repo, {}).path
                 if not self.mailed:
-                        pmsg += "I'd like you to review this change.\n"
+                        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)
@@ skipping 712 matching lines @@
 
         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 name == "new":
                 if ui.quiet:
                         ui.write(cl.name)
                 else:
                         ui.write("CL created: " + cl.url + "\n")
         return
 
@@ skipping 25 matching lines @@
         argv = ["hgpatch"]
         if opts["no_incoming"]:
                 argv += ["--checksync=false"]
         if err != "":
                 return err
         try:
                 cmd = subprocess.Popen(argv, shell=False, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=None, close_fds=sys.platform != "win32")
         except:
                 return "hgpatch: " + ExceptionDetail()
 
-        if sys.platform == "win32":
-                cmd.stdin.write(patch)
-                cmd.stdin.flush()
-        else:
-                if os.fork() == 0:
-                        cmd.stdin.write(patch)
-                        os._exit(0)
+        cmd.stdin.write(patch)
         cmd.stdin.close()
         out = cmd.stdout.read()
         if cmd.wait() != 0 and not opts["ignore_hgpatch_failure"]:
                 return "hgpatch failed"
         cl.local = True
         cl.files = out.strip().split()
         files = ChangedFiles(ui, repo, [], opts)
         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")
@@ skipping 1773 matching lines @@
                 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