Add comment with svn revision number.

roll_dep.py

 #!/usr/bin/env python
 # Copyright (c) 2014 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.
 
 """This scripts takes the path to a dep and an svn revision, and updates the
 parent repo's DEPS file with the corresponding git revision.  Sample invocation:
 
 [chromium/src]$ roll-dep third_party/WebKit 12345
 
 After the script completes, the DEPS file will be dirty with the new revision.
 The user can then:
 
 $ git add DEPS
 $ git commit
 """
 
 import ast
 import os
 import re
 import sys
 
 from itertools import izip
 from subprocess import Popen, PIPE
 from textwrap import dedent
 
 
+SHA1_RE = re.compile('^[a-fA-F0-9]{40}$')
+GIT_SVN_ID_RE = re.compile('^git-svn-id: .*@([0-9]+) .*$')
+
+
 def posix_path(path):
   """Convert a possibly-Windows path to a posix-style path."""
-  return re.sub('^[A-Z]:', '', path.replace(os.sep, '/'))
+  (_, path) = os.path.splitdrive(path)
+  return path.replace(os.sep, '/')
 
 
 def platform_path(path):
   """Convert a path to the native path format of the host OS."""
   return path.replace('/', os.sep)
 
 
 def find_gclient_root():
   """Find the directory containing the .gclient file."""
   cwd = posix_path(os.getcwd())
@@ skipping 19 matching lines @@
         cwd.startswith(os.path.join(gclient_root, soln_relpath))):
       return soln
   assert False, 'Could not determine the parent project for %s' % dep_path
 
 
 def verify_git_revision(dep_path, revision):
   """Verify that a git revision exists in a repository."""
   p = Popen(['git', 'rev-list', '-n', '1', revision],
             cwd=dep_path, stdout=PIPE, stderr=PIPE)
   result = p.communicate()[0].strip()
-  if p.returncode != 0 or not re.match('^[a-fA-F0-9]{40}$', result):
+  if p.returncode != 0 or not SHA1_RE.match(result):
     result = None
   return result
 
 
+def get_svn_revision(dep_path, git_revision):
+  """Given a git revision, return the corresponding svn revision."""
+  p = Popen(['git', 'log', '-n', '1', '--pretty=format:%B', git_revision],
+            stdout=PIPE, cwd=dep_path)
+  (log, _) = p.communicate()
+  assert p.returncode == 0, 'git log %s failed.' % git_revision
+  for line in reversed(log.splitlines()):
+    m = GIT_SVN_ID_RE.match(line.strip())
+    if m:
+      return m.group(1)
+  return None
+
+
 def convert_svn_revision(dep_path, revision):
   """Find the git revision corresponding to an svn revision."""
   err_msg = 'Unknown error'
   revision = int(revision)
   with open(os.devnull, 'w') as devnull:
     for ref in ('HEAD', 'origin/master'):
       try:
         log_p = Popen(['git', 'log', ref],
                       cwd=dep_path, stdout=PIPE, stderr=devnull)
         grep_p = Popen(['grep', '-e', '^commit ', '-e', '^ *git-svn-id: '],
@@ skipping 23 matching lines @@
                 'latest available revision is %d; you may need to '
                 '"git fetch origin" to get the latest commits.' % svn_rev)
       finally:
         log_p.terminate()
         grep_p.terminate()
   raise RuntimeError('No match for revision %d; %s' % (revision, err_msg))
 
 
 def get_git_revision(dep_path, revision):
   """Convert the revision argument passed to the script to a git revision."""
+  svn_revision = None
   if revision.startswith('r'):
-    result = convert_svn_revision(dep_path, revision[1:])
+    git_revision = convert_svn_revision(dep_path, revision[1:])
+    svn_revision = revision[1:]
   elif re.search('[a-fA-F]', revision):
-    result = verify_git_revision(dep_path, revision)
+    git_revision = verify_git_revision(dep_path, revision)
+    svn_revision = get_svn_revision(dep_path, git_revision)
   elif len(revision) > 6:
-    result = verify_git_revision(dep_path, revision)
-    if not result:
-      result = convert_svn_revision(dep_path, revision)
+    git_revision = verify_git_revision(dep_path, revision)
+    if git_revision:
+      svn_revision = get_svn_revision(dep_path, git_revision)
+    else:
+      git_revision = convert_svn_revision(dep_path, revision)
+      svn_revision = revision
   else:
     try:
-      result = convert_svn_revision(dep_path, revision)
+      git_revision = convert_svn_revision(dep_path, revision)
+      svn_revision = revision
     except RuntimeError:
-      result = verify_git_revision(dep_path, revision)
-      if not result:
+      git_revision = verify_git_revision(dep_path, revision)
+      if not git_revision:
         raise
-  return result
+      svn_revision = get_svn_revision(dep_path, git_revision)
+  return git_revision, svn_revision
 
 
 def ast_err_msg(node):
   return 'ERROR: Undexpected DEPS file AST structure at line %d column %d' % (
       node.lineno, node.col_offset)
 
 
 def find_deps_section(deps_ast, section):
   """Find a top-level section of the DEPS file in the AST."""
   try:
@@ skipping 35 matching lines @@
   line = deps_lines[line_idx]
   (prefix, sep, old_rev) = string_node.s.partition('@')
   if sep:
     start_idx = line.find(prefix + sep, start_idx) + len(prefix + sep)
     tail_idx = start_idx + len(old_rev)
   else:
     start_idx = line.find(prefix, start_idx)
     tail_idx = start_idx + len(prefix)
     old_rev = prefix
   deps_lines[line_idx] = line[:start_idx] + git_revision + line[tail_idx:]
-  return old_rev
+  return line_idx
 
 
 def update_binop(deps_lines, deps_ast, binop_node, git_revision):
   """Update a binary operation node in the AST with the new git revision."""
   # Since the revision part is always last, assume that it's the right-hand
   # operand that needs to be updated.
   return update_node(deps_lines, deps_ast, binop_node.right, git_revision)
 
 
 def update_call(deps_lines, deps_ast, call_node, git_revision):
@@ skipping 22 matching lines @@
   if url.endswith('.git'):
     url = url[:-4]
   url += '/+log/%s..%s' % (old_rev[:12], new_rev[:12])
   return dedent('''\
       Rolled %s
           from revision %s
           to revision %s
       Summary of changes available at:
           %s\n''' % (dep_name, old_rev, new_rev, url))
 
-def update_deps(soln_path, dep_name, new_rev):
+def update_deps_entry(deps_lines, deps_ast, value_node, new_rev, comment):
+  line_idx = update_node(deps_lines, deps_ast, value_node, new_rev)
+  (content, _, _) = deps_lines[line_idx].partition('#')
+  if comment:
+    deps_lines[line_idx] = '%s # %s' % (content.rstrip(), comment)
+  else:
+    deps_lines[line_idx] = content.rstrip()
+
+def update_deps(soln_path, dep_name, new_rev, comment):
   """Update the DEPS file with the new git revision."""
   commit_msg = ''
   deps_file = os.path.join(soln_path, 'DEPS')
   with open(deps_file) as fh:
     deps_content = fh.read()
   deps_locals = {}
   def _Var(key):
     return deps_locals['vars'][key]
   deps_locals['Var'] = _Var
   exec deps_content in {}, deps_locals
   deps_lines = deps_content.splitlines()
   deps_ast = ast.parse(deps_content, deps_file)
   deps_node = find_deps_section(deps_ast, 'deps')
   assert deps_node, 'Could not find "deps" section of DEPS file'
   dep_idx = find_dict_index(deps_node, dep_name)
   if dep_idx is not None:
     value_node = deps_node.values[dep_idx]
-    update_node(deps_lines, deps_ast, value_node, new_rev)
+    update_deps_entry(deps_lines, deps_ast, value_node, new_rev, comment)
     commit_msg = generate_commit_message(deps_locals['deps'], dep_name, new_rev)
   deps_os_node = find_deps_section(deps_ast, 'deps_os')
   if deps_os_node:
     for (os_name, os_node) in izip(deps_os_node.keys, deps_os_node.values):
       dep_idx = find_dict_index(os_node, dep_name)
       if dep_idx is not None:
         value_node = os_node.values[dep_idx]
         if value_node.__class__ is ast.Name and value_node.id == 'None':
           pass
         else:
-          update_node(deps_lines, deps_ast, value_node, new_rev)
+          update_deps_entry(deps_lines, deps_ast, value_node, new_rev, comment)
           commit_msg = generate_commit_message(
               deps_locals['deps_os'][os_name], dep_name, new_rev)
   if commit_msg:
     print 'Pinning %s' % dep_name
     print 'to revision %s' % new_rev
     print 'in %s' % deps_file
     with open(deps_file, 'w') as fh:
       for line in deps_lines:
         print >> fh, line
     with open(os.path.join(soln_path, '.git', 'MERGE_MSG'), 'a') as fh:
       fh.write(commit_msg)
   else:
     print 'Could not find an entry in %s to update.' % deps_file
   return 0 if commit_msg else 1
 
 
 def main(argv):
   if len(argv) != 2 :
     print >> sys.stderr, 'Usage: roll_dep.py <dep path> <svn revision>'
     return 1
   (dep_path, revision) = argv[0:2]
   dep_path = platform_path(dep_path)
   assert os.path.isdir(dep_path), 'No such directory: %s' % dep_path
   gclient_root = find_gclient_root()
   soln = get_solution(gclient_root, dep_path)
   soln_path = os.path.relpath(os.path.join(gclient_root, soln['name']))
   dep_name = posix_path(os.path.relpath(dep_path, gclient_root))
-  new_rev = get_git_revision(dep_path, revision)
-  assert new_rev, 'Could not find git revision matching %s' % revision
-  return update_deps(soln_path, dep_name, new_rev)
+  (git_rev, svn_rev) = get_git_revision(dep_path, revision)
+  comment = ('from svn revision %s' % svn_rev) if svn_rev else None
+  assert git_rev, 'Could not find git revision matching %s.' % revision
+  return update_deps(soln_path, dep_name, git_rev, comment)
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv[1:]))