Pythonification and refactoring of push-to-trunk.

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 52 matching lines @@
 def FileToText(file_name):
   with open(file_name) as f:
     return f.read()
 
 
 def MSub(rexp, replacement, text):
   return re.sub(rexp, replacement, text, flags=re.MULTILINE)
 
 
 def Fill80(line):
+  # Replace tabs and remove surrounding space.
+  line = re.sub(r"\t", r"        ", line.strip())
+
+  # Format with 8 characters indentation and line width 80.
   return textwrap.fill(line, width=80, initial_indent="        ",
                        subsequent_indent="        ")
 
 
 def GetLastChangeLogEntries(change_log_file):
   result = []
   for line in LinesInFile(change_log_file):
     if re.search(r"^\d{4}-\d{2}-\d{2}:", line) and result: break
     result.append(line)
   return "".join(result)
 
 
 def MakeComment(text):
   return MSub(r"^( ?)", "#", text)
 
 
 def StripComments(text):
   # Use split not splitlines to keep terminal newlines.
   return "\n".join(filter(lambda x: not x.startswith("#"), text.split("\n")))
 
 
 def MakeChangeLogBody(commit_messages, auto_format=False):
   result = ""
   added_titles = set()
   for (title, body, author) in commit_messages:
     # TODO(machenbach): Reload the commit description from rietveld in order to
     # catch late changes.
-    title = title.rstrip()
+    title = title.strip()
     if auto_format:
       # Only add commits that set the LOG flag correctly.
       log_exp = r"^[ \t]*LOG[ \t]*=[ \t]*(?:Y(?:ES)?)|TRUE"
       if not re.search(log_exp, body, flags=re.I | re.M):
         continue
       # Never include reverts.
       if title.startswith("Revert "):
         continue
       # Don't include duplicates.
       if title in added_titles:
         continue
 
     # TODO(machenbach): Let python do all formatting. Get raw git title, attach
     # issue and add/move dot to the end - all in one line. Make formatting and
     # indentation afterwards.
 
     # Add the commit's title line.
-    result += "%s\n" % title
+    result += "%s\n" % Fill80(title)
     added_titles.add(title)
 
     # Add bug references.
     result += MakeChangeLogBugReference(body)
 
     # Append the commit's author for reference if not in auto-format mode.
     if not auto_format:
-      result += "%s\n" % author.rstrip()
+      result += "%s\n" % Fill80("(%s)" % author.strip())
 
     result += "\n"
   return result
 
 
 def MakeChangeLogBugReference(body):
   """Grep for "BUG=xxxx" lines in the commit message and convert them to
   "(issue xxxx)".
   """
   crbugs = []
@@ skipping 61 matching lines @@
     url_fh = urllib2.urlopen(url, None, 60)
     try:
       return url_fh.read()
     finally:
       url_fh.close()
 
 DEFAULT_SIDE_EFFECT_HANDLER = SideEffectHandler()
 
 
 class Step(object):
-  def __init__(self, text="", requires=None):
+  def __init__(self, text, requires, number, config, state, options, handler):
     self._text = text
-    self._number = -1
-    self._options = None
     self._requires = requires
-    self._side_effect_handler = DEFAULT_SIDE_EFFECT_HANDLER
-
-  def SetNumber(self, number):
     self._number = number
-
-  def SetConfig(self, config):
     self._config = config
-
-  def SetState(self, state):
     self._state = state
-
-  def SetOptions(self, options):
     self._options = options
-
-  def SetSideEffectHandler(self, handler):
     self._side_effect_handler = handler
+    assert self._number >= 0
+    assert self._config is not None
+    assert self._state is not None
+    assert self._side_effect_handler is not None
 
   def Config(self, key):
     return self._config[key]
 
   def Run(self):
-    assert self._number >= 0
-    assert self._config is not None
-    assert self._state is not None
-    assert self._side_effect_handler is not None
     if self._requires:
       self.RestoreIfUnset(self._requires)
       if not self._state[self._requires]:
         return
     print ">>> Step %d: %s" % (self._number, self._text)
     self.RunStep()
 
   def RunStep(self):
     raise NotImplementedError
 
@@ skipping 156 matching lines @@
       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)
     if self.Git(args) is None:
       self.WaitForResolvingConflicts(patch_file)
 
 
 class UploadStep(Step):
-  def __init__(self):
-    Step.__init__(self, "Upload for code review.")
+  MESSAGE = "Upload for code review."
 
   def RunStep(self):
     if self._options.r:
       print "Using account %s for review." % self._options.r
       reviewer = self._options.r
     else:
       print "Please enter the email address of a V8 reviewer for your patch: ",
       self.DieInForcedMode("A reviewer must be specified in forced mode.")
       reviewer = self.ReadLine()
     force_flag = " -f" if self._options.f else ""
     args = "cl upload -r \"%s\" --send-mail%s" % (reviewer, force_flag)
     # TODO(machenbach): Check output in forced mode. Verify that all required
     # base files were uploaded, if not retry.
     if self.Git(args, pipe=False) is None:
       self.Die("'git cl upload' failed, please try again.")
 
 
+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
+    except AttributeError:
+      message = step_class.__name__
+    try:
+      requires = step_class.REQUIRES
+    except AttributeError:
+      requires = None
+
+    return step_class(message, requires, number=number, config=config,
+                      state=state, options=options,
+                      handler=side_effect_handler)
+
+
 def RunScript(step_classes,
               config,
               options,
               side_effect_handler=DEFAULT_SIDE_EFFECT_HANDLER):
   state = {}
   steps = []
-  number = 0
-
-  for step_class in step_classes:
-    # TODO(machenbach): Factory methods.
-    step = step_class()
-    step.SetNumber(number)
-    step.SetConfig(config)
-    step.SetOptions(options)
-    step.SetState(state)
-    step.SetSideEffectHandler(side_effect_handler)
-    steps.append(step)
-    number += 1
+  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()