Retrieve bleeding edge push revision from trunk commit message.

tools/push-to-trunk/push_to_trunk.py

 #!/usr/bin/env python
 # Copyright 2013 the V8 project authors. All rights reserved.
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
 # met:
 #
 #     * Redistributions of source code must retain the above copyright
 #       notice, this list of conditions and the following disclaimer.
 #     * Redistributions in binary form must reproduce the above
 #       copyright notice, this list of conditions and the following
@@ skipping 33 matching lines @@
   TEMP_BRANCH: "prepare-push-temporary-branch-created-by-script",
   DOT_GIT_LOCATION: ".git",
   VERSION_FILE: "src/version.cc",
   CHANGELOG_FILE: "ChangeLog",
   CHANGELOG_ENTRY_FILE: "/tmp/v8-push-to-trunk-tempfile-changelog-entry",
   PATCH_FILE: "/tmp/v8-push-to-trunk-tempfile-patch-file",
   COMMITMSG_FILE: "/tmp/v8-push-to-trunk-tempfile-commitmsg",
   DEPS_FILE: "DEPS",
 }
 
+PUSH_MESSAGE_SUFFIX = " (based on bleeding_edge revision r%d)"
+PUSH_MESSAGE_RE = re.compile(r".* \(based on bleeding_edge revision r(\d+)\)$")
+
 
 class PushToTrunkOptions(CommonOptions):
   @staticmethod
   def MakeForcedOptions(author, reviewer, chrome_path):
     """Convenience wrapper."""
     class Options(object):
       pass
     options = Options()
     options.s = 0
     options.l = None
+    options.b = None

[Jakob Kummerow, 2014/02/19 12:44:49]

I hope it's on your to-do list to give all these guys readable (long) names :-)

[Michael Achenbach, 2014/02/19 13:23:03]

yap

     options.f = True
     options.m = False
     options.c = chrome_path
     options.a = author
     return PushToTrunkOptions(options)
 
   def __init__(self, options):
     super(PushToTrunkOptions, self).__init__(options, options.m)
     self.requires_editor = not options.f
     self.wait_for_lgtm = not options.f
     self.tbr_commit = not options.m
     self.l = options.l
     self.reviewer = options.reviewer
     self.c = options.c
+    self.b = getattr(options, 'b', None)

[Jakob Kummerow, 2014/02/19 12:44:49]

Instead of using getattr(), the default value should be set in the OptionParser.
Again, something for the to-do list.

[Michael Achenbach, 2014/02/19 13:23:03]

The whole option design will get a new face in a follow up CL.

     self.author = getattr(options, 'a', None)
 
 class Preparation(Step):
   MESSAGE = "Preparation."
 
   def RunStep(self):
     self.InitialEnvironmentChecks()
     self.CommonPrepare()
     self.PrepareBranch()
     self.DeleteBranch(self.Config(TRUNKBRANCH))
 
 
 class FreshBranch(Step):
   MESSAGE = "Create a fresh branch."
 
   def RunStep(self):
     args = "checkout -b %s svn/bleeding_edge" % self.Config(BRANCHNAME)
     if self.Git(args) is None:
       self.Die("Creating branch %s failed." % self.Config(BRANCHNAME))
 
 
 class DetectLastPush(Step):
   MESSAGE = "Detect commit ID of last push to trunk."
 
   def RunStep(self):
-    last_push = (self._options.l or
-                 self.Git("log -1 --format=%H ChangeLog").strip())
+    push_pattern = "^Version [[:digit:]]*\.[[:digit:]]*\.[[:digit:]]* (based"

[Jakob Kummerow, 2014/02/19 12:44:49]

For increased correctness, s/*/+/

[Michael Achenbach, 2014/02/19 13:23:03]

There's no + in grep. At least on my command-line, the same command doesn't work
with s/*/+/

+    args = "log -1 --format=%%H --grep=\"%s\" svn/trunk" % push_pattern
+    last_push_trunk = self._options.l or self.Git(args).strip()
     while True:
       # Print assumed commit, circumventing git's pager.
-      print self.Git("log -1 %s" % last_push)
+      print self.Git("log -1 %s" % last_push_trunk)
       if self.Confirm("Is the commit printed above the last push to trunk?"):
         break
-      args = "log -1 --format=%H %s^ ChangeLog" % last_push
-      last_push = self.Git(args).strip()
-    self.Persist("last_push", last_push)
-    self._state["last_push"] = last_push
+      args = ("log -1 --format=%H %s^ --grep=\"%s\""

[Jakob Kummerow, 2014/02/19 12:44:49]

s/%H/%%H/ like above? Why has this worked before? I guess it's never been
executed...

[Michael Achenbach, 2014/02/19 13:23:03]

Done.

+              % (last_push_trunk, push_pattern))
+      last_push_trunk = self.Git(args).strip()
+
+    if self._options.b:
+      # Read the bleeding edge revision of the last push from a command-line
+      # option.
+      last_push_bleeding_edge = self._options.b
+    else:
+      # Retrieve the bleeding edge revision of the last push from the text in
+      # the push commit message.
+      args = "log -1 --format=%%s %s" % last_push_trunk
+      last_push_trunk_title = self.Git(args).strip()
+      last_push_be_svn = PUSH_MESSAGE_RE.match(last_push_trunk_title).group(1)
+      if not last_push_be_svn:
+        self.Die("Could not retrieve bleeding edge revision for trunk push %s"
+                 % last_push_trunk)
+      args = "svn find-rev r%d" % int(last_push_be_svn)

[Jakob Kummerow, 2014/02/19 12:44:49]

"%d" % int(some_string) is the complicated way of saying "%s" % some_string, eh?

[Michael Achenbach, 2014/02/19 13:23:03]

Done.

+      last_push_bleeding_edge = self.Git(args).strip()
+      if not last_push_bleeding_edge:
+        self.Die("Could not retrieve bleeding edge git hash for trunk push %s"
+                 % last_push_trunk)
+
+    # TODO(machenbach): last_push_trunk points to the svn revision on trunk.
+    # It is not used yet but we'll need it for retrieving the current version.
+    self.Persist("last_push_trunk", last_push_trunk)
+    self._state["last_push_trunk"] = last_push_trunk
+    # TODO(machenbach): This currently points to the prepare push revision that
+    # will be deprecated soon. After the deprecation it will point to the last
+    # bleeding_edge revision that went into the last push.
+    self.Persist("last_push_bleeding_edge", last_push_bleeding_edge)
+    self._state["last_push_bleeding_edge"] = last_push_bleeding_edge
 
 
 class PrepareChangeLog(Step):
   MESSAGE = "Prepare raw ChangeLog entry."
 
   def Reload(self, body):
     """Attempts to reload the commit message from rietveld in order to allow
     late changes to the LOG flag. Note: This is brittle to future changes of
     the web page name or structure.
     """
     match = re.search(r"^Review URL: https://codereview\.chromium\.org/(\d+)$",
                       body, flags=re.M)
     if match:
       cl_url = "https://codereview.chromium.org/%s/description" % match.group(1)
       try:
         # Fetch from Rietveld but only retry once with one second delay since
         # there might be many revisions.
         body = self.ReadURL(cl_url, wait_plan=[1])
       except urllib2.URLError:
         pass
     return body
 
   def RunStep(self):
-    self.RestoreIfUnset("last_push")
+    self.RestoreIfUnset("last_push_bleeding_edge")
 
     # These version numbers are used again later for the trunk commit.
     self.ReadAndPersistVersion()
 
     date = self.GetDate()
     self.Persist("date", date)
     output = "%s: Version %s.%s.%s\n\n" % (date,
                                            self._state["major"],
                                            self._state["minor"],
                                            self._state["build"])
     TextToFile(output, self.Config(CHANGELOG_ENTRY_FILE))
 
-    args = "log %s..HEAD --format=%%H" % self._state["last_push"]
+    args = "log %s..HEAD --format=%%H" % self._state["last_push_bleeding_edge"]
     commits = self.Git(args).strip()
 
     # Cache raw commit messages.
     commit_messages = [
       [
         self.Git("log -1 %s --format=\"%%s\"" % commit),
         self.Reload(self.Git("log -1 %s --format=\"%%B\"" % commit)),
         self.Git("log -1 %s --format=\"%%an\"" % commit),
       ] for commit in commits.splitlines()
     ]
@@ skipping 133 matching lines @@
     text = FileToText(self.Config(CHANGELOG_ENTRY_FILE))
 
     # Remove date and trailing white space.
     text = re.sub(r"^%s: " % self._state["date"], "", text.rstrip())
 
     # Retrieve svn revision for showing the used bleeding edge revision in the
     # commit message.
     args = "svn find-rev %s" % self._state["prepare_commit_hash"]
     svn_revision = self.Git(args).strip()
     self.Persist("svn_revision", svn_revision)
-    text = MSub(r"^(Version \d+\.\d+\.\d+)$",
-                "\\1 (based on bleeding_edge revision r%s)" % svn_revision,
-                text)
+    suffix = PUSH_MESSAGE_SUFFIX % int(svn_revision)
+    text = MSub(r"^(Version \d+\.\d+\.\d+)$", "\\1%s" % suffix, text)
 
     # Remove indentation and merge paragraphs into single long lines, keeping
     # empty lines between them.
     def SplitMapJoin(split_text, fun, join_text):
       return lambda text: join_text.join(map(fun, text.split(split_text)))
     strip = lambda line: line.strip()
     text = SplitMapJoin("\n\n", SplitMapJoin("\n", strip, " "), "\n\n")(text)
 
     if not text:
       self.Die("Commit message editing failed.")
@@ skipping 253 matching lines @@
     CleanUp,
   ]
 
   RunScript(step_classes, config, options, side_effect_handler)
 
 
 def BuildOptions():
   result = optparse.OptionParser()
   result.add_option("-a", "--author", dest="a",
                     help=("Specify the author email used for rietveld."))
+  result.add_option("-b", "--last-bleeding-edge", dest="b",
+                    help=("Manually specify the git commit ID of the last "
+                          "bleeding edge revision that was pushed to trunk."))

[Jakob Kummerow, 2014/02/19 12:44:49]

For clarification, I'd add something like "This is used for the auto-generated
ChangeLog entry" (since the patch itself will be created between current trunk
and current bleeding_edge, as opposed to old and current bleeding_edge).

[Michael Achenbach, 2014/02/19 13:23:03]

Done.

   result.add_option("-c", "--chromium", dest="c",
                     help=("Specify the path to your Chromium src/ "
                           "directory to automate the V8 roll."))
   result.add_option("-f", "--force", dest="f",
                     help="Don't prompt the user.",
                     default=False, action="store_true")
   result.add_option("-l", "--last-push", dest="l",
                     help=("Manually specify the git commit ID "
                           "of the last push to trunk."))
   result.add_option("-m", "--manual", dest="m",
@@ skipping 29 matching lines @@
 def Main():
   parser = BuildOptions()
   (options, args) = parser.parse_args()
   if not ProcessOptions(options):
     parser.print_help()
     return 1
   RunPushToTrunk(CONFIG, PushToTrunkOptions(options))
 
 if __name__ == "__main__":
   sys.exit(Main())