Allow gclient clone in non-empty directories

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
@@ skipping 270 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,
+               tmpdir_stage):
     gclient_utils.WorkItem.__init__(self, name)
     DependencySettings.__init__(
         self, parent, url, safesync_url, managed, custom_deps, custom_vars,
         custom_hooks, deps_file, should_process)
 
     # This is in both .gclient and DEPS files:
     self._deps_hooks = []
 
     # Calculates properties:
     self._parsed_url = None
     self._dependencies = []
     # 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 has been processed, i.e. checked out
     self._processed = False
     # 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.tmpdir_stage = tmpdir_stage
 
     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.
@@ skipping 167 matching lines @@
     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)
     # 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.
+
+    tmpdir_staged_deps = local_scope.get('tmpdir_stage', [])
     target_os_deps = {}
     if 'deps_os' in local_scope:
       for deps_os_key in self.target_os:
         os_deps = local_scope['deps_os'].get(deps_os_key, {})
         if len(self.target_os) > 1:
           # Ignore any conflict 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.
           target_os_deps.update(
@@ skipping 21 matching lines @@
         # dependency local path.
         rel_deps[os.path.normpath(os.path.join(self.name, d))] = url
       deps = rel_deps
 
     # 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_to_add.append(Dependency(
           self, name, url, None, None, None, None, None,
-          self.deps_file, should_process))
+          self.deps_file, should_process, name in tmpdir_staged_deps))
     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 70 matching lines @@
           # pylint: disable=E1103
           options.revision = parsed_url.GetRevision()
           self._used_scm = gclient_scm.SVNWrapper(
               parsed_url.GetPath(), self.root.root_dir, self.name)
           self._used_scm.RunCommand('updatesingle',
               options, args + [parsed_url.GetFilename()], file_list)
       else:
         # Create a shallow copy to mutate revision.
         options = copy.copy(options)
         options.revision = revision_overrides.get(self.name)
+        options.stage_clone = self.tmpdir_stage
         self.maybeGetParentRevision(
             command, options, parsed_url, self.parent.name, revision_overrides)
         self._used_scm = gclient_scm.CreateSCM(
             parsed_url, self.root.root_dir, self.name)
         self._used_scm.RunCommand(command, options, args, file_list)
         if file_list:
           file_list = [os.path.join(self.name, f.strip()) for f in file_list]
 
       # TODO(phajdan.jr): We should know exactly when the paths are absolute.
       # Convert all absolute paths to relative.
@@ skipping 1204 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: