Propagate use_relative_paths into recursedeps

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 196 matching lines @@
         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 DependencySettings(GClientKeywords):
   """Immutable configuration settings."""
   def __init__(
       self, parent, url, safesync_url, managed, custom_deps, custom_vars,
-      custom_hooks, deps_file, should_process):
+      custom_hooks, deps_file, should_process, relative):
     GClientKeywords.__init__(self)
 
     # These are not mutable:
     self._parent = parent
     self._safesync_url = safesync_url
     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
+    # If this is a recursed-upon sub-dependency, and the parent has
+    # use_relative_paths set, then this dependency should check out its own
+    # dependencies relative to that parent's path for this, rather than
+    # relative to the .gclient file.
+    self._relative = relative
     # 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 75 matching lines @@
     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)
 
 
 class Dependency(gclient_utils.WorkItem, DependencySettings):
   """Object that represents a dependency checkout."""
 
   def __init__(self, parent, name, url, safesync_url, managed, custom_deps,
-               custom_vars, custom_hooks, deps_file, should_process):
+               custom_vars, custom_hooks, deps_file, should_process,
+               relative):
     gclient_utils.WorkItem.__init__(self, name)
     DependencySettings.__init__(
         self, parent, url, safesync_url, managed, custom_deps, custom_vars,
-        custom_hooks, deps_file, should_process)
+        custom_hooks, deps_file, should_process, relative)
 
     # This is in both .gclient and DEPS files:
     self._deps_hooks = []
 
     self._pre_deps_hooks = []
 
     # Calculates properties:
     self._parsed_url = None
     self._dependencies = []
     # A cache of the files affected by the current operation, necessary for
@@ skipping 336 matching lines @@
     # If a line is in custom_deps, but not in the solution, we want to append
     # this line to the solution.
     for d in self.custom_deps:
       if d not in deps:
         deps[d] = self.custom_deps[d]
 
     # If use_relative_paths is set in the DEPS file, regenerate
     # the dictionary using paths relative to the directory containing
     # the DEPS file.  Also update recursedeps if use_relative_paths is
     # enabled.
+    # If the deps file doesn't set use_relative_paths, but the parent did
+    # (and therefore set self.relative on this Dependency object), then we
+    # want to modify the deps and recursedeps by prepending the parent
+    # directory of this dependency.
     use_relative_paths = local_scope.get('use_relative_paths', False)
+    rel_prefix = None
     if use_relative_paths:
+      rel_prefix = self.name
+    elif self._relative:
+      rel_prefix = os.path.dirname(self.name)
+    if rel_prefix:
       logging.warning('use_relative_paths enabled.')
       rel_deps = {}
       for d, url in deps.items():
         # normpath is required to allow DEPS to use .. in their
         # dependency local path.
-        rel_deps[os.path.normpath(os.path.join(self.name, d))] = url
-      logging.warning('Updating deps by prepending %s.', self.name)
+        rel_deps[os.path.normpath(os.path.join(rel_prefix, d))] = url
+      logging.warning('Updating deps by prepending %s.', rel_prefix)
       deps = rel_deps
 
       # Update recursedeps if it's set.
       if self.recursedeps is not None:
-        logging.warning('Updating recursedeps by prepending %s.', self.name)
+        logging.warning('Updating recursedeps by prepending %s.', rel_prefix)
         rel_deps = {}
         for depname, options in self.recursedeps.iteritems():
-          rel_deps[os.path.normpath(os.path.join(self.name, depname))] = options
+          rel_deps[
+              os.path.normpath(os.path.join(rel_prefix, depname))] = options
         self.recursedeps = rel_deps
 
+
     if 'allowed_hosts' in local_scope:
       try:
         self._allowed_hosts = frozenset(local_scope.get('allowed_hosts'))
       except TypeError:  # raised if non-iterable
         pass
       if not self._allowed_hosts:
         logging.warning("allowed_hosts is specified but empty %s",
                         self._allowed_hosts)
         raise gclient_utils.Error(
             'ParseDepsFile(%s): allowed_hosts must be absent '
             'or a non-empty iterable' % self.name)
 
     # Convert the deps into real Dependency.
     deps_to_add = []
     for name, url in deps.iteritems():
       should_process = self.recursion_limit and self.should_process
       deps_file = self.deps_file
       if self.recursedeps is not None:
         ent = self.recursedeps.get(name)
         if ent is not None:
           deps_file = ent['deps_file']
       deps_to_add.append(Dependency(
           self, name, url, None, None, None, self.custom_vars, None,
-          deps_file, should_process))
+          deps_file, should_process, use_relative_paths))
     deps_to_add.sort(key=lambda x: x.name)
 
     # override named sets of hooks by the custom hooks
     hooks_to_run = []
     hook_names_to_suppress = [c.get('name', '') for c in self.custom_hooks]
     for hook in local_scope.get('hooks', []):
       if hook.get('name', '') not in hook_names_to_suppress:
         hooks_to_run.append(hook)
 
     # add the replacements and any additions
@@ skipping 468 matching lines @@
 # 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, True, None, None, None,
-                        'unused', True)
+                        'unused', True, None)
     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 = tuple(set(enforced_os))
     self._root_dir = root_dir
     self.config_content = None
@@ skipping 70 matching lines @@
     for s in config_dict.get('solutions', []):
       try:
         deps_to_add.append(Dependency(
             self, s['name'], s['url'],
             s.get('safesync_url', None),
             s.get('managed', True),
             s.get('custom_deps', {}),
             s.get('custom_vars', {}),
             s.get('custom_hooks', []),
             s.get('deps_file', 'DEPS'),
-            True))
+            True,
+            None))
       except KeyError:
         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)
@@ skipping 1034 matching lines @@
 
 
 if '__main__' == __name__:
   try:
     sys.exit(main(sys.argv[1:]))
   except KeyboardInterrupt:
     sys.stderr.write('interrupted\n')
     sys.exit(1)
 
 # vim: ts=2:sw=2:tw=80:et: