Change CheckCall behavior when print_error=False

scm.py

 # Copyright (c) 2006-2009 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 glob
 import os
 import re
 import shutil
@@ skipping 60 matching lines @@
 
     Returns an array of (status, file) tuples."""
     command = ["diff", "--name-status", "-r", "%s.." % upstream_branch]
     if not files:
       pass
     elif isinstance(files, basestring):
       command.append(files)
     else:
       command.extend(files)
 
-    status = GIT.Capture(command).rstrip()
+    status = GIT.Capture(command)[0].rstrip()
     results = []
     if status:
       for statusline in status.split('\n'):
         m = re.match('^(\w)\t(.+)$', statusline)
         if not m:
           raise Exception("status currently unsupported: %s" % statusline)
         results.append(('%s      ' % m.group(1), m.group(2)))
     return results
 
   @staticmethod
@@ skipping 27 matching lines @@
                                           print_messages,
                                           print_stdout,
                                           filter=filter)
 
   @staticmethod
   def GetEmail(repo_root):
     """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.
     return GIT.Capture(['config', 'user.email'],
-                       repo_root, error_ok=True).strip()
+                       repo_root, error_ok=True)[0].strip()
 
   @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).strip()
+    return GIT.Capture(['symbolic-ref', 'HEAD'], cwd)[0].strip()
 
   @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.
@@ skipping 10 matching lines @@
     # Strategy:
     # 1) find all git-svn branches and note their svn URLs.
     # 2) iterate through our branch history and match up the URLs.
 
     # regexp matching the git-svn line that contains the URL.
     git_svn_re = re.compile(r'^\s*git-svn-id: (\S+)@', re.MULTILINE)
 
     # Get the refname and svn url for all refs/remotes/*.
     remotes = GIT.Capture(
         ['for-each-ref', '--format=%(refname)', 'refs/remotes'],
-        cwd).splitlines()
+        cwd)[0].splitlines()
     svn_refs = {}
     for ref in remotes:
       match = git_svn_re.search(
-          GIT.Capture(['cat-file', '-p', ref], cwd))
+          GIT.Capture(['cat-file', '-p', ref], cwd)[0])
       if match:
         svn_refs[match.group(1)] = ref
 
     svn_branch = ''
     if len(svn_refs) == 1:
       # Only one svn branch exists -- seems like a good candidate.
       svn_branch = svn_refs.values()[0]
     elif len(svn_refs) > 1:
       # We have more than one remote branch available.  We don't
       # want to go through all of history, so read a line from the
@@ skipping 13 matching lines @@
 
   @staticmethod
   def FetchUpstreamTuple(cwd):
     """Returns a tuple containg remote and remote ref,
        e.g. 'origin', 'refs/heads/master'
     """
     remote = '.'
     branch = GIT.GetBranch(cwd)
     upstream_branch = None
     upstream_branch = GIT.Capture(
-        ['config', 'branch.%s.merge' % branch], error_ok=True).strip()
+        ['config', 'branch.%s.merge' % branch], error_ok=True)[0].strip()
     if upstream_branch:
       remote = GIT.Capture(
           ['config', 'branch.%s.remote' % branch],
-          error_ok=True).strip()
+          error_ok=True)[0].strip()
     else:
       # Fall back on trying a git-svn upstream branch.
       if GIT.IsGitSvn(cwd):
         upstream_branch = GIT.GetSVNBranch(cwd)
       # Fall back on origin/master if it exits.
       if not upstream_branch:
-        GIT.Capture(['branch', '-r']).split().count('origin/master')
+        GIT.Capture(['branch', '-r'])[0].split().count('origin/master')
         remote = 'origin'
         upstream_branch = 'refs/heads/master'
     return remote, upstream_branch
 
   @staticmethod
   def GetUpstream(cwd):
     """Gets the current branch's upstream branch."""
     remote, upstream_branch = GIT.FetchUpstreamTuple(cwd)
     if remote is not '.':
       upstream_branch = upstream_branch.replace('heads', 'remotes/' + remote)
     return upstream_branch
 
   @staticmethod
   def GenerateDiff(cwd, branch=None, branch_head='HEAD', full_move=False,
                    files=None):
     """Diffs against the upstream branch or optionally another branch.
 
     full_move means that move or copy operations should completely recreate the
     files, usually in the prospect to apply the patch for a try job."""
     if not branch:
       branch = GIT.GetUpstream(cwd)
     command = ['diff-tree', '-p', '--no-prefix', branch, branch_head]
     if not full_move:
       command.append('-C')
     # TODO(maruel): --binary support.
     if files:
       command.append('--')
       command.extend(files)
-    diff = GIT.Capture(command, cwd).splitlines(True)
+    diff = GIT.Capture(command, cwd)[0].splitlines(True)
     for i in range(len(diff)):
       # In the case of added files, replace /dev/null with the path to the
       # file being added.
       if diff[i].startswith('--- /dev/null'):
         diff[i] = '--- %s' % diff[i+1][4:]
     return ''.join(diff)
 
   @staticmethod
   def GetDifferentFiles(cwd, branch=None, branch_head='HEAD'):
     """Returns the list of modified files between two branches."""
     if not branch:
       branch = GIT.GetUpstream(cwd)
     command = ['diff', '--name-only', branch, branch_head]
-    return GIT.Capture(command, cwd).splitlines(False)
+    return GIT.Capture(command, cwd)[0].splitlines(False)
 
   @staticmethod
   def GetPatchName(cwd):
     """Constructs a name for this patch."""
-    short_sha = GIT.Capture(['rev-parse', '--short=4', 'HEAD'], cwd).strip()
+    short_sha = GIT.Capture(['rev-parse', '--short=4', 'HEAD'], cwd)[0].strip()
     return "%s-%s" % (GIT.GetBranch(cwd), short_sha)
 
   @staticmethod
   def GetCheckoutRoot(path):
     """Returns the top level directory of a git checkout as an absolute path.
     """
-    root = GIT.Capture(['rev-parse', '--show-cdup'], path).strip()
+    root = GIT.Capture(['rev-parse', '--show-cdup'], path)[0].strip()
     return os.path.abspath(os.path.join(path, root))
 
 
 class SVN(object):
   COMMAND = "svn"
 
   @staticmethod
   def Run(args, in_directory):
     """Runs svn, sending output to stdout.
 
@@ skipping 448 matching lines @@
     if not cur_dir_repo_root:
       return None
 
     while True:
       parent = os.path.dirname(directory)
       if (SVN.CaptureInfo(parent, print_error=False).get(
               "Repository Root") != cur_dir_repo_root):
         break
       directory = parent
     return GetCasedPath(directory)