Refactor SubprocessCallAndFilter() to remove positional arguments.

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 136 matching lines @@
     """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.
     """
     path = os.path.join(self._root_dir, self.relpath)
     merge_base = self._Run(['merge-base', 'HEAD', 'origin'])
     command = ['diff', merge_base]
     filterer = DiffFilterer(self.relpath)
-    scm.GIT.RunAndFilterOutput(command, path, False, False, filterer.Filter,
+    scm.GIT.RunAndFilterOutput(command, cwd=path, filter_fn=filterer.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.
 
     Raises:
       Error: if can't get URL for relative path.
     """
@@ skipping 469 matching lines @@
   def _GetCurrentBranch(self):
     # Returns name of current branch or None for detached HEAD
     branch = self._Run(['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
+      cwd = self.checkout_path
     stdout = None
     if redirect_stdout:
       stdout = subprocess.PIPE
     if cwd == None:
       cwd = self.checkout_path
     cmd = [scm.GIT.COMMAND]
     cmd.extend(args)
     logging.debug(cmd)
     try:
       sp = gclient_utils.Popen(cmd, cwd=cwd, stdout=stdout)
       output = sp.communicate()[0]
     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."""
-    command = ['cleanup']
-    command.extend(args)
-    scm.SVN.Run(command, os.path.join(self._root_dir, self.relpath))
+    scm.SVN.Run(['cleanup'] + args,
+                cwd=os.path.join(self._root_dir, self.relpath))
 
   def diff(self, options, args, file_list):
     # NOTE: This function does not currently modify file_list.
     path = os.path.join(self._root_dir, self.relpath)
     if not os.path.isdir(path):
       raise gclient_utils.Error('Directory %s is not present.' % path)
-    command = ['diff']
-    command.extend(args)
-    scm.SVN.Run(command, path)
+    scm.SVN.Run(['diff'] + args, cwd=path)
 
   def export(self, options, args, file_list):
     """Export a clean directory tree into the given path."""
     assert len(args) == 1
     export_path = os.path.abspath(os.path.join(args[0], self.relpath))
     try:
       os.makedirs(export_path)
     except OSError:
       pass
     assert os.path.exists(export_path)
-    command = ['export', '--force', '.']
-    command.append(export_path)
-    scm.SVN.Run(command, os.path.join(self._root_dir, self.relpath))
+    scm.SVN.Run(['export', '--force', '.', export_path],
+                cwd=os.path.join(self._root_dir, self.relpath))
 
   def pack(self, options, args, file_list):
     """Generates a patch file which can be applied to the root of the
     repository."""
     path = os.path.join(self._root_dir, self.relpath)
     if not os.path.isdir(path):
       raise gclient_utils.Error('Directory %s is not present.' % path)
     command = ['diff', '-x', '--ignore-eol-style']
     command.extend(args)
 
     filterer = DiffFilterer(self.relpath)
-    scm.SVN.RunAndFilterOutput(command, path, False, False, filterer.Filter,
+    scm.SVN.RunAndFilterOutput(command, cwd=path, print_messages=False,
+        print_stdout=False, filter_fn=filterer.Filter,
         stdout=options.stdout)
 
   def update(self, options, args, file_list):
     """Runs svn 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.
     """
@@ skipping 37 matching lines @@
     if not from_info:
       raise gclient_utils.Error(('Can\'t update/checkout %r if an unversioned '
                                  'directory is present. Delete the directory '
                                  'and try again.') %
                                 checkout_path)
 
     # Look for locked directories.
     dir_info = scm.SVN.CaptureStatus(os.path.join(checkout_path, '.'))
     if [True for d in dir_info if d[0][2] == 'L' and d[1] == checkout_path]:
       # The current directory is locked, clean it up.
-      scm.SVN.Run(['cleanup'], checkout_path)
+      scm.SVN.Run(['cleanup'], cwd=checkout_path)
 
     # Retrieve the current HEAD version because svn is slow at null updates.
     if options.manually_grab_svn_rev and not revision:
       from_info_live = scm.SVN.CaptureInfo(from_info['URL'], '.')
       revision = str(from_info_live['Revision'])
       rev_str = ' at %s' % revision
 
     if from_info['URL'] != base_url:
       # The repository url changed, need to switch.
       to_info = scm.SVN.CaptureInfo(url, '.')
@@ skipping 11 matching lines @@
         # to reflect where we "are now."  (This is the same way that
         # Subversion itself handles the metadata when switch --relocate
         # is used.)  This makes the checks below for whether we
         # can update to a revision or have to switch to a different
         # branch work as expected.
         # TODO(maruel):  TEST ME !
         command = ['switch', '--relocate',
                    from_info['Repository Root'],
                    to_info['Repository Root'],
                    self.relpath]
-        scm.SVN.Run(command, self._root_dir)
+        scm.SVN.Run(command, cwd=self._root_dir)
         from_info['URL'] = from_info['URL'].replace(
             from_info['Repository Root'],
             to_info['Repository Root'])
       else:
         if not options.force and not options.reset:
           # Look for local modifications but ignore unversioned files.
           for status in scm.SVN.CaptureStatus(checkout_path):
             if status[0] != '?':
               raise gclient_utils.Error(
                   ('Can\'t switch the checkout to %s; UUID don\'t match and '
@@ skipping 22 matching lines @@
         file_list)
 
   def updatesingle(self, options, args, file_list):
     checkout_path = os.path.join(self._root_dir, self.relpath)
     filename = args.pop()
     if scm.SVN.AssertVersion("1.5")[0]:
       if not os.path.exists(os.path.join(checkout_path, '.svn')):
         # Create an empty checkout and then update the one file we want.  Future
         # operations will only apply to the one file we checked out.
         command = ["checkout", "--depth", "empty", self.url, checkout_path]
-        scm.SVN.Run(command, self._root_dir)
+        scm.SVN.Run(command, cwd=self._root_dir)
         if os.path.exists(os.path.join(checkout_path, filename)):
           os.remove(os.path.join(checkout_path, filename))
         command = ["update", filename]
         scm.SVN.RunAndGetFileList(options.verbose, command, checkout_path,
             file_list)
       # After the initial checkout, we can use update as if it were any other
       # dep.
       self.update(options, args, file_list)
     else:
       # If the installed version of SVN doesn't support --depth, fallback to
       # just exporting the file.  This has the downside that revision
       # information is not stored next to the file, so we will have to
       # re-export the file every time we sync.
       if not os.path.exists(checkout_path):
         os.makedirs(checkout_path)
       command = ["export", os.path.join(self.url, filename),
                  os.path.join(checkout_path, filename)]
       command = self._AddAdditionalUpdateFlags(command, options,
           options.revision)
-      scm.SVN.Run(command, self._root_dir)
+      scm.SVN.Run(command, cwd=self._root_dir)
 
   def revert(self, options, args, file_list):
     """Reverts local modifications. Subversion specific.
 
     All reverted files will be appended to file_list, even if Subversion
     doesn't know about them.
     """
     path = os.path.join(self._root_dir, self.relpath)
     if not os.path.isdir(path):
       # svn revert won't work if the directory doesn't exist. It needs to
@@ skipping 89 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