Extend From() to allow importing from different mappings. Also...

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.
 
 """A wrapper script to manage a set of client modules in different SCM.
 
 This script is intended to be used to help basic management of client
 program sources residing in one or more Subversion modules and Git
 repositories, along with other modules it depends on, also in Subversion or Git,
@@ skipping 410 matching lines @@
     scope = {}
     filename = os.path.join(self._root_dir, self._options.entries_filename)
     if not os.path.exists(filename):
       return []
     exec(gclient_utils.FileRead(filename), scope)
     return scope["entries"]
 
   class FromImpl:
     """Used to implement the From syntax."""
 
-    def __init__(self, module_name):
+    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
+      DEPS file is different. E.g., you might want to map src/net to net."""
       self.module_name = module_name
+      self.sub_target_name = sub_target_name
 
     def __str__(self):
-      return 'From("%s")' % self.module_name
+      return 'From(%s, %s)' % (repr(self.module_name),
+                               repr(self.sub_target_name))
+
+    def GetUrl(self, target_name, sub_deps_base_url, root_dir, sub_deps):
+      """Resolve the URL for this From entry."""
+      sub_deps_target_name = target_name
+      if self.sub_target_name:
+        sub_deps_target_name = self.sub_target_name
+      url = sub_deps[sub_deps_target_name]
+      if url.startswith('/'):
+        # If it's a relative URL, we need to resolve the URL relative to the
+        # sub deps base URL.
+        if not isinstance(sub_deps_base_url, basestring):
+          sub_deps_base_url = sub_deps_base_url.GetPath()
+        scm = gclient_scm.CreateSCM(sub_deps_base_url, root_dir,
+                                    None)
+        url = scm.FullUrlForRelativeUrl(url)
+      return url
 
   class FileImpl:
     """Used to implement the File('') syntax which lets you sync a single file
     from an SVN repo."""
 
     def __init__(self, file_location):
       self.file_location = file_location
 
     def __str__(self):
       return 'File("%s")' % self.file_location
@@ skipping 18 matching lines @@
 
     def Lookup(self, var_name):
       """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)
 
   def _ParseSolutionDeps(self, solution_name, solution_deps_content,
-                         custom_vars):
+                         custom_vars, parse_hooks):
     """Parses the DEPS file for the specified solution.
 
     Args:
       solution_name: The name of the solution to query.
       solution_deps_content: Content of the DEPS file for the solution
       custom_vars: A dict of vars to override any vars defined in the DEPS file.
 
     Returns:
       A dict mapping module names (as relative paths) to URLs or an empty
       dict if the solution does not have a DEPS file.
@@ skipping 39 matching lines @@
         os_deps = local_scope["deps_os"].get(deps_os_key, {})
         if len(deps_to_include) > 1:
           # Ignore any overrides when including deps for more than one
           # platform, so we collect the broadest set of dependencies available.
           # We may end up with the wrong revision of something for our
           # platform, but this is the best we can do.
           deps.update([x for x in os_deps.items() if not x[0] in deps])
         else:
           deps.update(os_deps)
 
-    if 'hooks' in local_scope:
+    if 'hooks' in local_scope and parse_hooks:
       self._deps_hooks.extend(local_scope['hooks'])
 
     # If use_relative_paths is set in the DEPS file, regenerate
     # the dictionary using paths relative to the directory containing
     # the DEPS file.
     if local_scope.get('use_relative_paths'):
       rel_deps = {}
       for d, url in deps.items():
         # normpath is required to allow DEPS to use .. in their
         # dependency local path.
@@ skipping 18 matching lines @@
 
     Raises:
       Error: If a dependency conflicts with another dependency or of a solution.
     """
     deps = {}
     for solution in self.GetVar("solutions"):
       custom_vars = solution.get("custom_vars", {})
       solution_deps = self._ParseSolutionDeps(
                               solution["name"],
                               solution_deps_content[solution["name"]],
-                              custom_vars)
+                              custom_vars,
+                              True)
 
       # If a line is in custom_deps, but not in the solution, we want to append
       # this line to the solution.
       if "custom_deps" in solution:
         for d in solution["custom_deps"]:
           if d not in solution_deps:
             solution_deps[d] = solution["custom_deps"][d]
 
       for d in solution_deps:
         if "custom_deps" in solution and d in solution["custom_deps"]:
@@ skipping 188 matching lines @@
     if command == 'update' and not self._options.verbose:
       pm.end()
 
     # Second pass for inherited deps (via the From keyword)
     for d in deps_to_process:
       if isinstance(deps[d], self.FromImpl):
         filename = os.path.join(self._root_dir,
                                 deps[d].module_name,
                                 self._options.deps_file)
         content =  gclient_utils.FileRead(filename)
-        sub_deps = self._ParseSolutionDeps(deps[d].module_name, content, {})
-        url = sub_deps[d]
+        sub_deps = self._ParseSolutionDeps(deps[d].module_name, content, {},
+                                           False)
+        # Getting the URL from the sub_deps file can involve having to resolve
+        # a File() or having to resolve a relative URL.  To resolve relative
+        # URLs, we need to pass in the orignal sub deps URL.
+        sub_deps_base_url = deps[deps[d].module_name]
+        url = deps[d].GetUrl(d, sub_deps_base_url, self._root_dir, sub_deps)
         entries[d] = url
         if run_scm:
           self._options.revision = revision_overrides.get(d)
           scm = gclient_scm.CreateSCM(url, self._root_dir, d)
           scm.RunCommand(command, self._options, args, file_list)
           self._options.revision = None
 
     # Convert all absolute paths to relative.
     for i in range(len(file_list)):
       # TODO(phajdan.jr): We should know exactly when the paths are absolute.
@@ skipping 498 matching lines @@
 
 if "__main__" == __name__:
   try:
     result = Main(sys.argv)
   except gclient_utils.Error, e:
     print >> sys.stderr, "Error: %s" % str(e)
     result = 1
   sys.exit(result)
 
 # vim: ts=2:sw=2:tw=80:et: