Auto-update .gclient files for git.

gclient.py

 #!/usr/bin/env python
 # Copyright (c) 2012 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.
 
 """Meta checkout manager supporting both Subversion and GIT."""
 # Files
 #   .gclient      : Current client configuration, written by 'config' command.
 #                   Format is a Python script defining 'solutions', a list whose
 #                   entries each are maps binding the strings "name" and "url"
@@ skipping 60 matching lines @@
 #
 #   If the "target_os_only" key is also present and true, then *only* the
 #   operating systems listed in "target_os" will be used.
 #
 #   Example:
 #     target_os = [ "ios" ]
 #     target_os_only = True
 
 __version__ = '0.7'
 
+import ast
 import copy
 import json
 import logging
 import optparse
 import os
 import platform
 import posixpath
 import pprint
 import re
 import sys
 import time
 import urllib
 import urlparse
 
 import breakpad  # pylint: disable=W0611
 
 import fix_encoding
 import gclient_scm
 import gclient_utils
 import git_cache
 from third_party.repo.progress import Progress
 import subcommand
 import subprocess2
 from third_party import colorama
 
+CHROMIUM_SRC_URL = 'https://chromium.googlesource.com/chromium/src.git'
+
+
+def ast_dict_index(dnode, key):
+  """Search an ast.Dict for the argument key, and return its index."""
+  idx = [i for i in range(len(dnode.keys)) if (
+      type(dnode.keys[i]) is ast.Str and dnode.keys[i].s == key)]
+  if not idx:
+    return -1
+  elif len(idx) > 1:
+    raise gclient_utils.Error('Multiple dict entries with same key in AST')
+  return idx[-1]
+
+def ast2str(node, indent=0):
+  """Return a pretty-printed rendition of an ast.Node."""
+  t = type(node)
+  if t is ast.Module:
+    return '\n'.join([ast2str(x, indent) for x in node.body])
+  elif t is ast.Assign:
+    return (('  ' * indent) +
+            ' = '.join([ast2str(x) for x in node.targets] +
+                       [ast2str(node.value, indent)]) + '\n')
+  elif t is ast.Name:
+    return node.id
+  elif t is ast.List:
+    if not node.elts:
+      return '[]'
+    elif len(node.elts) == 1:
+      return '[' + ast2str(node.elts[0], indent) + ']'
+    return ('[\n' + ('  ' * (indent + 1)) +
+            (',\n' + ('  ' * (indent + 1))).join(
+                [ast2str(x, indent + 1) for x in node.elts]) +
+            '\n' + ('  ' * indent) + ']')
+  elif t is ast.Dict:
+    if not node.keys:
+      return '{}'
+    elif len(node.keys) == 1:
+      return '{%s: %s}' % (ast2str(node.keys[0]),
+                           ast2str(node.values[0], indent + 1))
+    return ('{\n' + ('  ' * (indent + 1)) +
+            (',\n' + ('  ' * (indent + 1))).join(
+                ['%s: %s' % (ast2str(node.keys[i]),
+                             ast2str(node.values[i], indent + 1))
+                 for i in range(len(node.keys))]) +
+            '\n' + ('  ' * indent) + '}')
+  elif t is ast.Str:
+    return "'%s'" % node.s
+  else:
+    raise gclient_utils.Error("Unexpected AST node at line %d, column %d: %s"
+                              % (node.lineno, node.col_offset, t))
+
 
 class GClientKeywords(object):
   class FromImpl(object):
     """Used to implement the From() syntax."""
 
     def __init__(self, module_name, sub_target_name=None):
       """module_name is the dep module we want to include from.  It can also be
       the name of a subdirectory to include from.
 
       sub_target_name is an optional parameter if the module name in the other
@@ skipping 45 matching lines @@
 class DependencySettings(GClientKeywords):
   """Immutable configuration settings."""
   def __init__(
       self, parent, url, safesync_url, managed, custom_deps, custom_vars,
       custom_hooks, deps_file, should_process):
     GClientKeywords.__init__(self)
 
     # These are not mutable:
     self._parent = parent
     self._safesync_url = safesync_url
-    self._deps_file = deps_file
+    if url == CHROMIUM_SRC_URL:
+      self._deps_file = 'DEPS'
+    else:
+      self._deps_file = deps_file
     self._url = url
     # 'managed' determines whether or not this dependency is synced/updated by
     # gclient after gclient checks it out initially.  The difference between
     # 'managed' and 'should_process' is that the user specifies 'managed' via
     # the --unmanaged command-line flag or a .gclient config, where
     # 'should_process' is dynamically set by gclient if it goes over its
     # recursion limit and controls gclient's behavior so it does not misbehave.
     self._managed = managed
     self._should_process = should_process
     # This is a mutable value which has the list of 'target_os' OSes listed in
@@ skipping 1007 matching lines @@
         raise gclient_utils.Error('Invalid .gclient file. Solution is '
                                   'incomplete: %s' % s)
     self.add_dependencies_and_close(deps_to_add, config_dict.get('hooks', []))
     logging.info('SetConfig() done')
 
   def SaveConfig(self):
     gclient_utils.FileWrite(os.path.join(self.root_dir,
                                          self._options.config_filename),
                             self.config_content)
 
+  def MigrateConfigToGit(self, path, options):
+    svn_url_re = re.compile('^(https?://src\.chromium\.org/svn|'
+                            'svn://svn\.chromium\.org/chrome)/'
+                            '(trunk|branches/[^/]+)/src')
+    old_git_re = re.compile('^(https?://git\.chromium\.org|'
+                            'ssh://([a-zA-Z_][a-zA-Z0-9_-]*@)?'
+                            'gerrit\.chromium\.org(:2941[89])?)/'
+                            'chromium/src\.git')
+    # Scan existing .gclient file for obsolete settings.  It would be simpler
+    # to traverse self.dependencies, but working with the AST allows the code to
+    # dump an updated .gclient file that preserves the ordering of the original.
+    a = ast.parse(self.config_content, options.config_filename, 'exec')
+    modified = False
+    solutions = [elem for elem in a.body if 'solutions' in
+                 [target.id for target in elem.targets]]
+    if not solutions:
+      return self
+    solutions = solutions[-1]
+    for solution in solutions.value.elts:
+      # Check for obsolete URL's
+      url_idx = ast_dict_index(solution, 'url')
+      if url_idx == -1:
+        continue
+      url_val = solution.values[url_idx]
+      if type(url_val) is not ast.Str:
+        continue
+      if (svn_url_re.match(url_val.s.strip())):
+        raise gclient_utils.Error(
+"""
+The chromium code repository has migrated completely to git.
+Your SVN-based checkout is now obsolete; you need to create a brand-new
+git checkout by following these instructions:
+
+http://www.chromium.org/developers/how-tos/get-the-code
+""")
+      if (old_git_re.match(url_val.s.strip())):
+        url_val.s = CHROMIUM_SRC_URL
+        modified = True
+
+      # Check for obsolete deps_file
+      if url_val.s == CHROMIUM_SRC_URL:
+        deps_file_idx = ast_dict_index(solution, 'deps_file')
+        if deps_file_idx == -1:
+          continue
+        deps_file_val = solution.values[deps_file_idx]
+        if type(deps_file_val) is not ast.Str:
+          continue
+        if deps_file_val.s == '.DEPS.git':
+          solution.keys[deps_file_idx:deps_file_idx + 1] = []
+          solution.values[deps_file_idx:deps_file_idx + 1] = []
+          modified = True
+
+    if not modified:
+      return self
+
+    print(
+"""
+WARNING: gclient detected an obsolete setting in your %s file.  The file has
+been automagically updated.  The previous version is available at %s.old.
+""" % (options.config_filename, options.config_filename))
+
+    # Replace existing .gclient with the updated version.
+    # Return a new GClient instance based on the new content.
+    new_content = ast2str(a)
+    dot_gclient_fn = os.path.join(path, options.config_filename)
+    os.rename(dot_gclient_fn, dot_gclient_fn + '.old')
+    fh = open(dot_gclient_fn, 'w')
+    fh.write(new_content)
+    fh.close()
+    client = GClient(path, options)
+    client.SetConfig(new_content)
+    return client
+
   @staticmethod
   def LoadCurrentConfig(options):
     """Searches for and loads a .gclient file relative to the current working
     dir. Returns a GClient object."""
     if options.spec:
       client = GClient('.', options)
       client.SetConfig(options.spec)
     else:
       path = gclient_utils.FindGclientRoot(os.getcwd(), options.config_filename)
       if not path:
         return None
       client = GClient(path, options)
       client.SetConfig(gclient_utils.FileRead(
           os.path.join(path, options.config_filename)))
+      client = client.MigrateConfigToGit(path, options)
 
     if (options.revisions and
         len(client.dependencies) > 1 and
         any('@' not in r for r in options.revisions)):
       print >> sys.stderr, (
           'You must specify the full solution name like --revision %s@%s\n'
           'when you have multiple solutions setup in your .gclient file.\n'
           'Other solutions present are: %s.') % (
               client.dependencies[0].name,
               options.revisions[0],
@@ skipping 416 matching lines @@
   parser.add_option('--name',
                     help='overrides the default name for the solution')
   parser.add_option('--deps-file', default='DEPS',
                     help='overrides the default name for the DEPS file for the'
                          'main solutions and all sub-dependencies')
   parser.add_option('--unmanaged', action='store_true', default=False,
                     help='overrides the default behavior to make it possible '
                          'to have the main solution untouched by gclient '
                          '(gclient will check out unmanaged dependencies but '
                          'will never sync them)')
-  parser.add_option('--git-deps', action='store_true',
-                    help='sets the deps file to ".DEPS.git" instead of "DEPS"')
   parser.add_option('--cache-dir',
                     help='(git only) Cache all git repos into this dir and do '
                          'shared clones from the cache, instead of cloning '
                          'directly from the remote. (experimental)')
   parser.set_defaults(config_filename=None)
   (options, args) = parser.parse_args(args)
   if options.output_config_file:
     setattr(options, 'config_filename', getattr(options, 'output_config_file'))
   if ((options.spec and args) or len(args) > 2 or
       (not options.spec and not args)):
     parser.error('Inconsistent arguments. Use either --spec or one or 2 args')
 
   client = GClient('.', options)
   if options.spec:
     client.SetConfig(options.spec)
   else:
     base_url = args[0].rstrip('/')
     if not options.name:
       name = base_url.split('/')[-1]
       if name.endswith('.git'):
         name = name[:-4]
     else:
       # specify an alternate relpath for the given URL.
       name = options.name
     deps_file = options.deps_file
-    if options.git_deps:
-      deps_file = '.DEPS.git'
     safesync_url = ''
     if len(args) > 1:
       safesync_url = args[1]
     client.SetDefaultConfig(name, deps_file, base_url, safesync_url,
                             managed=not options.unmanaged,
                             cache_dir=options.cache_dir)
   client.SaveConfig()
   return 0
 
 
@@ skipping 377 matching lines @@
     print >> sys.stderr, 'Error: %s' % str(e)
     return 1
   finally:
     gclient_utils.PrintWarnings()
 
 
 if '__main__' == __name__:
   sys.exit(Main(sys.argv[1:]))
 
 # vim: ts=2:sw=2:tw=80:et: