gclient: make git path more verbose

gclient_scm.py

 # Copyright 2009 Google Inc.  All Rights Reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
 #
 #      http://www.apache.org/licenses/LICENSE-2.0
 #
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
@@ skipping 78 matching lines @@
           command, self.scm_name))
 
     return getattr(self, command)(options, args, file_list)
 
 
 class GitWrapper(SCMWrapper):
   """Wrapper for Git"""
 
   def cleanup(self, options, args, file_list):
     """Cleanup working copy."""
-    self._RunGit(['prune'])
-    self._RunGit(['fsck'])
-    self._RunGit(['gc'])
+    self._RunGit(['prune'], redirect_stdout=False)
+    self._RunGit(['fsck'], redirect_stdout=False)
+    self._RunGit(['gc'], redirect_stdout=False)
 
   def diff(self, options, args, file_list):
     # NOTE: This function does not currently modify file_list.
     merge_base = self._RunGit(['merge-base', 'HEAD', 'origin'])
-    print self._RunGit(['diff', merge_base])
+    self._RunGit(['diff', merge_base], redirect_stdout=False)
 
   def export(self, options, args, file_list):
     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._RunGit(['checkout-index', '-a', '--prefix=%s/' % export_path])
+    self._RunGit(['checkout-index', '-a', '--prefix=%s/' % export_path],
+                 redirect_stdout=False)
 
   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.
 
     Raises:
       Error: if can't get URL for relative path.
     """
 
     if args:
       raise gclient_utils.Error("Unsupported argument(s): %s" % ",".join(args))
 
     components = self.url.split("@")
     url = components[0]
     revision = None
     if options.revision:
       revision = options.revision
     elif len(components) == 2:
       revision = components[1]
 
     if not os.path.exists(self.checkout_path):
-      self._RunGit(['clone', '-q', url, self.checkout_path], cwd=self._root_dir)
+      self._RunGit(['clone', url, self.checkout_path],
+                   cwd=self._root_dir, redirect_stdout=False)
       if revision:
-        self._RunGit(['reset', '--hard', revision])
+        self._RunGit(['reset', '--hard', revision], redirect_stdout=False)
       files =  self._RunGit(['ls-files']).split()
       file_list.extend([os.path.join(self.checkout_path, f) for f in files])
       return
 
-    self._RunGit(['remote', 'update'])
+    self._RunGit(['remote', 'update'], redirect_stdout=False)
     new_base = 'origin'
     if revision:
       new_base = revision
     files = self._RunGit(['diff', new_base, '--name-only']).split()
     file_list.extend([os.path.join(self.checkout_path, f) for f in files])
-    self._RunGit(['rebase', new_base])
+    self._RunGit(['rebase', new_base], redirect_stdout=False)
 
   def revert(self, options, args, file_list):
     """Reverts local modifications.
 
     All reverted files will be appended to file_list.
     """
     path = os.path.join(self._root_dir, self.relpath)
     if not os.path.isdir(path):
       # revert won't work if the directory doesn't exist. It needs to
       # checkout instead.
       print("\n_____ %s is missing, synching instead" % self.relpath)
       # Don't reuse the args.
       return self.update(options, [], file_list)
     merge_base = self._RunGit(['merge-base', 'HEAD', 'origin'])
     files = self._RunGit(['diff', merge_base, '--name-only']).split()
-    print self._RunGit(['reset', '--hard', merge_base])
+    self._RunGit(['reset', '--hard', merge_base], redirect_stdout=False)
     file_list.extend([os.path.join(self.checkout_path, f) for f in files])
 
   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):
       print('\n________ couldn\'t run status in %s:\nThe directory '
             'does not exist.' % checkout_path)
     else:
       merge_base = self._RunGit(['merge-base', 'HEAD', 'origin'])
-      print self._RunGit(['diff', '--name-status', merge_base])
+      self._RunGit(['diff', '--name-status', merge_base], redirect_stdout=False)
       files = self._RunGit(['diff', '--name-only', merge_base]).split()
       file_list.extend([os.path.join(self.checkout_path, f) for f in files])
 
-  def _RunGit(self, args, cwd=None, checkrc=True):
+  def _RunGit(self, args, cwd=None, checkrc=True, redirect_stdout=True):
+    stdout=None
+    if redirect_stdout:
+      stdout=subprocess.PIPE
     if cwd == None:
       cwd = self.checkout_path
     cmd = ['git']
     cmd.extend(args)
-    sp = subprocess.Popen(cmd, cwd=cwd, stdout=subprocess.PIPE)
+    sp = subprocess.Popen(cmd, cwd=cwd, stdout=stdout)
     if checkrc and sp.returncode:
       raise gclient_utils.Error('git command %s returned %d' %
                                 (args[0], sp.returncode))
-    return sp.communicate()[0].strip()
+    output = sp.communicate()[0]
+    if output != None:
+      return output.strip()
 
 
 class SVNWrapper(SCMWrapper):
   """ Wrapper for SVN """
 
   def cleanup(self, options, args, file_list):
     """Cleanup working copy."""
     command = ['cleanup']
     command.extend(args)
     RunSVN(command, os.path.join(self._root_dir, self.relpath))
@@ skipping 560 matching lines @@
         # Col 3
         if wc_status[0].getAttribute('copied') == 'true':
           statuses[3] = '+'
         # Col 4
         if wc_status[0].getAttribute('switched') == 'true':
           statuses[4] = 'S'
         # TODO(maruel): Col 5 and 6
         item = (''.join(statuses), file)
         results.append(item)
   return results