Unify the version string to be displayed on "About Chromium" dialog.

build/util/lastchange.py

 #!/usr/bin/env python
 # Copyright (c) 2011 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """
 lastchange.py -- Chromium revision fetching utility.
 """
 
 import re
@@ skipping 84 matching lines @@
     a VersionInfo object or None on error.
   """
   proc = RunGitCommand(directory, ['rev-parse', 'HEAD'])
   if proc:
     output = proc.communicate()[0].strip()
     if proc.returncode == 0 and output:
       return VersionInfo('git', 'git', output[:7])
   return None
 
 
-def IsGitSVN(directory):
+def MatchGitSVNRevision(output):
   """
-  Checks whether git-svn has been set up.
-
-  Errors are swallowed.
-
-  Returns:
-    whether git-svn has been set up.
-  """
-  # To test whether git-svn has been set up, query the config for any
-  # svn-related configuration.  This command exits with an error code
-  # if there aren't any matches, so ignore its output.
-  proc = RunGitCommand(directory, ['config', '--get-regexp', '^svn'])
-  if proc:
-    return (proc.wait() == 0)
-  return False
-
-
-def FetchGitSVNURL(directory):
-  """
-  Fetch URL of SVN repository bound to git.
-
-  Errors are swallowed.
-
-  Returns:
-    SVN URL.
-  """
-  if IsGitSVN(directory):
-    proc = RunGitCommand(directory, ['svn', 'info', '--url'])
-    if proc:
-      output = proc.communicate()[0].strip()
-      if proc.returncode == 0:
-        match = re.search(r'^\w+://.*$', output, re.M)
-        if match:
-          return match.group(0)
-  return ''
-
-
-def FetchGitSVNRoot(directory):
-  """
-  Fetch root of SVN repository bound to git.
-
-  Errors are swallowed.
-
-  Returns:
-    SVN root repository.
-  """
-  if IsGitSVN(directory):
-    git_command = ['config', '--get-regexp', '^svn-remote.svn.url$']
-    proc = RunGitCommand(directory, git_command)
-    if proc:
-      output = proc.communicate()[0].strip()
-      if proc.returncode == 0:
-        # Zero return code implies presence of requested configuration variable.
-        # Its value is second (last) field of output.
-        match = re.search(r'\S+$', output)
-        if match:
-          return match.group(0)
-  return ''
-
-
-def LookupGitSVNRevision(directory, depth):
-  """
-  Fetch the Git-SVN identifier for the local tree.
-  Parses first |depth| commit messages.
+  Extract the latest SVN revision and the SVN URL.
 
   Errors are swallowed.
   """
-  if not IsGitSVN(directory):
-    return None
-  git_re = re.compile(r'^\s*git-svn-id:\s+(\S+)@(\d+)')
-  proc = RunGitCommand(directory, ['log', '-' + str(depth)])
-  if proc:
-    for line in proc.stdout:
-      match = git_re.match(line)
-      if match:
-        id = match.group(2)
-        if id:
-          proc.stdout.close()  # Cut pipe for fast exit.
-          return id
-  return None
+  # The target line is the last "git-svn-id: ..." line.
+  #
+  # git-svn-id: svn://svn.chromium.org/chrome/trunk/src@85528 0039d316...
+  match = re.search(r'([\s\S]*)git-svn-id:\s*([^@]*)@([0-9]+)', output)

[Denis Lagno, 2011/06/16 07:29:22]

nit: maybe replace ([\s\S]*) with .*

in my understanding \s\S is equivalent to .
and parentheses are not needed here because this group of symbols is not used.

[Denis Lagno, 2011/06/16 07:44:42]

oh, I see, dot does not match newline.  Probably using dot together with
re.DOTALL flag is still more clear than \s\S

[haraken1, 2011/06/16 08:28:09]

Done.

+  if match:
+    return (match.group(2), match.group(3))
+  return (None, None)
 
-
-def IsGitSVNDirty(directory):
+def FetchGitSVNRevision(directory):
   """
-  Checks whether our git-svn tree contains clean trunk or some branch.
+  Fetch the SVN revision for a given directory through Git.
 
   Errors are swallowed.
   """
-  # For git branches the last commit message is either
-  # some local commit or a merge.
-  return LookupGitSVNRevision(directory, 1) is None
+  proc = RunGitCommand(directory, ['log', '-1',
+                                   '--grep=git-svn-id', '--format=%b'])
+  if proc:
+    output = proc.communicate()[0].strip()
+    if proc.returncode == 0 and output:
+      # Extract the latest SVN revision and the SVN URL.
+      (url, revision) = MatchGitSVNRevision(output)
 
+      if url and revision:
+        # Check if there are any local changes.
+        dirty = True
+        proc = RunGitCommand(directory, ['log', '-1'])
+        if proc:
+          output = proc.communicate()[0].strip()
+          if proc.returncode == 0 and output:
+            # Check if there are any local commits.
+            (dummy_url, dummy_revision) = MatchGitSVNRevision(output)
 
-def FetchGitSVNRevision(directory):
-  """
-  Fetch the Git-SVN identifier for the local tree.
+            if dummy_url and dummy_revision:
+              # Check if there are any local uncommitted changes.
+              proc = RunGitCommand(directory, ['checkout'])
+              if proc:
+                output = proc.communicate()[0].strip()
+                if proc.returncode == 0 and not output:
+                  dirty = False
 
-  Errors are swallowed.
-  """
-  # We assume that at least first 999 commit messages contain svn evidence.
-  revision = LookupGitSVNRevision(directory, 999)
-  if not revision:
-    return None
-  if IsGitSVNDirty(directory):
-    revision = revision + '-dirty'
-  url = FetchGitSVNURL(directory)
-  root = FetchGitSVNRoot(directory)
-  return VersionInfo(url, root, revision)
+        if dirty:
+          revision = revision + "-dirty"
+        return VersionInfo(url, 'git-svn', revision)
+  return None
 
 
 def FetchVersionInfo(default_lastchange, directory=None):
   """
   Returns the last change (in the form of a branch, revision tuple),
   from some appropriate revision control system.
   """
   version_info = (FetchSVNRevision(directory) or
       FetchGitSVNRevision(directory) or FetchGitRevision(directory))
   if not version_info:
@@ skipping 53 matching lines @@
     if out_file:
       WriteIfChanged(out_file, contents)
     else:
       sys.stdout.write(contents)
 
   return 0
 
 
 if __name__ == '__main__':
   sys.exit(main())