Refactor version increment in release scripts.

tools/release/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 29 matching lines @@
 import textwrap
 import time
 import urllib
 import urllib2
 
 from git_recipes import GitRecipesMixin
 from git_recipes import GitFailedException
 
 CHANGELOG_FILE = "ChangeLog"
 VERSION_FILE = os.path.join("src", "version.cc")
+VERSION_RE = re.compile(r"^\d+\.\d+\.\d+(?:\.\d+)?$")
 
 # V8 base directory.
 V8_BASE = 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 313 matching lines @@
                         os.path.join(self._options.work_dir, "v8"))
 
     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 __getitem__(self, key):
     # Convenience method to allow direct [] access on step classes for
     # manipulating the backed state dict.
-    return self._state[key]
+    return self._state.get(key)

[tandrii(chromium), 2015/01/27 23:59:28]

Are you sure there were no code relying on KeyError being raised here before
this change?

 
   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):
@@ skipping 188 matching lines @@
       print "> ",
       answer = self.ReadLine()
 
   # Takes a file containing the patch to apply as first argument.
   def ApplyPatch(self, patch_file, revert=False):
     try:
       self.GitApplyPatch(patch_file, revert)
     except GitFailedException:
       self.WaitForResolvingConflicts(patch_file)
 
+  def GetLatestVersion(self):
+    # Use cached version if available.
+    if self["latest_version"]:
+      return self["latest_version"]
+
+    # Make sure tags are fetched.
+    self.Git("fetch origin +refs/tags/*:refs/tags/*")
+    version_parts = sorted(filter(VERSION_RE.match, self.vc.GetTags()),
+                           key=SortingKey, reverse=True)[0].split(".")
+    if len(version_parts) == 3:
+      version_parts.append("0")
+    self["latest_version"] = ".".join(version_parts)
+    return self["latest_version"]
+
   def FindLastCandidatesPush(
       self, parent_hash="", branch="", include_patches=False):
     push_pattern = "^Version [[:digit:]]*\.[[:digit:]]*\.[[:digit:]]*"
     if not include_patches:
       # Non-patched versions only have three numbers followed by the "(based
       # on...) comment."
       push_pattern += " (based"
     branch = "" if parent_hash else branch or self.vc.RemoteCandidateBranch()
     return self.GitLog(n=1, format="%H", grep=push_pattern,
                        parent_hash=parent_hash, branch=branch)
@@ skipping 202 matching lines @@
     for (number, step_class) in enumerate([BootstrapStep] + 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)