Clean up release scripts.

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
+# This script retrieves the history of all V8 branches and
 # their corresponding Chromium revisions.
 
 # Requires a chromium checkout with branch heads:
 # gclient sync --with_branch_heads
 # gclient fetch
 
 import argparse
 import csv
 import itertools
 import json
@@ skipping 112 matching lines @@
     self.PrepareBranch()
 
 
 class RetrieveV8Releases(Step):
   MESSAGE = "Retrieve all V8 releases."
 
   def ExceedsMax(self, releases):
     return (self._options.max_releases > 0
             and len(releases) > self._options.max_releases)
 
-  def GetBleedingEdgeGitFromPush(self, title):
+  def GetMasterHashFromPush(self, title):
     return MatchSafe(PUSH_MSG_GIT_RE.match(title))
 
   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 GetMergedPatchesGit(self, body):
     patches = []
     for line in body.splitlines():
       patch = MatchSafe(MERGE_MESSAGE_GIT_RE.match(line))
       if patch:
         patches.append(patch)
       patch = MatchSafe(ROLLBACK_MESSAGE_GIT_RE.match(line))
       if patch:
         patches.append("-%s" % patch)
     return ", ".join(patches)
 
 
   def GetReleaseDict(
-      self, git_hash, bleeding_edge_rev, bleeding_edge_git, branch, version,
+      self, git_hash, master_position, master_hash, branch, version,
       patches, cl_body):
     revision = self.GetCommitPositionNumber(git_hash)
     return {
       # The cr commit position number on the branch.
       "revision": revision,
       # The git revision on the branch.
       "revision_git": git_hash,
       # The cr commit position number on master.
-      "bleeding_edge": bleeding_edge_rev,
+      "bleeding_edge": master_position,

[tandrii(chromium), 2015/01/26 14:31:14]

i guess, this key can't be changed :(

       # The same for git.
-      "bleeding_edge_git": bleeding_edge_git,
+      "bleeding_edge_git": master_hash,
       # 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.
+      # Link to the CL on code review. Candiates pushes are not uploaded,
+      # so this field will be populated below with the recent roll CL link.
       "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),
     }
 
   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"]
       if CHERRY_PICK_TITLE_GIT_RE.match(body.splitlines()[0]):
         patches = self.GetMergedPatchesGit(body)
       else:
         patches = self.GetMergedPatches(body)
 
     title = self.GitLog(n=1, format="%s", git_hash=git_hash)
-    bleeding_edge_git = self.GetBleedingEdgeGitFromPush(title)
-    bleeding_edge_position = ""
-    if bleeding_edge_git:
-      bleeding_edge_position = self.GetCommitPositionNumber(bleeding_edge_git)
+    master_hash = self.GetMasterHashFromPush(title)
+    master_position = ""
+    if master_hash:
+      master_position = self.GetCommitPositionNumber(master_hash)
     # TODO(machenbach): Add the commit position number.
     return self.GetReleaseDict(
-        git_hash, bleeding_edge_position, bleeding_edge_git, branch, version,
+        git_hash, master_position, master_hash, branch, version,
         patches, body), self["patch"]
 
   def GetReleasesFromMaster(self):
     # TODO(machenbach): Implement this in git as soon as we tag again on
     # master.
     # 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.vc.SvnGit(revision)
@@ skipping 35 matching lines @@
 
     # Clean up checked-out version file.
     self.GitCheckoutFileSafe(VERSION_FILE, "HEAD")
     return releases
 
   def RunStep(self):
     self.GitCreateBranch(self._config["BRANCHNAME"])
     branches = self.vc.GetBranches()
     releases = []
     if self._options.branch == 'recent':
-      # Get only recent development on trunk, beta and stable.
+      # Get only recent development on candidates, 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(self.vc.CandidateBranch())
       releases += self.GetReleasesFromBranch(self.vc.MasterBranch())
     elif self._options.branch == 'all':  # pragma: no cover
       # Retrieve the full release history.
       for branch in branches:
@@ skipping 82 matching lines @@
           if int(v8_rev) < oldest_v8_rev - 100:
             break  # pragma: no cover
 
     # Allow Ctrl-C interrupt.
     except (KeyboardInterrupt, SystemExit):  # pragma: no cover
       pass
 
     # Clean up.
     self.GitCheckoutFileSafe("DEPS", "HEAD", cwd=cwd)
 
-    # Add the chromium ranges to the v8 trunk and bleeding_edge releases.
+    # Add the chromium ranges to the v8 candidates and master releases.
     all_ranges = BuildRevisionRanges(cr_releases)
     releases_dict = dict((r["revision"], r) for r in releases)
     for revision, ranges in all_ranges.iteritems():
       releases_dict.get(revision, {})["chromium_revision"] = ranges
 
 
 # TODO(machenbach): Unify common code with method above.
 class RietrieveChromiumBranches(Step):
   MESSAGE = "Retrieve Chromium branch information."
 
   def RunStep(self):
     cwd = self._options.chromium
-    trunk_releases = filter(lambda r: r["branch"] == self.vc.CandidateBranch(),
-                            self["releases"])
-    if not trunk_releases:  # pragma: no cover
-      print "No trunk releases detected. Skipping chromium history."
+    cand_releases = filter(lambda r: r["branch"] == self.vc.CandidateBranch(),
+                           self["releases"])
+    if not cand_releases:  # pragma: no cover
+      print "No candidates releases detected. Skipping chromium history."
       return True
 
-    oldest_v8_rev = int(trunk_releases[-1]["revision"])
+    oldest_v8_rev = int(cand_releases[-1]["revision"])
 
     # Filter out irrelevant branches.
     branches = filter(lambda r: re.match(r"branch-heads/\d+", r),
                       self.GitRemotes(cwd=cwd))
 
     # Transform into pure branch numbers.
     branches = map(lambda r: int(re.match(r"branch-heads/(\d+)", r).group(1)),
                    branches)
 
     branches = sorted(branches, reverse=True)
@@ skipping 17 matching lines @@
           if int(v8_rev) < oldest_v8_rev - 100:
             break  # pragma: no cover
 
     # Allow Ctrl-C interrupt.
     except (KeyboardInterrupt, SystemExit):  # pragma: no cover
       pass
 
     # Clean up.
     self.GitCheckoutFileSafe("DEPS", "HEAD", cwd=cwd)
 
-    # Add the chromium branches to the v8 trunk releases.
+    # Add the chromium branches to the v8 candidate releases.
     all_ranges = BuildRevisionRanges(cr_branches)
-    trunk_dict = dict((r["revision"], r) for r in trunk_releases)
+    cand_dict = dict((r["revision"], r) for r in cand_releases)
     for revision, ranges in all_ranges.iteritems():
-      trunk_dict.get(revision, {})["chromium_branch"] = ranges
+      cand_dict.get(revision, {})["chromium_branch"] = ranges
 
 
 class CleanUp(Step):
   MESSAGE = "Clean up."
 
   def RunStep(self):
     self.GitCheckout("master", cwd=self._options.chromium)
     self.GitDeleteBranch(self.Config("BRANCHNAME"), cwd=self._options.chromium)
     self.CommonCleanup()
 
@@ skipping 16 matching lines @@
         f.write(json.dumps(self["releases"]))
     if not self._options.csv and not self._options.json:
       print self["releases"]  # pragma: no cover
 
 
 class Releases(ScriptsBase):
   def _PrepareOptions(self, parser):
     parser.add_argument("-b", "--branch", default="recent",
                         help=("The branch to analyze. If 'all' is specified, "
                               "analyze all branches. If 'recent' (default) "
-                              "is specified, track beta, stable and trunk."))
+                              "is specified, track beta, stable and "
+                              "candidates."))
     parser.add_argument("-c", "--chromium",
                         help=("The path to your Chromium src/ "
                               "directory to automate the V8 roll."))
     parser.add_argument("--csv", help="Path to a CSV file for export.")
     parser.add_argument("-m", "--max-releases", type=int, default=0,
                         help="The maximum number of releases to track.")
     parser.add_argument("--json", help="Path to a JSON file for export.")
 
   def _ProcessOptions(self, options):  # pragma: no cover
     return True
@@ skipping 12 matching lines @@
       UpdateChromiumCheckout,
       RetrieveChromiumV8Releases,
       RietrieveChromiumBranches,
       CleanUp,
       WriteOutput,
     ]
 
 
 if __name__ == "__main__":  # pragma: no cover
   sys.exit(Releases().Run())