Refactoring: Remove global configs in release 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 27 matching lines @@
 import subprocess
 import sys
 import textwrap
 import time
 import urllib
 import urllib2
 
 from git_recipes import GitRecipesMixin
 from git_recipes import GitFailedException
 
-PERSISTFILE_BASENAME = "PERSISTFILE_BASENAME"
-BRANCHNAME = "BRANCHNAME"
-CHANGELOG_FILE = "CHANGELOG_FILE"
-CHANGELOG_ENTRY_FILE = "CHANGELOG_ENTRY_FILE"
-COMMITMSG_FILE = "COMMITMSG_FILE"
-PATCH_FILE = "PATCH_FILE"
-
 VERSION_FILE = os.path.join("src", "version.cc")
 
 # V8 base directory.
 DEFAULT_CWD = os.path.dirname(
     os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 
 
 def TextToFile(text, file_name):
   with open(file_name, "w") as f:
     f.write(text)
@@ skipping 222 matching lines @@
   def __setitem__(self, key, value):
     # Convenience method to allow direct [] access on step classes for
     # manipulating the backed state dict.
     self._state[key] = value
 
   def Config(self, key):
     return self._config[key]
 
   def Run(self):
     # Restore state.
-    state_file = "%s-state.json" % self._config[PERSISTFILE_BASENAME]
+    state_file = "%s-state.json" % self._config["PERSISTFILE_BASENAME"]
     if not self._state and os.path.exists(state_file):
       self._state.update(json.loads(FileToText(state_file)))
 
     print ">>> Step %d: %s" % (self._number, self._text)
     try:
       return self.RunStep()
     finally:
       # Persist state.
       TextToFile(json.dumps(self._state), state_file)
 
@@ skipping 118 matching lines @@
       self.Die("Workspace is not clean. Please commit or undo your changes.")
 
     # Persist current branch.
     self["current_branch"] = self.GitCurrentBranch()
 
     # Fetch unfetched revisions.
     self.GitSVNFetch()
 
   def PrepareBranch(self):
     # Delete the branch that will be created later if it exists already.
-    self.DeleteBranch(self._config[BRANCHNAME])
+    self.DeleteBranch(self._config["BRANCHNAME"])
 
   def CommonCleanup(self):
     self.GitCheckout(self["current_branch"])
-    if self._config[BRANCHNAME] != self["current_branch"]:
-      self.GitDeleteBranch(self._config[BRANCHNAME])
+    if self._config["BRANCHNAME"] != self["current_branch"]:
+      self.GitDeleteBranch(self._config["BRANCHNAME"])
 
     # Clean up all temporary files.
-    for f in glob.iglob("%s*" % self._config[PERSISTFILE_BASENAME]):
+    for f in glob.iglob("%s*" % self._config["PERSISTFILE_BASENAME"]):
       if os.path.isfile(f):
         os.remove(f)
       if os.path.isdir(f):
         shutil.rmtree(f)
 
   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)
@@ skipping 64 matching lines @@
         line = re.sub("\d+$", self[prefix + "minor"], line)
       elif line.startswith("#define BUILD_NUMBER"):
         line = re.sub("\d+$", self[prefix + "build"], line)
       elif line.startswith("#define PATCH_LEVEL"):
         line = re.sub("\d+$", self[prefix + "patch"], line)
       output += "%s\n" % line
     TextToFile(output, version_file)
 
   def SVNCommit(self, root, commit_message):
     patch = self.GitDiff("HEAD^", "HEAD")
-    TextToFile(patch, self._config[PATCH_FILE])
+    TextToFile(patch, self._config["PATCH_FILE"])
     self.Command("svn", "update", cwd=self._options.svn)
     if self.Command("svn", "status", cwd=self._options.svn) != "":
       self.Die("SVN checkout not clean.")
     if not self.Command("patch", "-d %s -p1 -i %s" %
-                        (root, self._config[PATCH_FILE]),
+                        (root, self._config["PATCH_FILE"]),
                         cwd=self._options.svn):
       self.Die("Could not apply patch.")
     self.Command(
         "svn",
         "commit --non-interactive --username=%s --config-dir=%s -m \"%s\"" %
             (self._options.author, self._options.svn_config, commit_message),
         cwd=self._options.svn)
 
 
 class UploadStep(Step):
@@ skipping 55 matching lines @@
       message = step_class.MESSAGE
     except AttributeError:
       message = step_class.__name__
 
     return step_class(message, number=number, config=config,
                       state=state, options=options,
                       handler=side_effect_handler)
 
 
 class ScriptsBase(object):
   # TODO(machenbach): Move static config here.

[tandrii(chromium), 2014/09/23 14:45:25]

Is this still TODO?

[Michael Achenbach, 2014/09/25 08:17:41]

Ups no. This is exactly what the todo was about... will clean up in a follow up.

-  def __init__(self, config, side_effect_handler=DEFAULT_SIDE_EFFECT_HANDLER,
+  def __init__(self,
+               config=None,
+               side_effect_handler=DEFAULT_SIDE_EFFECT_HANDLER,
                state=None):
-    self._config = config
+    self._config = config or self._Config()
     self._side_effect_handler = side_effect_handler
     self._state = state if state is not None else {}
 
   def _Description(self):
     return None
 
   def _PrepareOptions(self, parser):
     pass
 
   def _ProcessOptions(self, options):
     return True
 
   def _Steps(self):  # pragma: no cover
     raise Exception("Not implemented.")
 
+  def _Config(self):
+    return {}
+
   def MakeOptions(self, args=None):
     parser = argparse.ArgumentParser(description=self._Description())
     parser.add_argument("-a", "--author", default="",
                         help="The author email used for rietveld.")
     parser.add_argument("--dry-run", default=False, action="store_true",
                         help="Perform only read-only actions.")
     parser.add_argument("-g", "--googlers-mapping",
                         help="Path to the script mapping google accounts.")
     parser.add_argument("-r", "--reviewer", default="",
                         help="The account name to be used for reviews.")
@@ skipping 45 matching lines @@
     if not self._ProcessOptions(options):
       parser.print_help()
       return None
     return options
 
   def RunSteps(self, step_classes, args=None):
     options = self.MakeOptions(args)
     if not options:
       return 1
 
-    state_file = "%s-state.json" % self._config[PERSISTFILE_BASENAME]
+    state_file = "%s-state.json" % self._config["PERSISTFILE_BASENAME"]
     if options.step == 0 and os.path.exists(state_file):
       os.remove(state_file)
 
     steps = []
     for (number, step_class) in enumerate(step_classes):
       steps.append(MakeStep(step_class, number, self._state, self._config,
                             options, self._side_effect_handler))
     for step in steps[options.step:]:
       if step.Run():
         return 0
     return 0
 
   def Run(self, args=None):
     return self.RunSteps(self._Steps(), args)