Add a --deps-file flag to gclient to allow using a deps file other than DEPS.

gclient.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.
 
 """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
@@ skipping 120 matching lines @@
       """Implements the Var syntax."""
       if var_name in self._custom_vars:
         return self._custom_vars[var_name]
       elif var_name in self._local_scope.get("vars", {}):
         return self._local_scope["vars"][var_name]
       raise gclient_utils.Error("Var is not defined: %s" % var_name)
 
 
 class Dependency(GClientKeywords, gclient_utils.WorkItem):
   """Object that represents a dependency checkout."""
-  DEPS_FILE = 'DEPS'
 
   def __init__(self, parent, name, url, safesync_url, custom_deps,
                custom_vars, deps_file, should_process):
     GClientKeywords.__init__(self)
     gclient_utils.WorkItem.__init__(self)
     self.parent = parent
     self.name = name
     self.url = url
     self.parsed_url = None
     # These 2 are only set in .gclient and not in DEPS files.
     self.safesync_url = safesync_url
     self.custom_vars = custom_vars or {}
     self.custom_deps = custom_deps or {}
     self.deps_hooks = []
     self.dependencies = []
-    self.deps_file = deps_file or self.DEPS_FILE
+    self.deps_file = deps_file
     # A cache of the files affected by the current operation, necessary for
     # hooks.
     self._file_list = []
     # If it is not set to True, the dependency wasn't processed for its child
     # dependency, i.e. its DEPS wasn't read.
     self.deps_parsed = False
     # This dependency should be processed, i.e. checked out
     self.should_process = should_process
     # This dependency has been processed, i.e. checked out
     self.processed = False
@@ skipping 91 matching lines @@
     local_scope = {}
     var = self.VarImpl(self.custom_vars, local_scope)
     global_scope = {
       'File': self.FileImpl,
       'From': self.FromImpl,
       'Var': var.Lookup,
       'deps_os': {},
     }
     filepath = os.path.join(self.root_dir(), self.name, self.deps_file)
     if not os.path.isfile(filepath):
-      logging.info('%s: No DEPS file found at %s' % (self.name, filepath))
+      logging.info('%s: No %s file found at %s' % (self.name, self.deps_file,
+                                                   filepath))
     else:
       deps_content = gclient_utils.FileRead(filepath)
       logging.debug(deps_content)
       # Eval the content.
       try:
         exec(deps_content, global_scope, local_scope)
       except SyntaxError, e:
         gclient_utils.SyntaxErrorToError(filepath, e)
     deps = local_scope.get('deps', {})
     # load os specific dependencies if defined.  these dependencies may
@@ skipping 44 matching lines @@
             logging.info('Won\'t process duplicate dependency %s' % tree[name])
             # In theory we could keep it as a shadow of the other one. In
             # practice, simply ignore it.
             #should_process = False
             continue
           else:
             raise gclient_utils.Error(
                 'Dependency %s specified more than once:\n  %s\nvs\n  %s' %
                 (name, tree[name].hierarchy(), self.hierarchy()))
       self.dependencies.append(Dependency(self, name, url, None, None, None,
-          None, should_process))
+          self.deps_file, should_process))
     logging.debug('Loaded: %s' % str(self))
 
   # Arguments number differs from overridden method
   # pylint: disable=W0221
   def run(self, revision_overrides, command, args, work_queue, options):
     """Runs 'command' before parsing the DEPS in case it's a initial checkout
     or a revert."""
 
     def maybeGetParentRevision(options):
       """If we are performing an update and --transitive is set, set the
@@ skipping 233 matching lines @@
     "mac": "mac",
     "unix": "unix",
     "linux": "unix",
     "linux2": "unix",
   }
 
   DEFAULT_CLIENT_FILE_TEXT = ("""\
 solutions = [
   { "name"        : "%(solution_name)s",
     "url"         : "%(solution_url)s",
+    "deps_file"   : "%(deps_file)s",
     "custom_deps" : {
     },
     "safesync_url": "%(safesync_url)s",
   },
 ]
 """)
 
   DEFAULT_SNAPSHOT_SOLUTION_TEXT = ("""\
   { "name"        : "%(solution_name)s",
     "url"         : "%(solution_url)s",
+    "deps_file"   : "%(deps_file)s",
     "custom_deps" : {
 %(solution_deps)s    },
     "safesync_url": "%(safesync_url)s",
   },
 """)
 
   DEFAULT_SNAPSHOT_FILE_TEXT = ("""\
 # Snapshot generated with gclient revinfo --snapshot
 solutions = [
 %(solution_list)s]
 """)
 
   def __init__(self, root_dir, options):
     # Do not change previous behavior. Only solution level and immediate DEPS
     # are processed.
     self._recursion_limit = 2
-    Dependency.__init__(self, None, None, None, None, None, None, None, True)
+    Dependency.__init__(self, None, None, None, None, None, None, 'unused',
+                        True)
     self._options = options
     if options.deps_os:
       enforced_os = options.deps_os.split(',')
     else:
       enforced_os = [self.DEPS_OS_CHOICES.get(sys.platform, 'unix')]
     if 'all' in enforced_os:
       enforced_os = self.DEPS_OS_CHOICES.itervalues()
     self._enforced_os = list(set(enforced_os))
     self._root_dir = root_dir
     self.config_content = None
@@ skipping 10 matching lines @@
       try:
         tree = dict((d.name, d) for d in self.tree(False))
         if s['name'] in tree:
           raise gclient_utils.Error(
               'Dependency %s specified more than once in .gclient' % s['name'])
         self.dependencies.append(Dependency(
             self, s['name'], s['url'],
             s.get('safesync_url', None),
             s.get('custom_deps', {}),
             s.get('custom_vars', {}),
-            None,
+            s.get('deps_file', 'DEPS'),

[M-A Ruel, 2011/05/28 22:58:23]

self.deps_file?

             True))
       except KeyError:
         raise gclient_utils.Error('Invalid .gclient file. Solution is '
                                   'incomplete: %s' % s)
     # .gclient can have hooks.
     self.deps_hooks = config_dict.get('hooks', [])
     self.deps_parsed = True
 
   def SaveConfig(self):
     gclient_utils.FileWrite(os.path.join(self.root_dir(),
                                          self._options.config_filename),
                             self.config_content)
 
   @staticmethod
   def LoadCurrentConfig(options):
     """Searches for and loads a .gclient file relative to the current working
     dir. Returns a GClient object."""
     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)))
     return client
 
-  def SetDefaultConfig(self, solution_name, solution_url, safesync_url):
+  def SetDefaultConfig(self, solution_name, deps_file, solution_url,
+                       safesync_url):
     self.SetConfig(self.DEFAULT_CLIENT_FILE_TEXT % {
       'solution_name': solution_name,
       'solution_url': solution_url,
+      'deps_file': deps_file,
       'safesync_url' : safesync_url,
     })
 
   def _SaveEntries(self):
     """Creates a .gclient_entries file to record the list of unique checkouts.
 
     The .gclient_entries file lives in the same directory as .gclient.
     """
     # Sometimes pprint.pformat will use {', sometimes it'll use { ' ... It
     # makes testing a bit too fun.
@@ skipping 154 matching lines @@
         custom_deps = []
         for k in sorted(entries.keys()):
           if entries[k]:
             # Quotes aren't escaped...
             custom_deps.append('      \"%s\": \'%s\',\n' % (k, entries[k]))
           else:
             custom_deps.append('      \"%s\": None,\n' % k)
         new_gclient += self.DEFAULT_SNAPSHOT_SOLUTION_TEXT % {
             'solution_name': d.name,
             'solution_url': d.url,
+            'deps_file': d.deps_file,
             'safesync_url' : d.safesync_url or '',
             'solution_deps': ''.join(custom_deps),
         }
       # Print the snapshot configuration file
       print(self.DEFAULT_SNAPSHOT_FILE_TEXT % {'solution_list': new_gclient})
     else:
       entries = {}
       for d in self.tree(False):
         if self._options.actual:
           entries[d.name] = GetURLAndRev(d)
@@ skipping 98 matching lines @@
 modules to operate on as well. If optional [url] parameter is
 provided, then configuration is read from a specified Subversion server
 URL.
 """
   parser.add_option('--spec',
                     help='create a gclient file containing the provided '
                          'string. Due to Cygwin/Python brokenness, it '
                          'probably can\'t contain any newlines.')
   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('--git-deps', action='store_true',
+                    help='sets the deps file to ".DEPS.git" instead of "DEPS"')
   (options, args) = parser.parse_args(args)
   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')
 
   if os.path.exists(options.config_filename):
     raise gclient_utils.Error('%s file already exists in the current directory'
                                   % options.config_filename)
   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]
     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, base_url, safesync_url)
+    client.SetDefaultConfig(name, deps_file, base_url, safesync_url)
   client.SaveConfig()
   return 0
 
 
 @attr('epilog', """Example:
   gclient pack > patch.txt
     generate simple patch for configured client and dependences
 """)
 def CMDpack(parser, args):
   """Generate a patch which can be applied at the root of the tree.
@@ skipping 286 matching lines @@
   except (gclient_utils.Error, subprocess2.CalledProcessError), e:
     print >> sys.stderr, 'Error: %s' % str(e)
     return 1
 
 
 if '__main__' == __name__:
   fix_encoding.fix_encoding()
   sys.exit(Main(sys.argv[1:]))
 
 # vim: ts=2:sw=2:tw=80:et: