roll-dep: If applicable, include svn revision range in commit message

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 subprocess import check_output, 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]+) .*$')
-ROLL_DESCRIPTION_STR = '''Roll %s from %s to %s
+ROLL_DESCRIPTION_STR = (
+'''Roll %(dep_path)s %(before_rev)s:%(after_rev)s%(svn_range)s
 
 Summary of changes available at:
-%s
-'''
+%(revlog_url)s
+''')
 
 
 def shorten_dep_path(dep):
   """Shorten the given dep path if necessary."""
   while len(dep) > 31:
     dep = '.../' + dep.lstrip('./').partition('/')[2]
   return dep
 
 
 def posix_path(path):
@@ skipping 203 matching lines @@
   git revision."""
   vars_node = find_deps_section(deps_ast, 'vars')
   assert vars_node, 'Could not find "vars" section of DEPS file.'
   var_idx = find_dict_index(vars_node, var_name)
   assert var_idx is not None, (
       'Could not find definition of "%s" var in DEPS file.' % var_name)
   val_node = vars_node.values[var_idx]
   return update_node(deps_lines, deps_ast, val_node, git_revision)
 
 
-def generate_commit_message(deps_section, dep_name, new_rev):
+def short_rev(rev, dep_path):
+  return check_output(['git', 'rev-parse', '--short', rev],
+                      cwd=dep_path).rstrip()
+
+
+def generate_commit_message(deps_section, dep_path, dep_name, new_rev):
   (url, _, old_rev) = deps_section[dep_name].partition('@')
   if url.endswith('.git'):
     url = url[:-4]
-  url += '/+log/%s..%s' % (old_rev[:12], new_rev[:12])
-  return dedent(ROLL_DESCRIPTION_STR % (
-      shorten_dep_path(dep_name), old_rev[:12], new_rev[:12], url))
+  old_rev_short = short_rev(old_rev, dep_path)
+  new_rev_short = short_rev(new_rev, dep_path)
+  url += '/+log/%s..%s' % (old_rev_short, new_rev_short)
+  old_svn_rev = get_svn_revision(dep_path, old_rev)
+  new_svn_rev = get_svn_revision(dep_path, new_rev)
+  svn_range_str = ''
+  if old_svn_rev and new_svn_rev:
+    svn_range_str = ' (svn %s:%s)' % (old_svn_rev, new_svn_rev)
+  return dedent(ROLL_DESCRIPTION_STR % {
+    'dep_path': shorten_dep_path(dep_name),
+    'before_rev': old_rev_short,
+    'after_rev': new_rev_short,
+    'svn_range': svn_range_str,
+    'revlog_url': url,
+  })
 
 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):
+def update_deps(soln_path, dep_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_deps_entry(deps_lines, deps_ast, value_node, new_rev, comment)
-    commit_msg = generate_commit_message(deps_locals['deps'], dep_name, new_rev)
+    commit_msg = generate_commit_message(deps_locals['deps'], dep_path,
+                                         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_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)
+              deps_locals['deps_os'][os_name], dep_path, 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))
   (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)
+  return update_deps(soln_path, dep_path, dep_name, git_rev, comment)
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv[1:]))