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 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 == '.':
           self._DeleteOrMove(options.force)
       self._Clone(revision, url, options)
-      self._UpdateBranchHeads(options, fetch=True)
+      self._UpdateBranchHeads(options, fetch_revision=revision)
       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.
         self.Print('')
       return self._Capture(['rev-parse', '--verify', 'HEAD'])
 
     if not managed:
-      self._UpdateBranchHeads(options, fetch=False)
+      self._UpdateBranchHeads(options)
       self.Print('________ unmanaged solution; skipping %s' % self.relpath)
       return self._Capture(['rev-parse', '--verify', 'HEAD'])
 
     # See if the url has changed (the unittests use git://foo for the url, let
     # that through).
     current_url = self._Capture(['config', 'remote.%s.url' % self.remote])
     return_early = False
     # TODO(maruel): Delete url != 'git://foo' since it's just to make the
     # unit test pass. (and update the comment above)
     # Skip url auto-correction if remote.origin.gclient-auto-fix-url is set.
@@ skipping 52 matching lines @@
       else:
         raise gclient_utils.Error('Invalid Upstream: %s' % upstream_branch)
 
     if not scm.GIT.IsValidRevision(self.checkout_path, revision, sha_only=True):
       # Update the remotes first so we have all the refs.
       remote_output = scm.GIT.Capture(['remote'] + verbose + ['update'],
               cwd=self.checkout_path)
       if verbose:
         self.Print(remote_output)
 
-      self._UpdateBranchHeads(options, fetch=True)
+      self._UpdateBranchHeads(options, fetch_revision=revision)
 
     # This is a big hammer, debatable if it should even be here...
     if options.force or options.reset:
       target = 'HEAD'
       if options.upstream and upstream_branch:
         target = upstream_branch
       self._Run(['reset', '--hard', target], options)
 
     if current_type == 'detached':
       # case 0
@@ skipping 325 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):
         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 156 matching lines @@
     if branch == 'HEAD':
       return None
     return branch
 
   def _Capture(self, args, **kwargs):
     kwargs.setdefault('cwd', self.checkout_path)
     kwargs.setdefault('stderr', subprocess2.PIPE)
     env = scm.GIT.ApplyEnvVars(kwargs)
     return subprocess2.check_output(['git'] + args, env=env, **kwargs).strip()
 
-  def _UpdateBranchHeads(self, options, fetch=False):
+  def _UpdateBranchHeads(self, options, fetch_revision=None):
     """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)
+      if fetch_revision is not None:
+        self._Fetch(options)
+
+    if fetch_revision is not None:
+      self._FetchIfRemote(options, fetch_revision)
 
   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