[Release] Make release scripts aware of packed tags

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 32 matching lines @@
 import urllib2
 
 from git_recipes import GitRecipesMixin
 from git_recipes import GitFailedException
 
 CHANGELOG_FILE = "ChangeLog"
 DAY_IN_SECONDS = 24 * 60 * 60
 PUSH_MSG_GIT_RE = re.compile(r".* \(based on (?P<git_rev>[a-fA-F0-9]+)\)$")
 PUSH_MSG_NEW_RE = re.compile(r"^Version \d+\.\d+\.\d+$")
 VERSION_FILE = os.path.join("include", "v8-version.h")
-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 135 matching lines @@
       return subprocess.check_output(cmd_line, shell=True, cwd=cwd)
     else:
       return subprocess.check_call(cmd_line, shell=True, cwd=cwd)
   except subprocess.CalledProcessError:
     return None
   finally:
     sys.stdout.flush()
     sys.stderr.flush()
 
 
+def SanitizeVersionTag(tag):
+    version_without_prefix = re.compile(r"^\d+\.\d+\.\d+(?:\.\d+)?$")
+    version_with_prefix = re.compile(r"^tags\/\d+\.\d+\.\d+(?:\.\d+)?$")
+
+    if version_without_prefix.match(tag):
+      return tag
+    elif version_with_prefix.match(tag):
+        return tag[len("tags/"):]
+    else:
+      return None
+
+
+def NormalizeVersionTags(version_tags):
+  normalized_version_tags = []
+
+  # Remove tags/ prefix because of packed refs.
+  for current_tag in version_tags:
+    version_tag = SanitizeVersionTag(current_tag)
+    if version_tag != None:
+      normalized_version_tags.append(version_tag)
+
+  return normalized_version_tags
+
+
 # Wrapper for side effects.
 class SideEffectHandler(object):  # pragma: no cover
   def Call(self, fun, *args, **kwargs):
     return fun(*args, **kwargs)
 
   def Command(self, cmd, args="", prefix="", pipe=True, cwd=None):
     return Command(cmd, args, prefix, pipe, cwd=cwd)
 
   def ReadLine(self):
     return sys.stdin.readline().strip()
@@ skipping 381 matching lines @@
 
   # 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 GetVersionTag(self, revision):
     tag = self.Git("describe --tags %s" % revision).strip()
-    if VERSION_RE.match(tag):
-      return tag
-    else:
-      return None
+    return SanitizeVersionTag(tag)
 
   def GetRecentReleases(self, max_age):
     # Make sure tags are fetched.
     self.Git("fetch origin +refs/tags/*:refs/tags/*")
 
     # Current timestamp.
     time_now = int(self._side_effect_handler.GetUTCStamp())
 
     # List every tag from a given period.
     revisions = self.Git("rev-list --max-age=%d --tags" %
                          int(time_now - max_age)).strip()
 
     # Filter out revisions who's tag is off by one or more commits.
     return filter(lambda r: self.GetVersionTag(r), revisions.splitlines())
 
   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 = sorted(filter(VERSION_RE.match, self.vc.GetTags()),
+
+    all_tags = self.vc.GetTags()
+    only_version_tags = NormalizeVersionTags(all_tags)
+
+    version = sorted(only_version_tags,
                      key=SortingKey, reverse=True)[0]
     self["latest_version"] = version
     return version
 
   def GetLatestRelease(self):
     """The latest release is the git hash of the latest tagged version.
 
     This revision should be rolled into chromium.
     """
     latest_version = self.GetLatestVersion()
@@ skipping 225 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)