Added remote 'git' branch awareness to 'gclient'

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."""
 
 from __future__ import print_function
 
 import logging
 import os
@@ skipping 258 matching lines @@
 
     The patch file is generated from a diff of the merge base of HEAD and
     its upstream branch.
     """
     merge_base = self._Capture(['merge-base', 'HEAD', self.remote])
     gclient_utils.CheckCallAndFilter(
         ['git', 'diff', merge_base],
         cwd=self.checkout_path,
         filter_fn=GitDiffFilterer(self.relpath).Filter, print_func=self.Print)
 
+  def _ParseRevision(self, revision):
+    """Analyzes a revision string and determines what the repository-local
+    refspec is for that revision.
+
+    This function handles:
+      - Standard local revision paths (refs/heads, refs/remotes)
+        (e.g., refs/heads/master)
+      - Remote-relative mirrored revision paths (e.g., origin/master)
+      - Non-remote revision paths (anything else begining with 'refs/') are
+        assumed to be refs on our remote.
+      - Everything else (branches, commits)
+
+    Params:
+      revision: The revision string, fitting into one of the categories above,
+          to resolve
+
+    Return (dict): Refspec analysis dictionary including:
+      - 'revision' (str): The refspec to use to reference the revision in the
+            local repository (after it's been fetched).
+      - 'type' (str): The type of revision, one of ('branch', 'hash')
+      - 'mapped' (bool): If 'True', the revision is part of the default mapped
+            revision set ('refs/heads/*'); if 'False', it needs to be
+            explicitly fetched before it can be referenced at 'revision'.
+      - 'fetch_refspec' (str): The parameter to use to fetch this revision from
+            its origin.
+    """
+    result = {
+        'revision':       revision,
+        'type':           'branch',
+        'mapped':         True,
+        'fetch_refspec':  revision,
+        }
+    #
+    # If 'revision' begins with some prefixes, chop them off to reference
+    # local refs.
+    for prefix, replacement in (
+        ('refs/heads/', None),
+        ('refs/remotes/%s/' % (self.remote), None),
+        ('%s/' % (self.remote), 'refs/heads/'),
+    ):
+      if revision.startswith(prefix):
+        local_revision = revision[len(prefix):]
+        if replacement is not None:
+          revision = revision.replace(prefix, replacement)
+
+        # Trim 'prefix' to make 'revision' relative to our standard
+        # 'refs/heads/*' fetch mapping.
+        result['revision'] = revision
+        result['fetch_refspec'] = local_revision
+        return result
+
+    # If 'revision' begins with 'refs/', treat it as an unmapped remote ref
+    if revision.startswith('refs/'):
+      result['fetch_refspec'] = '%s:%s' % (revision, revision)
+      result['mapped'] = False
+      return result
+
+    # Assume 'revision' is either a local branch or a commit
+    result['type'] = 'hash'
+    return result
+
+  def _Fetch(self, options, revision=None):
+    cfg = gclient_utils.DefaultIndexPackConfig()
+    fetch_cmd = cfg + ['fetch', self.remote]
+
+    if revision is not None:
+      refdict = self._ParseRevision(revision)
+      fetch_cmd.append(refdict['fetch_refspec'])
+
+    if not options.verbose:
+      fetch_cmd.append('--quiet')
+    fetch_cmd.append('--prune')
+    self._Run(fetch_cmd, options, retry=True)
+
+  def _FetchIfRemote(self, options, revision):
+    refdict = self._ParseRevision(revision)
+    if not refdict['mapped']:
+      self._Fetch(options, revision)
+
   def _FetchAndReset(self, revision, file_list, options):
     """Equivalent to git fetch; git reset."""
+    self._UpdateBranchHeads(options, fetch=False)
+
+    # Fetch default fetch targets ('master'...)
+    self._Fetch(options)
+    # Fetch our specific revision from the remote, if it's not in the default
+    # fetch set.
+    self._FetchIfRemote(options, revision)
+
     quiet = []
     if not options.verbose:
-      quiet = ['--quiet']
-    self._UpdateBranchHeads(options, fetch=False)
-
-    cfg = gclient_utils.DefaultIndexPackConfig(self.url)
-    fetch_cmd = cfg + ['fetch', self.remote, '--prune']
-    self._Run(fetch_cmd + quiet, options, retry=True)
+      quiet.append('--quiet')
     self._Run(['reset', '--hard', revision] + quiet, options)
     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])
 
   def update(self, options, args, file_list):
     """Runs git to update or transparently checkout the working copy.
 
     All updated files will be appended to file_list.
 
@@ skipping 33 matching lines @@
 
     printed_path = False
     verbose = []
     if options.verbose:
       self.Print('_____ %s%s' % (self.relpath, rev_str), timestamp=False)
       verbose = ['--verbose']
       printed_path = True
 
     url = self._CreateOrUpdateCache(url, options)
 
-    if revision.startswith('refs/'):
-      rev_type = "branch"
-    elif revision.startswith(self.remote + '/'):
-      # For compatibility with old naming, translate 'origin' to 'refs/heads'
-      revision = revision.replace(self.remote + '/', 'refs/heads/')
-      rev_type = "branch"
-    else:
-      # hash is also a tag, only make a distinction at checkout
-      rev_type = "hash"
+    refdict = self._ParseRevision(revision)
+    revision = refdict['revision']
+    rev_type = refdict['type']
 
     if (not os.path.exists(self.checkout_path) or
         (os.path.isdir(self.checkout_path) and
          not os.path.exists(os.path.join(self.checkout_path, '.git')))):
       if (os.path.isdir(self.checkout_path) and
           not os.path.exists(os.path.join(self.checkout_path, '.git')) and
           os.listdir(self.checkout_path)):
         # This is a little hack to work around checkouts which are created
         # using "gclient config --name ."
         if not self.relpath == '.':
@@ skipping 418 matching lines @@
     try:
       clone_cmd.append(tmp_dir)
       self._Run(clone_cmd, options, cwd=self._root_dir, retry=True)
       gclient_utils.safe_makedirs(self.checkout_path)
       gclient_utils.safe_rename(os.path.join(tmp_dir, '.git'),
                                 os.path.join(self.checkout_path, '.git'))
     except:
       traceback.print_exc(file=self.out_fh)
       raise
     finally:
-      if os.listdir(tmp_dir):
+      if os.path.exists(tmp_dir) and os.listdir(tmp_dir):

[dnj (Google), 2014/04/24 19:30:44]

A bit unrelated, but I did hit this case when 'listdir' was called and the
directory was not created.

         self.Print('_____ removing non-empty tmp dir %s' % tmp_dir)
       gclient_utils.rmtree(tmp_dir)
+
+    # Fetch our specific revision
+    self._FetchIfRemote(options, revision)
+
     if revision.startswith('refs/heads/'):
       self._Run(
           ['checkout', '--quiet', revision.replace('refs/heads/', '')], options)
     else:
       # Squelch git's very verbose detached HEAD warning and use our own
       self._Run(['checkout', '--quiet', revision], options)
       self.Print(
         ('Checked out %s to a detached HEAD. Before making any commits\n'
          'in this repo, you should use \'git checkout <branch>\' to switch to\n'
          'an existing branch or use \'git checkout %s -b <branch>\' to\n'
@@ skipping 164 matching lines @@
     return subprocess2.check_output(['git'] + args, env=env, **kwargs).strip()
 
   def _UpdateBranchHeads(self, options, fetch=False):
     """Adds, and optionally fetches, "branch-heads" refspecs if requested."""
     if hasattr(options, 'with_branch_heads') and options.with_branch_heads:
       config_cmd = ['config', 'remote.%s.fetch' % self.remote,
                     '+refs/branch-heads/*:refs/remotes/branch-heads/*',
                     '^\\+refs/branch-heads/\\*:.*$']
       self._Run(config_cmd, options)
       if fetch:
-        cfg = gclient_utils.DefaultIndexPackConfig(self.url)
-        fetch_cmd =  cfg + ['fetch', self.remote]
-        if options.verbose:
-          fetch_cmd.append('--verbose')
-        self._Run(fetch_cmd, options, retry=True)
+        self._Fetch(options)
 
   def _Run(self, args, options, **kwargs):
     cwd = kwargs.setdefault('cwd', self.checkout_path)
     kwargs.setdefault('stdout', self.out_fh)
     kwargs['filter_fn'] = self.filter
     kwargs.setdefault('print_stdout', False)
     env = scm.GIT.ApplyEnvVars(kwargs)
     cmd = ['git'] + args
     header = "running '%s' in '%s'" % (' '.join(cmd), cwd)
     self.filter(header)
@@ skipping 462 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