Add recurselist DEPS var setting.

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 160 matching lines @@
     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 that overrides the normal recursion limit for this
-    # dependency.  It is read from the actual DEPS file so cannot be set on
-    # class instantiation.
-    self.recursion_override = None
     # This is a mutable value which has the list of 'target_os' OSes listed in
     # the current deps file.
     self.local_target_os = None
 
     # These are only set in .gclient and not in DEPS files.
     self._custom_vars = custom_vars or {}
     self._custom_deps = custom_deps or {}
     self._custom_hooks = custom_hooks or []
 
     # TODO(iannucci): Remove this when all masters are correctly substituting
@@ skipping 57 matching lines @@
 
   @property
   def custom_hooks(self):
     return self._custom_hooks[:]
 
   @property
   def url(self):
     return self._url
 
   @property
-  def recursion_limit(self):
-    """Returns > 0 if this dependency is not too recursed to be processed."""
-    if self.recursion_override is not None:
-      return self.recursion_override
-    return max(self.parent.recursion_limit - 1, 0)
-
-  @property
   def target_os(self):
     if self.local_target_os is not None:
       return tuple(set(self.local_target_os).union(self.parent.target_os))
     else:
       return self.parent.target_os
 
   def get_custom_deps(self, name, url):
     """Returns a custom deps if applicable."""
     if self.parent:
       url = self.parent.get_custom_deps(name, url)
@@ skipping 32 matching lines @@
     # This dependency had its hook run
     self._hooks_ran = False
     # This is the scm used to checkout self.url. It may be used by dependencies
     # to get the datetime of the revision we checked out.
     self._used_scm = None
     self._used_revision = None
     # The actual revision we ended up getting, or None if that information is
     # unavailable
     self._got_revision = None
 
+    # This is a mutable value that overrides the normal recursion limit for this
+    # dependency.  It is read from the actual DEPS file so cannot be set on
+    # class instantiation.
+    self.recursion_override = None
+    # recurselist is a mutable value that selectively overrides the default
+    # 'no recursion' setting on a dep-by-dep basis.  It will replace
+    # recursion_override.
+    self.recurselist = None
+
     if not self.name and self.parent:
       raise gclient_utils.Error('Dependency without name')
 
   @property
   def requirements(self):
     """Calculate the list of requirements."""
     requirements = set()
     # self.parent is implicitly a requirement. This will be recursive by
     # definition.
     if self.parent and self.parent.name:
@@ skipping 19 matching lines @@
     if self.name:
       requirements |= set(
           obj.name for obj in self.root.subtree(False)
           if (obj is not self
               and obj.name and
               self.name.startswith(posixpath.join(obj.name, ''))))
     requirements = tuple(sorted(requirements))
     logging.info('Dependency(%s).requirements = %s' % (self.name, requirements))
     return requirements
 
+  @property
+  def try_recurselist(self):
+    """Returns False if recursion_override is ever specified."""
+    if self.recursion_override is not None:
+      return False
+    return self.parent.try_recurselist
+
+  @property
+  def recursion_limit(self):
+    """Returns > 0 if this dependency is not too recursed to be processed."""
+    # We continue to support the absence of recurselist until tools and DEPS
+    # using recursion_override are updated.
+    if self.try_recurselist and self.parent.recurselist != None:
+      if self.name in self.parent.recurselist:
+        return 1
+
+    if self.recursion_override is not None:
+      return self.recursion_override
+    return max(self.parent.recursion_limit - 1, 0)
+
   def verify_validity(self):
     """Verifies that this Dependency is fine to add as a child of another one.
 
     Returns True if this entry should be added, False if it is a duplicate of
     another entry.
     """
     logging.info('Dependency(%s).verify_validity()' % self.name)
     if self.name in [s.name for s in self.parent.dependencies]:
       raise gclient_utils.Error(
           'The same name "%s" appears multiple times in the deps section' %
@@ skipping 186 matching lines @@
           if not isinstance(val, (dict, list, tuple, str)):
             raise gclient_utils.Error(
               'ParseDepsFile(%s): Strict mode disallows %r -> %r' %
               (self.name, key, val))
 
     deps = local_scope.get('deps', {})
     if 'recursion' in local_scope:
       self.recursion_override = local_scope.get('recursion')
       logging.warning(
           'Setting %s recursion to %d.', self.name, self.recursion_limit)
+    self.recurselist = local_scope.get('recurselist', None)

[iannucci, 2014/06/30 23:37:04]

nit: I would have preferred recurselist actually be a set()

+    if 'recurselist' in local_scope:
+      logging.warning('Found recurselist %r.', repr(self.recurselist))
     # If present, save 'target_os' in the local_target_os property.
     if 'target_os' in local_scope:
       self.local_target_os = local_scope['target_os']
     # load os specific dependencies if defined.  these dependencies may
     # override or extend the values defined by the 'deps' member.
     target_os_list = self.target_os
     if 'deps_os' in local_scope and target_os_list:
       deps = self.MergeWithOsDeps(deps, local_scope['deps_os'], target_os_list)
 
     # If a line is in custom_deps, but not in the solution, we want to append
@@ skipping 874 matching lines @@
   def enforced_os(self):
     """What deps_os entries that are to be parsed."""
     return self._enforced_os
 
   @property
   def recursion_limit(self):
     """How recursive can each dependencies in DEPS file can load DEPS file."""
     return self._recursion_limit
 
   @property
+  def try_recurselist(self):
+    """Whether to attempt using recurselist-style recursion processing."""
+    return True
+
+  @property
   def target_os(self):
     return self._enforced_os
 
 
 #### gclient commands.
 
 
 def CMDcleanup(parser, args):
   """Cleans up all working copies.
 
@@ skipping 537 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: