Allow gclient clone in non-empty directories

gclient_scm.py

 # 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.
 
 """Gclient-specific SCM-specific operations."""
 
 import collections
 import logging
 import os
 import posixpath
 import re
 import sys
+import tempfile
 import threading
 import time
 
 import gclient_utils
 import scm
 import subprocess2
 
 
 THIS_FILE_PATH = os.path.abspath(__file__)
 
@@ skipping 320 matching lines @@
     if revision.startswith('refs/'):
       rev_type = "branch"
     elif revision.startswith('origin/'):
       # For compatability with old naming, translate 'origin' to 'refs/heads'
       revision = revision.replace('origin/', 'refs/heads/')
       rev_type = "branch"
     else:
       # hash is also a tag, only make a distinction at checkout
       rev_type = "hash"
 
-    if not os.path.exists(self.checkout_path) or (
-        os.path.isdir(self.checkout_path) and
-        not os.listdir(self.checkout_path)):
-      gclient_utils.safe_makedirs(os.path.dirname(self.checkout_path))
-      self._Clone(revision, url, options)
+    def PostCloneSteps():
       self.UpdateSubmoduleConfig()
       if file_list is not None:
         files = self._Capture(['ls-files']).splitlines()
         file_list.extend([os.path.join(self.checkout_path, f) for f in files])
       if not verbose:
         # Make the output a little prettier. It's nice to have some whitespace
         # between projects when cloning.
         print('')
-      return
+
+    if (os.path.exists(self.checkout_path) and
+        getattr(options, 'stage_clone', None) and
+        not os.path.exists(os.path.join(self.checkout_path, '.git'))):
+      parent_dir = os.path.dirname(self.checkout_path)
+      gclient_utils.safe_makedirs(parent_dir)
+      try:
+        tmp_dir = tempfile.mkdtemp(
+            suffix='_%s' % os.path.basename(self.checkout_path),
+            dir=parent_dir)
+        self._Clone(revision, url, options, clone_path=tmp_dir)
+        src_files = os.listdir(tmp_dir)
+        overlap = set(src_files).intersection(os.listdir(self.checkout_path))
+        if overlap:
+          raise gclient_utils.Error(
+              "%s clone failure. Files exist: %s" % (
+                  self.checkout_path, sorted(overlap)))
+        print('\n_____ copying %s -> %s' % (tmp_dir, self.checkout_path))
+        for src_file in src_files:
+          os.rename(os.path.join(tmp_dir, src_file),
+                    os.path.join(self.checkout_path, src_file))
+        return PostCloneSteps()
+      finally:
+        if os.path.exists(tmp_dir):
+          if os.listdir(tmp_dir):
+            print('\n_____ removing non-empty tmp dir %s' % tmp_dir)
+          gclient_utils.rmtree(tmp_dir)
+    elif not os.path.exists(self.checkout_path) or (
+        os.path.isdir(self.checkout_path) and
+        not os.listdir(self.checkout_path)):
+      gclient_utils.safe_makedirs(os.path.dirname(self.checkout_path))
+      self._Clone(revision, url, options)
+      return PostCloneSteps()
 
     if not managed:
       self._UpdateBranchHeads(options, fetch=False)
       self.UpdateSubmoduleConfig()
       print ('________ unmanaged solution; skipping %s' % self.relpath)
       return
 
     if not os.path.exists(os.path.join(self.checkout_path, '.git')):
       raise gclient_utils.Error('\n____ %s%s\n'
                                 '\tPath is not a git repo. No .git dir.\n'
@@ skipping 28 matching lines @@
       print('_____ %s/.git is corrupted, rebuilding' % self.relpath)
       self._Run(['init'], options)
       self._Run(['remote', 'set-url', 'origin', url], options)
 
     if not self._HasHead():
       # Previous checkout was aborted before branches could be created in repo,
       # so we need to reconstruct them here.
       self._Run(['-c', 'core.deltaBaseCacheLimit=2g', 'pull', 'origin',
                  'master'], options)
       self._FetchAndReset(revision, file_list, options)
-
+ 

[M-A Ruel, 2013/07/16 13:46:32]

.

     cur_branch = self._GetCurrentBranch()
 
     # Cases:
     # 0) HEAD is detached. Probably from our initial clone.
     #   - make sure HEAD is contained by a named ref, then update.
     # Cases 1-4. HEAD is a branch.
     # 1) current branch is not tracking a remote branch (could be git-svn)
     #   - try to rebase onto the new hash or branch
     # 2) current branch is tracking a remote branch with local committed
     #    changes, but the DEPS file switched to point to a hash
@@ skipping 341 matching lines @@
         existing_url = self._Capture(['config', 'remote.origin.url'],
                                      cwd=folder)
         assert self._NormalizeGitURL(existing_url) == self._NormalizeGitURL(url)
 
         # Would normally use `git remote update`, but it doesn't support
         # --progress, so use fetch instead.
         self._Run(['fetch'] + v + ['--multiple', '--progress', '--all'],
                   options, git_filter=True, filter_fn=filter_fn, cwd=folder)
     return folder
 
-  def _Clone(self, revision, url, options):
+  def _Clone(self, revision, url, options, clone_path=None):
     """Clone a git repository from the given URL.
 
     Once we've cloned the repo, we checkout a working branch if the specified
     revision is a branch head. If it is a tag or a specific commit, then we
     leave HEAD detached as it makes future updates simpler -- in this case the
     user should first create a new branch or switch to an existing branch before
     making changes in the repo."""
     if not options.verbose:
       # git clone doesn't seem to insert a newline properly before printing
       # to stdout
       print('')
     template_path = os.path.join(
         os.path.dirname(THIS_FILE_PATH), 'git-templates')
     clone_cmd = ['-c', 'core.deltaBaseCacheLimit=2g', 'clone', '--progress',
                  '--template=%s' % template_path]
     if self.cache_dir:
       clone_cmd.append('--shared')
     if revision.startswith('refs/heads/'):
       clone_cmd.extend(['-b', revision.replace('refs/heads/', '')])
       detach_head = False
     else:
       detach_head = True
     if options.verbose:
       clone_cmd.append('--verbose')
-    clone_cmd.extend([url, self.checkout_path])
+    clone_cmd.extend([url, clone_path or self.checkout_path])
 
     # If the parent directory does not exist, Git clone on Windows will not
     # create it, so we need to do it manually.
     parent_dir = os.path.dirname(self.checkout_path)
     if not os.path.exists(parent_dir):
       gclient_utils.safe_makedirs(parent_dir)
 
     for _ in range(3):
       try:
         self._Run(clone_cmd, options, cwd=self._root_dir, git_filter=True)
@@ skipping 622 matching lines @@
       new_command.append('--force')
       if command[0] != 'checkout' and scm.SVN.AssertVersion('1.6')[0]:
         new_command.extend(('--accept', 'theirs-conflict'))
     elif options.manually_grab_svn_rev:
       new_command.append('--force')
       if command[0] != 'checkout' and scm.SVN.AssertVersion('1.6')[0]:
         new_command.extend(('--accept', 'postpone'))
     elif command[0] != 'checkout' and scm.SVN.AssertVersion('1.6')[0]:
       new_command.extend(('--accept', 'postpone'))
     return new_command