Make gclient_scm_test much more silent

gclient_scm.py

 # Copyright (c) 2010 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 logging
 import os
 import posixpath
 import re
@@ skipping 240 matching lines @@
                       " branch.")
       elif upstream_branch.startswith('refs/remotes'):
         current_type = "branch"
       else:
         raise gclient_utils.Error('Invalid Upstream: %s' % upstream_branch)
 
     # Update the remotes first so we have all the refs.
     backoff_time = 5
     for _ in range(10):
       try:
-        remote_output, remote_err = scm.GIT.Capture(
+        remote_output = scm.GIT.Capture(
             ['remote'] + verbose + ['update'],
-            self.checkout_path,
-            print_error=False)
+            cwd=self.checkout_path)
         break
       except gclient_utils.CheckCallError, e:
         # Hackish but at that point, git is known to work so just checking for
         # 502 in stderr should be fine.
         if '502' in e.stderr:
           options.stdout.write(str(e) + '\n')
           options.stdout.write('Sleeping %.1f seconds and retrying...\n' %
                                backoff_time)
           time.sleep(backoff_time)
           backoff_time *= 1.3
           continue
         raise
 
     if verbose:
-      options.stdout.write(remote_output.strip() + '\n')
-      # git remote update prints to stderr when used with --verbose
-      options.stdout.write(remote_err.strip() + '\n')
+      options.stdout.write(remote_output)
 
     # This is a big hammer, debatable if it should even be here...
     if options.force or options.reset:
       self._Run(['reset', '--hard', 'HEAD'], options)
 
     if current_type == 'detached':
       # case 0
       self._CheckClean(rev_str)
       self._CheckDetachedHead(rev_str, options)
       self._Capture(['checkout', '--quiet', '%s^0' % revision])
@@ skipping 32 matching lines @@
                      "cd %s; git rebase %s\n" % (self.checkout_path, new_base) +
                      "OR git checkout -b <some new branch> %s" % new_base)
       raise gclient_utils.Error(switch_error)
     else:
       # case 3 - the default case
       files = self._Capture(['diff', upstream_branch, '--name-only']).split()
       if verbose:
         options.stdout.write('Trying fast-forward merge to branch : %s\n' %
             upstream_branch)
       try:
-        merge_output, merge_err = scm.GIT.Capture(['merge', '--ff-only',
-                                                   upstream_branch],
-                                                  self.checkout_path,
-                                                  print_error=False)
+        merge_output = scm.GIT.Capture(['merge', '--ff-only', upstream_branch],
+            cwd=self.checkout_path)
       except gclient_utils.CheckCallError, e:
         if re.match('fatal: Not possible to fast-forward, aborting.', e.stderr):
           if not printed_path:
             options.stdout.write('\n_____ %s%s\n' % (self.relpath, rev_str))
             printed_path = True
           while True:
             try:
-              # TODO(maruel): That can't work.
+              # TODO(maruel): That can't work with --jobs.
               action = str(raw_input("Cannot fast-forward merge, attempt to "
                                      "rebase? (y)es / (q)uit / (s)kip : "))
             except ValueError:
               gclient_utils.Error('Invalid Character')
               continue
             if re.match(r'yes|y', action, re.I):
               self._AttemptRebase(upstream_branch, files, options,
                                   printed_path=printed_path)
               printed_path = True
               break
@@ skipping 19 matching lines @@
           # Some other problem happened with the merge
           logging.error("Error during fast-forward merge in %s!" % self.relpath)
           options.stdout.write(e.stderr + '\n')
           raise
       else:
         # Fast-forward merge was successful
         if not re.match('Already up-to-date.', merge_output) or verbose:
           if not printed_path:
             options.stdout.write('\n_____ %s%s\n' % (self.relpath, rev_str))
             printed_path = True
-          print merge_output.strip()
-          if merge_err:
-            options.stdout.write('Merge produced error output:\n%s\n' %
-                merge_err.strip())
+          options.stdout.write(merge_output)
           if not verbose:
             # Make the output a little prettier. It's nice to have some
             # whitespace between projects when syncing.
             options.stdout.write('\n')
 
     file_list.extend([os.path.join(self.checkout_path, f) for f in files])
 
     # If the rebase generated a conflict, abort and ask user to fix
     if self._IsRebasing():
       raise gclient_utils.Error('\n____ %s%s\n'
@@ skipping 124 matching lines @@
     rebase_cmd = ['rebase']
     if options.verbose:
       rebase_cmd.append('--verbose')
     if newbase:
       rebase_cmd.extend(['--onto', newbase])
     rebase_cmd.append(upstream)
     if branch:
       rebase_cmd.append(branch)
 
     try:
-      rebase_output, rebase_err = scm.GIT.Capture(rebase_cmd,
-                                                  self.checkout_path,
-                                                  print_error=False)
+      rebase_output = scm.GIT.Capture(rebase_cmd, cwd=self.checkout_path)
     except gclient_utils.CheckCallError, e:
-      if re.match(r'cannot rebase: you have unstaged changes', e.stderr) or \
-         re.match(r'cannot rebase: your index contains uncommitted changes',
-                  e.stderr):
+      if (re.match(r'cannot rebase: you have unstaged changes', e.stderr) or
+          re.match(r'cannot rebase: your index contains uncommitted changes',
+                   e.stderr)):
         while True:
           rebase_action = str(raw_input("Cannot rebase because of unstaged "
                                         "changes.\n'git reset --hard HEAD' ?\n"
                                         "WARNING: destroys any uncommitted "
                                         "work in your current branch!"
                                         " (y)es / (q)uit / (s)how : "))
           if re.match(r'yes|y', rebase_action, re.I):
             self._Run(['reset', '--hard', 'HEAD'], options)
             # Should this be recursive?
-            rebase_output, rebase_err = scm.GIT.Capture(rebase_cmd,
-                                                        self.checkout_path)
+            rebase_output = scm.GIT.Capture(rebase_cmd, cwd=self.checkout_path)
             break
           elif re.match(r'quit|q', rebase_action, re.I):
             raise gclient_utils.Error("Please merge or rebase manually\n"
                                       "cd %s && git " % self.checkout_path
                                       + "%s" % ' '.join(rebase_cmd))
           elif re.match(r'show|s', rebase_action, re.I):
             options.stdout.write('\n%s\n' % e.stderr.strip())
             continue
           else:
             gclient_utils.Error("Input not recognized")
             continue
       elif re.search(r'^CONFLICT', e.stdout, re.M):
         raise gclient_utils.Error("Conflict while rebasing this branch.\n"
                                   "Fix the conflict and run gclient again.\n"
                                   "See 'man git-rebase' for details.\n")
       else:
         options.stdout.write(e.stdout.strip() + '\n')
         options.stdout.write('Rebase produced error output:\n%s\n' %
             e.stderr.strip())
         raise gclient_utils.Error("Unrecognized error, please merge or rebase "
                                   "manually.\ncd %s && git " %
                                   self.checkout_path
                                   + "%s" % ' '.join(rebase_cmd))
 
-    print rebase_output.strip()
-    if rebase_err:
-      options.stdout.write('Rebase produced error output:\n%s\n' %
-          rebase_err.strip())
+    options.stdout.write(rebase_output)
     if not options.verbose:
       # Make the output a little prettier. It's nice to have some
       # whitespace between projects when syncing.
       options.stdout.write('\n')
 
   @staticmethod
   def _CheckMinVersion(min_version):
     (ok, current_version) = scm.GIT.AssertVersion(min_version)
     if not ok:
       raise gclient_utils.Error('git version %s < minimum required %s' %
                                 (current_version, min_version))
 
   def _IsRebasing(self):
     # Check for any of REBASE-i/REBASE-m/REBASE/AM. Unfortunately git doesn't
     # have a plumbing command to determine whether a rebase is in progress, so
     # for now emualate (more-or-less) git-rebase.sh / git-completion.bash
     g = os.path.join(self.checkout_path, '.git')
     return (
       os.path.isdir(os.path.join(g, "rebase-merge")) or
       os.path.isdir(os.path.join(g, "rebase-apply")))
 
   def _CheckClean(self, rev_str):
     # Make sure the tree is clean; see git-rebase.sh for reference
     try:
       scm.GIT.Capture(['update-index', '--ignore-submodules', '--refresh'],
-                      self.checkout_path, print_error=False)
+                      cwd=self.checkout_path)
     except gclient_utils.CheckCallError:
       raise gclient_utils.Error('\n____ %s%s\n'
                                 '\tYou have unstaged changes.\n'
                                 '\tPlease commit, stash, or reset.\n'
                                   % (self.relpath, rev_str))
     try:
       scm.GIT.Capture(['diff-index', '--cached', '--name-status', '-r',
-                       '--ignore-submodules', 'HEAD', '--'], self.checkout_path,
-                       print_error=False)
+                       '--ignore-submodules', 'HEAD', '--'],
+                       cwd=self.checkout_path)
     except gclient_utils.CheckCallError:
       raise gclient_utils.Error('\n____ %s%s\n'
                                 '\tYour index contains uncommitted changes\n'
                                 '\tPlease commit, stash, or reset.\n'
                                   % (self.relpath, rev_str))
 
   def _CheckDetachedHead(self, rev_str, options):
     # HEAD is detached. Make sure it is safe to move away from (i.e., it is
     # reference by a commit). If not, error out -- most likely a rebase is
     # in progress, try to detect so we can give a better error.
     try:
-      _, _ = scm.GIT.Capture(
-        ['name-rev', '--no-undefined', 'HEAD'],
-        self.checkout_path,
-        print_error=False)
+      scm.GIT.Capture(['name-rev', '--no-undefined', 'HEAD'],
+          cwd=self.checkout_path)
     except gclient_utils.CheckCallError:
       # Commit is not contained by any rev. See if the user is rebasing:
       if self._IsRebasing():
         # Punt to the user
         raise gclient_utils.Error('\n____ %s%s\n'
                                   '\tAlready in a conflict, i.e. (no branch).\n'
                                   '\tFix the conflict and run gclient again.\n'
                                   '\tOr to abort run:\n\t\tgit-rebase --abort\n'
                                   '\tSee man git-rebase for details.\n'
                                    % (self.relpath, rev_str))
       # Let's just save off the commit so we can proceed.
       name = ('saved-by-gclient-' +
               self._Capture(['rev-parse', '--short', 'HEAD']))
       self._Capture(['branch', name])
       options.stdout.write(
           '\n_____ found an unreferenced commit and saved it as \'%s\'\n' %
           name)
 
   def _GetCurrentBranch(self):
     # Returns name of current branch or None for detached HEAD
     branch = self._Capture(['rev-parse', '--abbrev-ref=strict', 'HEAD'])
     if branch == 'HEAD':
       return None
     return branch
 
   def _Capture(self, args):
-    return gclient_utils.CheckCall(['git'] + args,
-                                   cwd=self.checkout_path)[0].strip()
+    return gclient_utils.CheckCall(
+        ['git'] + args, cwd=self.checkout_path, print_error=False)[0].strip()
 
   def _Run(self, args, options, **kwargs):
     kwargs.setdefault('cwd', self.checkout_path)
     gclient_utils.CheckCallAndFilterAndHeader(['git'] + args,
         always=options.verbose, stdout=options.stdout, **kwargs)
 
 
 class SVNWrapper(SCMWrapper):
   """ Wrapper for SVN """
 
@@ skipping 296 matching lines @@
 
     This method returns a new list to be used as a command."""
     new_command = command[:]
     if revision:
       new_command.extend(['--revision', str(revision).strip()])
     # --force was added to 'svn update' in svn 1.5.
     if ((options.force or options.manually_grab_svn_rev) and
         scm.SVN.AssertVersion("1.5")[0]):
       new_command.append('--force')
     return new_command