Misc gclient cleanup

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.
 
 """SCM-specific utility classes."""
 
 import cStringIO
 import glob
 import logging
 import os
@@ skipping 82 matching lines @@
     return 0
 
 
 class GIT(object):
   current_version = None
 
   @staticmethod
   def Capture(args, cwd, **kwargs):
     return subprocess2.check_output(
         ['git', '--no-pager'] + args,
-        cwd=cwd, stderr=subprocess2.PIPE, **kwargs)
+        cwd=cwd, stderr=subprocess2.PIPE, **kwargs).strip()
 
   @staticmethod
   def CaptureStatus(files, cwd, upstream_branch):
     """Returns git status.
 
     @files can be a string (one file) or a list of files.
 
     Returns an array of (status, file) tuples."""
     if upstream_branch is None:
       upstream_branch = GIT.GetUpstreamBranch(cwd)
       if upstream_branch is None:
         raise gclient_utils.Error('Cannot determine upstream branch')
     command = ['diff', '--name-status', '--no-renames',
                '-r', '%s...' % upstream_branch]
     if not files:
       pass
     elif isinstance(files, basestring):
       command.append(files)
     else:
       command.extend(files)
-    status = GIT.Capture(command, cwd).rstrip()
+    status = GIT.Capture(command, cwd)
     results = []
     if status:
       for statusline in status.splitlines():
         # 3-way merges can cause the status can be 'MMM' instead of 'M'. This
         # can happen when the user has 2 local branches and he diffs between
         # these 2 branches instead diffing to upstream.
         m = re.match('^(\w)+\t(.+)$', statusline)
         if not m:
           raise gclient_utils.Error(
               'status currently unsupported: %s' % statusline)
         # Only grab the first letter.
         results.append(('%s      ' % m.group(1)[0], m.group(2)))
     return results
 
   @staticmethod
   def GetEmail(cwd):
     """Retrieves the user email address if known."""
     # We could want to look at the svn cred when it has a svn remote but it
     # should be fine for now, users should simply configure their git settings.
     try:
-      return GIT.Capture(['config', 'user.email'], cwd=cwd).strip()
+      return GIT.Capture(['config', 'user.email'], cwd=cwd)
     except subprocess2.CalledProcessError:
       return ''
 
   @staticmethod
   def ShortBranchName(branch):
     """Converts a name like 'refs/heads/foo' to just 'foo'."""
     return branch.replace('refs/heads/', '')
 
   @staticmethod
   def GetBranchRef(cwd):
     """Returns the full branch reference, e.g. 'refs/heads/master'."""
-    return GIT.Capture(['symbolic-ref', 'HEAD'], cwd=cwd).strip()
+    return GIT.Capture(['symbolic-ref', 'HEAD'], cwd=cwd)
 
   @staticmethod
   def GetBranch(cwd):
     """Returns the short branch name, e.g. 'master'."""
     return GIT.ShortBranchName(GIT.GetBranchRef(cwd))
 
   @staticmethod
   def IsGitSvn(cwd):
     """Returns true if this repo looks like it's using git-svn."""
     # If you have any "svn-remote.*" config keys, we think you're using svn.
     try:
-      GIT.Capture(['config', '--get-regexp', r'^svn-remote\.'], cwd=cwd)
+      GIT.Capture(['config', '--local', '--get-regexp', r'^svn-remote\.'],
+                  cwd=cwd)
       return True
     except subprocess2.CalledProcessError:
       return False
 
   @staticmethod
   def MatchSvnGlob(url, base_url, glob_spec, allow_wildcards):
     """Return the corresponding git ref if |base_url| together with |glob_spec|
     matches the full |url|.
 
     If |allow_wildcards| is true, |glob_spec| can contain wildcards (see below).
@@ skipping 53 matching lines @@
     for line in proc.stdout:
       match = git_svn_re.match(line)
       if match:
         url = match.group(1)
         proc.stdout.close()  # Cut pipe.
         break
 
     if url:
       svn_remote_re = re.compile(r'^svn-remote\.([^.]+)\.url (.*)$')
       remotes = GIT.Capture(
-          ['config', '--get-regexp', r'^svn-remote\..*\.url'],
+          ['config', '--local', '--get-regexp', r'^svn-remote\..*\.url'],
           cwd=cwd).splitlines()
       for remote in remotes:
         match = svn_remote_re.match(remote)
         if match:
           remote = match.group(1)
           base_url = match.group(2)
           try:
             fetch_spec = GIT.Capture(
-                ['config', 'svn-remote.%s.fetch' % remote],
-                cwd=cwd).strip()
+                ['config', '--local', 'svn-remote.%s.fetch' % remote],
+                cwd=cwd)
             branch = GIT.MatchSvnGlob(url, base_url, fetch_spec, False)
           except subprocess2.CalledProcessError:
             branch = None
           if branch:
             return branch
           try:
             branch_spec = GIT.Capture(
-                ['config', 'svn-remote.%s.branches' % remote],
-                cwd=cwd).strip()
+                ['config', '--local', 'svn-remote.%s.branches' % remote],
+                cwd=cwd)
             branch = GIT.MatchSvnGlob(url, base_url, branch_spec, True)
           except subprocess2.CalledProcessError:
             branch = None
           if branch:
             return branch
           try:
             tag_spec = GIT.Capture(
-                ['config', 'svn-remote.%s.tags' % remote],
-                cwd=cwd).strip()
+                ['config', '--local', 'svn-remote.%s.tags' % remote],
+                cwd=cwd)
             branch = GIT.MatchSvnGlob(url, base_url, tag_spec, True)
           except subprocess2.CalledProcessError:
             branch = None
           if branch:
             return branch
 
   @staticmethod
   def FetchUpstreamTuple(cwd):
     """Returns a tuple containg remote and remote ref,
        e.g. 'origin', 'refs/heads/master'
        Tries to be intelligent and understand git-svn.
     """
     remote = '.'
     branch = GIT.GetBranch(cwd)
     try:
       upstream_branch = GIT.Capture(
-          ['config', 'branch.%s.merge' % branch], cwd=cwd).strip()
+          ['config', '--local', 'branch.%s.merge' % branch], cwd=cwd)
     except subprocess2.CalledProcessError:
       upstream_branch = None
     if upstream_branch:
       try:
         remote = GIT.Capture(
-            ['config', 'branch.%s.remote' % branch], cwd=cwd).strip()
+            ['config', '--local', 'branch.%s.remote' % branch], cwd=cwd)
       except subprocess2.CalledProcessError:
         pass
     else:
       try:
         upstream_branch = GIT.Capture(
-            ['config', 'rietveld.upstream-branch'], cwd=cwd).strip()
+            ['config', '--local', 'rietveld.upstream-branch'], cwd=cwd)
       except subprocess2.CalledProcessError:
         upstream_branch = None
       if upstream_branch:
         try:
           remote = GIT.Capture(
-              ['config', 'rietveld.upstream-remote'], cwd=cwd).strip()
+              ['config', '--local', 'rietveld.upstream-remote'], cwd=cwd)
         except subprocess2.CalledProcessError:
           pass
       else:
         # Fall back on trying a git-svn upstream branch.
         if GIT.IsGitSvn(cwd):
           upstream_branch = GIT.GetSVNBranch(cwd)
         else:
           # Else, try to guess the origin remote.
           remote_branches = GIT.Capture(['branch', '-r'], cwd=cwd).split()
           if 'origin/master' in remote_branches:
@@ skipping 50 matching lines @@
   def GetDifferentFiles(cwd, branch=None, branch_head='HEAD'):
     """Returns the list of modified files between two branches."""
     if not branch:
       branch = GIT.GetUpstreamBranch(cwd)
     command = ['diff', '--name-only', branch + "..." + branch_head]
     return GIT.Capture(command, cwd=cwd).splitlines(False)
 
   @staticmethod
   def GetPatchName(cwd):
     """Constructs a name for this patch."""
-    short_sha = GIT.Capture(['rev-parse', '--short=4', 'HEAD'], cwd=cwd).strip()
+    short_sha = GIT.Capture(['rev-parse', '--short=4', 'HEAD'], cwd=cwd)
     return "%s#%s" % (GIT.GetBranch(cwd), short_sha)
 
   @staticmethod
   def GetCheckoutRoot(cwd):
     """Returns the top level directory of a git checkout as an absolute path.
     """
-    root = GIT.Capture(['rev-parse', '--show-cdup'], cwd=cwd).strip()
+    root = GIT.Capture(['rev-parse', '--show-cdup'], cwd=cwd)
     return os.path.abspath(os.path.join(cwd, root))
 
   @staticmethod
   def GetGitSvnHeadRev(cwd):
     """Gets the most recently pulled git-svn revision."""
     try:
       output = GIT.Capture(['svn', 'info'], cwd=cwd)
       match = re.search(r'^Revision: ([0-9]+)$', output, re.MULTILINE)
       return int(match.group(1)) if match else None
     except (subprocess2.CalledProcessError, ValueError):
@@ skipping 38 matching lines @@
       if not sha1:
         return None
       output = GIT.Capture(['rev-list', '-n', '1', '%s^1' % sha1], cwd=cwd)
       if git_svn_rev != output.rstrip():
         raise gclient_utils.Error(sha1)
       return sha1
     except subprocess2.CalledProcessError:
       return None
 
   @staticmethod
-  def IsValidRevision(cwd, rev):
-    """Verifies the revision is a proper git revision."""
+  def IsValidRevision(cwd, rev, sha_only=False):
+    """Verifies the revision is a proper git revision.
+
+    sha_only: Fail unless rev is a sha hash.
+    """
     # 'git rev-parse foo' where foo is *any* 40 character hex string will return
     # the string and return code 0. So strip one character to force 'git
     # rev-parse' to do a hash table look-up and returns 128 if the hash is not
     # present.
+    lookup_rev = rev
     if re.match(r'^[0-9a-fA-F]{40}$', rev):
-      rev = rev[:-1]
+      lookup_rev = rev[:-1]
     try:
-      GIT.Capture(['rev-parse', rev], cwd=cwd)
+      sha = GIT.Capture(['rev-parse', lookup_rev], cwd=cwd)
+      if lookup_rev != rev:
+        # Make sure we get the original 40 chars back.
+        return rev == sha

[M-A Ruel, 2013/07/08 18:44:41]

what about lower/upper case?
return rev.lower() == sha.lower()

[Isaac (away), 2013/07/08 20:03:34]

Good point.  It looks like git always returns lower case characters but I'll add
lower() on git output for safety.  I'll send out a follow up CL.

+      if sha_only:
+        return sha.startswith(rev)

[M-A Ruel, 2013/07/08 18:44:41]

sha.lower().startswith(rev.lower())

       return True
     except subprocess2.CalledProcessError:
       return False
 
   @classmethod
   def AssertVersion(cls, min_version):
     """Asserts git's version is at least min_version."""
     if cls.current_version is None:
       current_version = cls.Capture(['--version'], '.')
       matched = re.search(r'version ([0-9\.]+)', current_version)
@@ skipping 627 matching lines @@
         # revert, like for properties.
         if not os.path.isdir(cwd):
           # '.' was deleted. It's not worth continuing.
           return
         try:
           SVN.Capture(['revert', file_status[1]], cwd=cwd)
         except subprocess2.CalledProcessError:
           if not os.path.exists(file_path):
             continue
           raise