Teach releases script to read bleeding_edge tags.

tools/push-to-trunk/releases.py

 #!/usr/bin/env python
 # Copyright 2014 the V8 project authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 # This script retrieves the history of all V8 branches and trunk revisions and
 # their corresponding Chromium revisions.
 
 # Requires a chromium checkout with branch heads:
 # gclient sync --with_branch_heads
@@ skipping 34 matching lines @@
 # Expression for retrieving the code review link.
 REVIEW_LINK_RE = re.compile(r"^Review URL: (.+)$", re.M)
 
 # Expression with three versions (historical) for extracting the v8 revision
 # from the chromium DEPS file.
 DEPS_RE = re.compile(r'^\s*(?:"v8_revision": "'
                       '|\(Var\("googlecode_url"\) % "v8"\) \+ "\/trunk@'
                       '|"http\:\/\/v8\.googlecode\.com\/svn\/trunk@)'
                       '([0-9]+)".*$', re.M)
 
+# Expression to pick tag and revision for bleeding edge tags. To be used with
+# output of 'svn log'.
+BLEEDING_EDGE_TAGS_RE = re.compile(
+    r"A \/tags\/([^\s]+) \(from \/branches\/bleeding_edge\:(\d+)\)")
+
 
 def SortBranches(branches):
   """Sort branches with version number names."""
   return sorted(branches, key=SortingKey, reverse=True)
 
 
 def FilterDuplicatesAndReverse(cr_releases):
   """Returns the chromium releases in reverse order filtered by v8 revision
   duplicates.
 
@@ skipping 68 matching lines @@
 
   def GetMergedPatches(self, body):
     patches = MatchSafe(MERGE_MESSAGE_RE.search(body))
     if not patches:
       patches = MatchSafe(ROLLBACK_MESSAGE_RE.search(body))
       if patches:
         # Indicate reverted patches with a "-".
         patches = "-%s" % patches
     return patches
 
-  def GetRelease(self, git_hash, branch):
-    self.ReadAndPersistVersion()
-    base_version = [self["major"], self["minor"], self["build"]]
-    version = ".".join(base_version)
-    body = self.GitLog(n=1, format="%B", git_hash=git_hash)
-
-    patches = ""
-    if self["patch"] != "0":
-      version += ".%s" % self["patch"]
-      patches = self.GetMergedPatches(body)
-
-    title = self.GitLog(n=1, format="%s", git_hash=git_hash)
+  def GetReleaseDict(
+      self, git_hash, bleeding_edge_rev, branch, version, patches, cl_body):
     revision = self.GitSVNFindSVNRev(git_hash)
     return {

[Michael Achenbach, 2014/07/28 12:56:35]

Small refactoring. I move the dict creation to a separate method for reuse.
Otherwise GetRelease doesn't change (codereview is a bit confuse).

       # The SVN revision on the branch.
       "revision": revision,
       # The SVN revision on bleeding edge (only for newer trunk pushes).
-      "bleeding_edge": self.GetBleedingEdgeFromPush(title),
+      "bleeding_edge": bleeding_edge_rev,
       # The branch name.
       "branch": branch,
       # The version for displaying in the form 3.26.3 or 3.26.3.12.
       "version": version,
       # The date of the commit.
       "date": self.GitLog(n=1, format="%ci", git_hash=git_hash),
       # Merged patches if available in the form 'r1234, r2345'.
       "patches_merged": patches,
       # Default for easier output formatting.
       "chromium_revision": "",
       # Default for easier output formatting.
       "chromium_branch": "",
       # Link to the CL on code review. Trunk pushes are not uploaded, so this
       # field will be populated below with the recent roll CL link.
-      "review_link": MatchSafe(REVIEW_LINK_RE.search(body)),
+      "review_link": MatchSafe(REVIEW_LINK_RE.search(cl_body)),
       # Link to the commit message on google code.
       "revision_link": ("https://code.google.com/p/v8/source/detail?r=%s"
                         % revision),
-    }, self["patch"]
+    }
+
+  def GetRelease(self, git_hash, branch):
+    self.ReadAndPersistVersion()
+    base_version = [self["major"], self["minor"], self["build"]]
+    version = ".".join(base_version)
+    body = self.GitLog(n=1, format="%B", git_hash=git_hash)
+
+    patches = ""
+    if self["patch"] != "0":
+      version += ".%s" % self["patch"]
+      patches = self.GetMergedPatches(body)
+
+    title = self.GitLog(n=1, format="%s", git_hash=git_hash)
+    return self.GetReleaseDict(
+        git_hash, self.GetBleedingEdgeFromPush(title), branch, version,
+        patches, body), self["patch"]
+
+  def GetReleasesFromBleedingEdge(self):
+    tag_text = self.SVN("log https://v8.googlecode.com/svn/tags -v --limit 20")
+    releases = []
+    for (tag, revision) in re.findall(BLEEDING_EDGE_TAGS_RE, tag_text):
+      git_hash = self.GitSVNFindGitHash(revision)
+
+      # Add bleeding edge release. It does not contain patches or a code
+      # review link, as tags are not uploaded.
+      releases.append(self.GetReleaseDict(
+        git_hash, revision, "bleeding_edge", tag, "", ""))
+    return releases
 
   def GetReleasesFromBranch(self, branch):
     self.GitReset("svn/%s" % branch)
+    if branch == 'bleeding_edge':
+      return self.GetReleasesFromBleedingEdge()
+
     releases = []
     try:
       for git_hash in self.GitLog(format="%H").splitlines():
         if self._config[VERSION_FILE] not in self.GitChangedFiles(git_hash):
           continue
         if self.ExceedsMax(releases):
           break  # pragma: no cover
         if not self.GitCheckoutFileSafe(self._config[VERSION_FILE], git_hash):
           break  # pragma: no cover
 
@@ skipping 25 matching lines @@
 
     releases = []
     if self._options.branch == 'recent':
       # Get only recent development on trunk, beta and stable.
       if self._options.max_releases == 0:  # pragma: no cover
         self._options.max_releases = 10
       beta, stable = SortBranches(branches)[0:2]
       releases += self.GetReleasesFromBranch(stable)
       releases += self.GetReleasesFromBranch(beta)
       releases += self.GetReleasesFromBranch("trunk")
+      releases += self.GetReleasesFromBranch("bleeding_edge")
     elif self._options.branch == 'all':  # pragma: no cover
       # Retrieve the full release history.
       for branch in branches:
         releases += self.GetReleasesFromBranch(branch)
       releases += self.GetReleasesFromBranch("trunk")
+      releases += self.GetReleasesFromBranch("bleeding_edge")
     else:  # pragma: no cover
       # Retrieve history for a specified branch.
-      assert self._options.branch in branches + ["trunk"]
+      assert self._options.branch in branches + ["trunk", "bleeding_edge"]
       releases += self.GetReleasesFromBranch(self._options.branch)
 
     self["releases"] = sorted(releases,
                               key=lambda r: SortingKey(r["version"]),
                               reverse=True)
 
 
 # TODO(machenbach): Parts of the Chromium setup are c/p from the chromium_roll
 # script -> unify.
 class CheckChromium(Step):
@@ skipping 198 matching lines @@
       RetrieveChromiumV8Releases,
       RietrieveChromiumBranches,
       SwitchV8,
       CleanUp,
       WriteOutput,
     ]
 
 
 if __name__ == "__main__":  # pragma: no cover
   sys.exit(Releases(CONFIG).Run())