Split _Run() in two to make redirection simpler in a later change.

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 109 matching lines @@
   """Wrapper for Git"""
 
   @staticmethod
   def cleanup(options, args, file_list):
     """'Cleanup' the repo.
 
     There's no real git equivalent for the svn cleanup command, do a no-op.
     """
 
   def diff(self, options, args, file_list):
-    merge_base = self._Run(['merge-base', 'HEAD', 'origin'])
-    self._Run(['diff', merge_base], redirect_stdout=False)
+    merge_base = self._Capture(['merge-base', 'HEAD', 'origin'])
+    self._Run(['diff', merge_base])
 
   def export(self, options, args, file_list):
     """Export a clean directory tree into the given path.
 
     Exports into the specified directory, creating the path if it does
     already exist.
     """
     assert len(args) == 1
     export_path = os.path.abspath(os.path.join(args[0], self.relpath))
     if not os.path.exists(export_path):
       os.makedirs(export_path)
-    self._Run(['checkout-index', '-a', '--prefix=%s/' % export_path],
-              redirect_stdout=False)
+    self._Run(['checkout-index', '-a', '--prefix=%s/' % export_path])
 
   def pack(self, options, args, file_list):
     """Generates a patch file which can be applied to the root of the
     repository.
 
     The patch file is generated from a diff of the merge base of HEAD and
     its upstream branch.
     """
-    merge_base = self._Run(['merge-base', 'HEAD', 'origin'])
+    merge_base = self._Capture(['merge-base', 'HEAD', 'origin'])
     gclient_utils.CheckCallAndFilter(
         ['git', 'diff', merge_base],
         cwd=self.checkout_path,
         filter_fn=DiffFilterer(self.relpath, options.stdout).Filter,
         stdout=options.stdout)
 
   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 31 matching lines @@
     elif revision.startswith('origin/'):
       # For compatability with old naming, translate 'origin' to 'refs/heads'
       revision = revision.replace('origin/', 'refs/heads/')
       rev_type = "branch"
     else:
       # hash is also a tag, only make a distinction at checkout
       rev_type = "hash"
 
     if not os.path.exists(self.checkout_path):
       self._Clone(revision, url, options)
-      files = self._Run(['ls-files']).split()
+      files = self._Capture(['ls-files']).split()
       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.
         options.stdout.write('\n')
       return
 
     if not os.path.exists(os.path.join(self.checkout_path, '.git')):
       raise gclient_utils.Error('\n____ %s%s\n'
                                 '\tPath is not a git repo. No .git dir.\n'
@@ skipping 60 matching lines @@
           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')
 
     # This is a big hammer, debatable if it should even be here...
     if options.force or options.reset:
-      self._Run(['reset', '--hard', 'HEAD'], redirect_stdout=False)
+      self._Run(['reset', '--hard', 'HEAD'])
 
     if current_type == 'detached':
       # case 0
       self._CheckClean(rev_str)
       self._CheckDetachedHead(rev_str, options)
-      self._Run(['checkout', '--quiet', '%s^0' % revision])
+      self._Capture(['checkout', '--quiet', '%s^0' % revision])
       if not printed_path:
         options.stdout.write('\n_____ %s%s\n' % (self.relpath, rev_str))
     elif current_type == 'hash':
       # case 1
       if scm.GIT.IsGitSvn(self.checkout_path) and upstream_branch is not None:
         # Our git-svn branch (upstream_branch) is our upstream
         self._AttemptRebase(upstream_branch, files, options,
                             newbase=revision, printed_path=printed_path)
         printed_path = True
       else:
@@ skipping 17 matching lines @@
       if not printed_path:
         options.stdout.write('\n_____ %s%s\n' % (self.relpath, rev_str))
       switch_error = ("Switching upstream branch from %s to %s\n"
                      % (upstream_branch, new_base) +
                      "Please merge or rebase manually:\n" +
                      "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._Run(['diff', upstream_branch, '--name-only']).split()
+      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)
       except gclient_utils.CheckCallError, e:
         if re.match('fatal: Not possible to fast-forward, aborting.', e.stderr):
@@ skipping 78 matching lines @@
       # Don't reuse the args.
       return self.update(options, [], file_list)
 
     default_rev = "refs/heads/master"
     _, deps_revision = gclient_utils.SplitUrlRevision(self.url)
     if not deps_revision:
       deps_revision = default_rev
     if deps_revision.startswith('refs/heads/'):
       deps_revision = deps_revision.replace('refs/heads/', 'origin/')
 
-    files = self._Run(['diff', deps_revision, '--name-only']).split()
-    self._Run(['reset', '--hard', deps_revision], redirect_stdout=False)
+    files = self._Capture(['diff', deps_revision, '--name-only']).split()
+    self._Run(['reset', '--hard', deps_revision])
     file_list.extend([os.path.join(self.checkout_path, f) for f in files])
 
   def revinfo(self, options, args, file_list):
-    """Display revision"""
-    return self._Run(['rev-parse', 'HEAD'])
+    """Returns revision"""
+    return self._Capture(['rev-parse', 'HEAD'])
 
   def runhooks(self, options, args, file_list):
     self.status(options, args, file_list)
 
   def status(self, options, args, file_list):
     """Display status information."""
     if not os.path.isdir(self.checkout_path):
       options.stdout.write(
           ('\n________ couldn\'t run status in %s:\nThe directory '
            'does not exist.\n') % self.checkout_path)
     else:
-      merge_base = self._Run(['merge-base', 'HEAD', 'origin'])
-      self._Run(['diff', '--name-status', merge_base], redirect_stdout=False)
-      files = self._Run(['diff', '--name-only', merge_base]).split()
+      merge_base = self._Capture(['merge-base', 'HEAD', 'origin'])
+      self._Run(['diff', '--name-status', merge_base])
+      files = self._Capture(['diff', '--name-only', merge_base]).split()
       file_list.extend([os.path.join(self.checkout_path, f) for f in files])
 
   def FullUrlForRelativeUrl(self, url):
     # Strip from last '/'
     # Equivalent to unix basename
     base_url = self.url
     return base_url[:base_url.rfind('/')] + url
 
   def _Clone(self, revision, url, options):
     """Clone a git repository from the given URL.
@@ skipping 14 matching lines @@
       detach_head = False
     else:
       clone_cmd.append('--no-checkout')
       detach_head = True
     if options.verbose:
       clone_cmd.append('--verbose')
     clone_cmd.extend([url, self.checkout_path])
 
     for _ in range(3):
       try:
-        self._Run(clone_cmd, cwd=self._root_dir, redirect_stdout=False)
+        self._Run(clone_cmd, cwd=self._root_dir)
         break
       except gclient_utils.Error, e:
         # TODO(maruel): Hackish, should be fixed by moving _Run() to
         # CheckCall().
         # Too bad we don't have access to the actual output.
         # We should check for "transfer closed with NNN bytes remaining to
         # read". In the meantime, just make sure .git exists.
         if (e.args[0] == 'git command clone returned 128' and
             os.path.exists(os.path.join(self.checkout_path, '.git'))):
           options.stdout.write(str(e) + '\n')
           options.stdout.write('Retrying...\n')
           continue
         raise e
 
     if detach_head:
       # Squelch git's very verbose detached HEAD warning and use our own
-      self._Run(['checkout', '--quiet', '%s^0' % revision])
+      self._Capture(['checkout', '--quiet', '%s^0' % revision])
       options.stdout.write(
         ('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 origin -b <branch>\' to\n'
          'create a new branch for your work.') % revision)
 
   def _AttemptRebase(self, upstream, files, options, newbase=None,
                      branch=None, printed_path=False):
     """Attempt to rebase onto either upstream or, if specified, newbase."""
-    files.extend(self._Run(['diff', upstream, '--name-only']).split())
+    files.extend(self._Capture(['diff', upstream, '--name-only']).split())
     revision = upstream
     if newbase:
       revision = newbase
     if not printed_path:
       options.stdout.write('\n_____ %s : Attempting rebase onto %s...\n' % (
           self.relpath, revision))
       printed_path = True
     else:
       options.stdout.write('Attempting rebase onto %s...\n' % revision)
 
@@ skipping 16 matching lines @@
       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'], redirect_stdout=False)
+            self._Run(['reset', '--hard', 'HEAD'])
             # Should this be recursive?
             rebase_output, rebase_err = scm.GIT.Capture(rebase_cmd,
                                                         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())
@@ skipping 72 matching lines @@
       # 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._Run(["rev-parse", "--short", "HEAD"])
-      self._Run(["branch", name])
+      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._Run(['rev-parse', '--abbrev-ref=strict', 'HEAD'])
+    branch = self._Capture(['rev-parse', '--abbrev-ref=strict', 'HEAD'])
     if branch == 'HEAD':
       return None
     return branch
 
-  def _Run(self, args, cwd=None, redirect_stdout=True):
-    # TODO(maruel): Merge with Capture or better gclient_utils.CheckCall().
-    if cwd is None:
-      cwd = self.checkout_path
-    stdout = None
-    if redirect_stdout:
-      stdout = subprocess.PIPE
-    if cwd == None:
-      cwd = self.checkout_path
-    cmd = ['git'] + args
-    logging.debug(cmd)
+  def _Capture(self, args):
+    return gclient_utils.CheckCall(['git'] + args,
+                                   cwd=self.checkout_path)[0].strip()
+
+  def _Run(self, args, **kwargs):
+    kwargs.setdefault('cwd', self.checkout_path)
     try:
-      sp = gclient_utils.Popen(cmd, cwd=cwd, stdout=stdout)
-      output = sp.communicate()[0]
+      gclient_utils.Popen(['git'] + args, **kwargs).communicate()
     except OSError:
       raise gclient_utils.Error("git command '%s' failed to run." %
               ' '.join(cmd) + "\nCheck that you have git installed.")
-    if sp.returncode:
-      raise gclient_utils.Error('git command %s returned %d' %
-                                (args[0], sp.returncode))
-    if output is not None:
-      return output.strip()
 
 
 class SVNWrapper(SCMWrapper):
   """ Wrapper for SVN """
 
   def cleanup(self, options, args, file_list):
     """Cleanup working copy."""
     self._Run(['cleanup'] + args, options)
 
   def diff(self, options, args, file_list):
@@ skipping 287 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