Add more glue code necessary for getting the DEPS dependencies as Dependency objects.

gclient.py

 #!/usr/bin/python
 # Copyright (c) 2010 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 293 matching lines @@
           raise gclient_utils.Error(
               "Solutions have conflicting versions of dependency \"%s\"" % d)
         if d in solution_urls and solution_urls[d] != url:
           raise gclient_utils.Error(
               "Dependency \"%s\" conflicts with specified solution" % d)
         # Grab the dependency.
         deps[d] = url
     return deps
 
   def _RunHookAction(self, hook_dict, matching_file_list):
-    """Runs the action from a single hook.
-    """
+    """Runs the action from a single hook."""
     logging.info(hook_dict)
     logging.info(matching_file_list)
     command = hook_dict['action'][:]
     if command[0] == 'python':
       # If the hook specified "python" as the first item, the action is a
       # Python script.  Run it by starting a new copy of the same
       # interpreter.
       command[0] = sys.executable
 
     if '$matching_files' in command:
       splice_index = command.index('$matching_files')
       command[splice_index:splice_index + 1] = matching_file_list
 
     # Use a discrete exit status code of 2 to indicate that a hook action
     # failed.  Users of this script may wish to treat hook action failures
     # differently from VC failures.
-    gclient_utils.SubprocessCall(command, self.root_dir(), fail_status=2)
+    return gclient_utils.SubprocessCall(command, self.root_dir(), fail_status=2)
 
   def _RunHooks(self, command, file_list, is_using_git):
     """Evaluates all hooks, running actions as needed.
     """
     # Hooks only run for these command types.
     if not command in ('update', 'revert', 'runhooks'):
       return
 
     # Hooks only run when --nohooks is not specified
     if self._options.nohooks:
@@ skipping 20 matching lines @@
       matching_file_list = [f for f in file_list if pattern.search(f)]
       if matching_file_list:
         self._RunHookAction(hook_dict, matching_file_list)
 
   def root_dir(self):
     return self.parent.root_dir()
 
   def enforced_os(self):
     return self.parent.enforced_os()
 
+  def recursion_limit(self):
+    return self.parent.recursion_limit() - 1
+
+  def tree(self, force_all):
+    return self.parent.tree(force_all)
+
+  def get_custom_deps(self, name, url):
+    """Returns a custom deps if applicable."""
+    if self.parent:
+      url = self.parent.get_custom_deps(name, url)
+    # None is a valid return value to disable a dependency.
+    return self.custom_deps.get(name, url)
+
+  def __str__(self):
+    out = []
+    for i in ('name', 'url', 'safesync_url', 'custom_deps', 'custom_vars',
+              'deps_hooks'):
+      # 'deps_file'
+      if self.__dict__[i]:
+        out.append('%s: %s' % (i, self.__dict__[i]))
+
+    for d in self.dependencies:
+      out.extend(['  ' + x for x in str(d).splitlines()])
+      out.append('')
+    return '\n'.join(out)
+
+  def __repr__(self):
+    return '%s: %s' % (self.name, self.url)
+
 
 class GClient(Dependency):
-  """Main gclient checkout root where .gclient resides."""
+  """Object that represent a gclient checkout. A tree of Dependency(), one per
+  solution or DEPS entry."""
   SUPPORTED_COMMANDS = [
     'cleanup', 'diff', 'export', 'pack', 'revert', 'status', 'update',
     'runhooks'
   ]
 
   DEPS_OS_CHOICES = {
     "win32": "win",
     "win": "win",
     "cygwin": "win",
     "darwin": "mac",
@@ skipping 36 matching lines @@
     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
+    # Do not change previous behavior. Only solution level and immediate DEPS
+    # are processed.
+    self._recursion_limit = 2
 
   def SetConfig(self, content):
     assert self.dependencies == []
     config_dict = {}
     self.config_content = content
     try:
       exec(content, config_dict)
     except SyntaxError, e:
       try:
         # Try to construct a human readable error message
@@ skipping 221 matching lines @@
             modified_files = gclient_scm.scm.SVN.CaptureStatus(e_dir)
           else:
             file_list = []
             scm = gclient_scm.CreateSCM(prev_entries[entry], self.root_dir(),
                                         entry_fixed)
             scm.status(self._options, [], file_list)
             modified_files = file_list != []
           if not self._options.delete_unversioned_trees or modified_files:
             # There are modified files in this entry. Keep warning until
             # removed.
-            print(("\nWARNING: \"%s\" is no longer part of this client.  "
-                   "It is recommended that you manually remove it.\n") %
+            print(('\nWARNING: \'%s\' is no longer part of this client.  '
+                   'It is recommended that you manually remove it.\n') %
                       entry_fixed)
           else:
             # Delete the entry
-            print("\n________ deleting \'%s\' " +
-                  "in \'%s\'") % (entry_fixed, self.root_dir())
+            print('\n________ deleting \'%s\' ' +
+                  'in \'%s\'') % (entry_fixed, self.root_dir())
             gclient_utils.RemoveDirectory(e_dir)
       # record the current list of entries for next time
       self._SaveEntries(entries)
     return 0
 
   def PrintRevInfo(self):
     """Output revision info mapping for the client and its dependencies.
 
     This allows the capture of an overall "revision" for the source tree that
     can be used to reproduce the same tree in the future. It is only useful for
@@ skipping 69 matching lines @@
       print(";\n".join(["%s: %s" % (x, entries[x])
                        for x in sorted(entries.keys())]))
 
     # Print the snapshot configuration file
     if self._options.snapshot:
       config = self.DEFAULT_SNAPSHOT_FILE_TEXT % {'solution_list': new_gclient}
       snapclient = GClient(self.root_dir(), self._options)
       snapclient.SetConfig(config)
       print(snapclient.config_content)
 
+  def ParseDepsFile(self, direct_reference):
+    """No DEPS to parse for a .gclient file."""
+    self.direct_reference = direct_reference
+    self.deps_parsed = True
+
   def root_dir(self):
+    """Root directory of gclient checkout."""
     return self._root_dir
 
   def enforced_os(self):
+    """What deps_os entries that are to be parsed."""
     return self._enforced_os
 
+  def recursion_limit(self):
+    """How recursive can each dependencies in DEPS file can load DEPS file."""
+    return self._recursion_limit
+
+  def tree(self, force_all):
+    """Returns a flat list of all the dependencies."""
+    def subtree(dep):
+      if not force_all and not dep.direct_reference:
+        # Was loaded from a From() keyword in a DEPS file, don't load all its
+        # dependencies.
+        return []
+      result = dep.dependencies[:]
+      for d in dep.dependencies:
+        result.extend(subtree(d))
+      return result
+    return subtree(self)
+
 
 #### gclient commands.
 
 
 def CMDcleanup(parser, args):
   """Cleans up all working copies.
 
 Mostly svn-specific. Simply runs 'svn cleanup' for each module.
 """
   parser.add_option('--deps', dest='deps_os', metavar='OS_LIST',
@@ skipping 333 matching lines @@
     return CMDhelp(parser, argv)
   except gclient_utils.Error, e:
     print >> sys.stderr, 'Error: %s' % str(e)
     return 1
 
 
 if '__main__' == __name__:
   sys.exit(Main(sys.argv[1:]))
 
 # vim: ts=2:sw=2:tw=80:et: