Refactoring: Extract low-level git from push and merge scripts.

tools/push-to-trunk/common_includes.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 18 matching lines @@
 import datetime
 import json
 import os
 import re
 import subprocess
 import sys
 import textwrap
 import time
 import urllib2
 
+from git_recipes import GitRecipesMixin
+
 PERSISTFILE_BASENAME = "PERSISTFILE_BASENAME"
 TEMP_BRANCH = "TEMP_BRANCH"
 BRANCHNAME = "BRANCHNAME"
 DOT_GIT_LOCATION = "DOT_GIT_LOCATION"
 VERSION_FILE = "VERSION_FILE"
 CHANGELOG_FILE = "CHANGELOG_FILE"
 CHANGELOG_ENTRY_FILE = "CHANGELOG_ENTRY_FILE"
 COMMITMSG_FILE = "COMMITMSG_FILE"
 PATCH_FILE = "PATCH_FILE"
 
@@ skipping 176 matching lines @@
 
 
 class CommonOptions(object):
   def __init__(self, options, manual=True):
     self.requires_editor = True
     self.wait_for_lgtm = True
     self.s = options.s
     self.force_readline_defaults = not manual
     self.force_upload = not manual
     self.manual = manual
-    self.reviewer = getattr(options, 'reviewer', None)
-    self.author = getattr(options, 'a', None)
+    self.reviewer = getattr(options, 'reviewer', "")
+    self.author = getattr(options, 'a', "")
 
 
-class Step(object):
+class Step(GitRecipesMixin):
   def __init__(self, text, requires, number, config, state, options, handler):
     self._text = text
     self._requires = requires
     self._number = number
     self._config = config
     self._state = state
     self._options = options
     self._side_effect_handler = handler
     assert self._number >= 0
     assert self._config is not None
@@ skipping 106 matching lines @@
     if not self._options.manual:
       msg = msg or "Only available in manual mode."
       self.Die(msg)
 
   def Confirm(self, msg):
     print "%s [Y/n] " % msg,
     answer = self.ReadLine(default="Y")
     return answer == "" or answer == "Y" or answer == "y"
 
   def DeleteBranch(self, name):
-    git_result = self.Git("branch").strip()
-    for line in git_result.splitlines():
+    for line in self.GitBranch().splitlines():
       if re.match(r".*\s+%s$" % name, line):
         msg = "Branch %s exists, do you want to delete it?" % name
         if self.Confirm(msg):
-          self.Git("branch -D %s" % name)
+          self.GitDeleteBranch(name)
           print "Branch %s deleted." % name
         else:
           msg = "Can't continue. Please delete branch %s and try again." % name
           self.Die(msg)
 
   def InitialEnvironmentChecks(self):
     # Cancel if this is not a git checkout.
     if not os.path.exists(self._config[DOT_GIT_LOCATION]):
       self.Die("This is not a git checkout, this script won't work for you.")
 
     # Cancel if EDITOR is unset or not executable.
     if (self._options.requires_editor and (not os.environ.get("EDITOR") or
         Command("which", os.environ["EDITOR"]) is None)):
       self.Die("Please set your EDITOR environment variable, you'll need it.")
 
   def CommonPrepare(self):
     # Check for a clean workdir.
-    if self.Git("status -s -uno").strip() != "":
+    if not self.GitIsWorkdirClean():
       self.Die("Workspace is not clean. Please commit or undo your changes.")
 
     # Persist current branch.
-    self["current_branch"] = ""
-    git_result = self.Git("status -s -b -uno").strip()
-    for line in git_result.splitlines():
-      match = re.match(r"^## (.+)", line)
-      if match:
-        self["current_branch"] = match.group(1)
-        break
+    self["current_branch"] = self.GitCurrentBranch()
 
     # Fetch unfetched revisions.
-    self.Git("svn fetch")
+    self.GitSVNFetch()
 
   def PrepareBranch(self):
     # Get ahold of a safe temporary branch and check it out.
     if self["current_branch"] != self._config[TEMP_BRANCH]:
       self.DeleteBranch(self._config[TEMP_BRANCH])
-      self.Git("checkout -b %s" % self._config[TEMP_BRANCH])
+      self.GitCreateBranch(self._config[TEMP_BRANCH])
 
     # Delete the branch that will be created later if it exists already.
     self.DeleteBranch(self._config[BRANCHNAME])
 
   def CommonCleanup(self):
-    self.Git("checkout -f %s" % self["current_branch"])
+    self.GitCheckout(self["current_branch"])
     if self._config[TEMP_BRANCH] != self["current_branch"]:
-      self.Git("branch -D %s" % self._config[TEMP_BRANCH])
+      self.GitDeleteBranch(self._config[TEMP_BRANCH])
     if self._config[BRANCHNAME] != self["current_branch"]:
-      self.Git("branch -D %s" % self._config[BRANCHNAME])
+      self.GitDeleteBranch(self._config[BRANCHNAME])
 
     # Clean up all temporary files.
     Command("rm", "-f %s*" % self._config[PERSISTFILE_BASENAME])
 
   def ReadAndPersistVersion(self, prefix=""):
     def ReadAndPersist(var_name, def_name):
       match = re.match(r"^#define %s\s+(\d*)" % def_name, line)
       if match:
         value = match.group(1)
         self["%s%s" % (prefix, var_name)] = value
@@ skipping 24 matching lines @@
     answer = ""
     while answer != "RESOLVED":
       if answer == "ABORT":
         self.Die("Applying the patch failed.")
       if answer != "":
         print "That was not 'RESOLVED' or 'ABORT'."
       print "> ",
       answer = self.ReadLine()
 
   # Takes a file containing the patch to apply as first argument.
-  def ApplyPatch(self, patch_file, reverse_patch=""):
-    args = "apply --index --reject %s \"%s\"" % (reverse_patch, patch_file)
+  def ApplyPatch(self, patch_file, revert=False):
     try:
-      self.Git(args)
+      self.GitApplyPatch(patch_file, revert)
     except GitFailedException:
       self.WaitForResolvingConflicts(patch_file)
 
-  def FindLastTrunkPush(self):
+  def FindLastTrunkPush(self, parent_hash=""):
     push_pattern = "^Version [[:digit:]]*\.[[:digit:]]*\.[[:digit:]]* (based"
-    args = "log -1 --format=%%H --grep=\"%s\" svn/trunk" % push_pattern
-    return self.Git(args).strip()
+    branch = "" if parent_hash else "svn/trunk"
+    return self.GitLog(n=1, format="%H", grep=push_pattern,
+                       parent_hash=parent_hash, branch=branch)
 
 
 class UploadStep(Step):
   MESSAGE = "Upload for code review."
 
   def RunStep(self):
     if self._options.reviewer:
       print "Using account %s for review." % self._options.reviewer
       reviewer = self._options.reviewer
     else:
       print "Please enter the email address of a V8 reviewer for your patch: ",
       self.DieNoManualMode("A reviewer must be specified in forced mode.")
       reviewer = self.ReadLine()
-    author_option = self._options.author
-    author = " --email \"%s\"" % author_option if author_option else ""
-    force_flag = " -f" if self._options.force_upload else ""
-    args = ("cl upload%s -r \"%s\" --send-mail%s"
-            % (author, reviewer, force_flag))
-    # TODO(machenbach): Check output in forced mode. Verify that all required
-    # base files were uploaded, if not retry.
-    self.Git(args, pipe=False)
+    self.GitUpload(reviewer, self._options.author, self._options.force_upload)
 
 
 def MakeStep(step_class=Step, number=0, state=None, config=None,
              options=None, side_effect_handler=DEFAULT_SIDE_EFFECT_HANDLER):
     # Allow to pass in empty dictionaries.
     state = state if state is not None else {}
     config = config if config is not None else {}
 
     try:
       message = step_class.MESSAGE
@@ skipping 17 matching lines @@
   if options.s == 0 and os.path.exists(state_file):
     os.remove(state_file)
   state = {}
   steps = []
   for (number, step_class) in enumerate(step_classes):
     steps.append(MakeStep(step_class, number, state, config,
                           options, side_effect_handler))
 
   for step in steps[options.s:]:
     step.Run()