Switch push-to-trunk to git mode.

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 16 matching lines @@
 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 import argparse
 import os
 import sys
 import tempfile
 import urllib2
 
 from common_includes import *
 
-PUSH_MESSAGE_SUFFIX = " (based on bleeding_edge revision r%d)"
-PUSH_MESSAGE_RE = re.compile(r".* \(based on bleeding_edge revision r(\d+)\)$")
+PUSH_MSG_SVN_RE = re.compile(r".* \(based on bleeding_edge revision r(\d+)\)$")
+PUSH_MSG_GIT_SUFFIX = " (based on %s)"
+PUSH_MSG_GIT_RE = re.compile(r".* \(based on (?P<git_rev>[a-fA-F0-9]+)\)$")
 
 class Preparation(Step):
   MESSAGE = "Preparation."
 
   def RunStep(self):
     self.InitialEnvironmentChecks(self.default_cwd)
     self.CommonPrepare()
 
     if(self["current_branch"] == self.Config("TRUNKBRANCH")
        or self["current_branch"] == self.Config("BRANCHNAME")):
       print "Warning: Script started on branch %s" % self["current_branch"]
 
     self.PrepareBranch()
     self.DeleteBranch(self.Config("TRUNKBRANCH"))
 
 
 class FreshBranch(Step):
   MESSAGE = "Create a fresh branch."
 
   def RunStep(self):
     self.GitCreateBranch(self.Config("BRANCHNAME"),
                          self.vc.RemoteMasterBranch())
 
 
 class PreparePushRevision(Step):
   MESSAGE = "Check which revision to push."
 
   def RunStep(self):
     if self._options.revision:
-      self["push_hash"] = self.vc.SvnGit(self._options.revision)
+      self["push_hash"] = self._options.revision
     else:
       self["push_hash"] = self.GitLog(n=1, format="%H", git_hash="HEAD")
     if not self["push_hash"]:  # pragma: no cover
       self.Die("Could not determine the git hash for the push.")
 
 
 class DetectLastPush(Step):
   MESSAGE = "Detect commit ID of last push to trunk."
 
   def RunStep(self):
     last_push = self._options.last_push or self.FindLastTrunkPush()
     while True:
       # Print assumed commit, circumventing git's pager.
       print self.GitLog(n=1, git_hash=last_push)
       if self.Confirm("Is the commit printed above the last push to trunk?"):
         break
       last_push = self.FindLastTrunkPush(parent_hash=last_push)
 
     if self._options.last_bleeding_edge:
       # Read the bleeding edge revision of the last push from a command-line
       # option.
       last_push_bleeding_edge = self._options.last_bleeding_edge
     else:
       # Retrieve the bleeding edge revision of the last push from the text in
       # the push commit message.
       last_push_title = self.GitLog(n=1, format="%s", git_hash=last_push)
-      last_push_be_svn = PUSH_MESSAGE_RE.match(last_push_title).group(1)
-      if not last_push_be_svn:  # pragma: no cover
-        self.Die("Could not retrieve bleeding edge revision for trunk push %s"
-                 % last_push)
-      last_push_bleeding_edge = self.vc.SvnGit(last_push_be_svn)
+      # TODO(machenbach): This is only needed for the git transition. Can be
+      # removed after one successful trunk push.
+      match = PUSH_MSG_SVN_RE.match(last_push_title)
+      if match:
+        last_push_be_svn = match.group(1)
+        if not last_push_be_svn:  # pragma: no cover
+          self.Die("Could not retrieve bleeding edge rev for trunk push %s"
+                   % last_push)
+        last_push_bleeding_edge = self.vc.SvnGit(last_push_be_svn)
+      else:
+        last_push_bleeding_edge = PUSH_MSG_GIT_RE.match(
+            last_push_title).group("git_rev")
+
       if not last_push_bleeding_edge:  # pragma: no cover
         self.Die("Could not retrieve bleeding edge git hash for trunk push %s"
                  % last_push)
 
-    # This points to the svn revision of the last push on trunk.
+    # This points to the git hash of the last push on trunk.
     self["last_push_trunk"] = last_push
     # This points to the last bleeding_edge revision that went into the last
     # push.
     # TODO(machenbach): Do we need a check to make sure we're not pushing a
     # revision older than the last push? If we do this, the output of the
     # current change log preparation won't make much sense.
     self["last_push_bleeding_edge"] = last_push_bleeding_edge
 
 
 # TODO(machenbach): Code similarities with bump_up_version.py. Merge after
@@ skipping 148 matching lines @@
     TextToFile(self.GitDiff(self.vc.RemoteCandidateBranch(),
                             self["push_hash"]),
                self.Config("PATCH_FILE"))
 
     # Convert the ChangeLog entry to commit message format.
     text = FileToText(self.Config("CHANGELOG_ENTRY_FILE"))
 
     # Remove date and trailing white space.
     text = re.sub(r"^%s: " % self["date"], "", text.rstrip())
 
-    # Retrieve svn revision for showing the used bleeding edge revision in the
-    # commit message.
-    self["svn_revision"] = self.vc.GitSvn(self["push_hash"])
-    suffix = PUSH_MESSAGE_SUFFIX % int(self["svn_revision"])
+    # Show the used master hash in the commit message.
+    suffix = PUSH_MSG_GIT_SUFFIX % self["push_hash"]
     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:  # pragma: no cover
@@ skipping 101 matching lines @@
     group.add_argument("-m", "--manual",
                       help="Prompt the user at every important step.",
                       default=False, action="store_true")
     parser.add_argument("-b", "--last-bleeding-edge",
                         help=("The git commit ID of the last bleeding edge "
                               "revision that was pushed to trunk. This is "
                               "used for the auto-generated ChangeLog entry."))
     parser.add_argument("-l", "--last-push",
                         help="The git commit ID of the last push to trunk.")
     parser.add_argument("-R", "--revision",
-                        help="The svn revision to push (defaults to HEAD).")
+                        help="The git commit ID to push (defaults to HEAD).")
 
   def _ProcessOptions(self, options):  # pragma: no cover
     if not options.manual and not options.reviewer:
       print "A reviewer (-r) is required in (semi-)automatic mode."
       return False
     if not options.manual and not options.author:
       print "Specify your chromium.org email with -a in (semi-)automatic mode."
       return False
-    if options.revision and not int(options.revision) > 0:
-      print("The --revision flag must be a positiv integer pointing to a "
-            "valid svn revision.")
-      return False
 
     options.tbr_commit = not options.manual
     return True
 
   def _Config(self):
     return {
       "BRANCHNAME": "prepare-push",
       "TRUNKBRANCH": "trunk-push",
       "PERSISTFILE_BASENAME": "/tmp/v8-push-to-trunk-tempfile",
       "CHANGELOG_FILE": "ChangeLog",
@@ skipping 21 matching lines @@
       CommitTrunk,
       SanityCheck,
       CommitSVN,
       TagRevision,
       CleanUp,
     ]
 
 
 if __name__ == "__main__":  # pragma: no cover
   sys.exit(PushToTrunk().Run())