Refactor SubprocessCallAndFilter() to remove positional arguments.

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 cStringIO
 import glob
 import os
 import re
@@ skipping 99 matching lines @@
     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
-  def RunAndFilterOutput(args,
-                         in_directory,
-                         print_messages,
-                         print_stdout,
-                         filter_fn,
-                         stdout=None):
-    """Runs a command, optionally outputting to stdout.
-
-    stdout is passed line-by-line to the given filter_fn function. If
-    print_stdout is true, it is also printed to sys.stdout as in Run.
-
-    Args:
-      args: A sequence of command line parameters to be passed.
-      in_directory: The directory where git is to be run.
-      print_messages: Whether to print status messages to stdout about
-        which commands are being run.
-      print_stdout: Whether to forward program's output to stdout.
-      filter_fn: A function taking one argument (a string) which will be
-        passed each line (with the ending newline character removed) of
-        program's output for filtering.
-
-    Raises:
-      gclient_utils.Error: An error occurred while running the command.
-    """
-    command = [GIT.COMMAND]
-    command.extend(args)
-    gclient_utils.SubprocessCallAndFilter(command,
-                                          in_directory,
-                                          print_messages,
-                                          print_stdout,
-                                          filter_fn=filter_fn,
-                                          stdout=stdout)
+  def RunAndFilterOutput(args, **kwargs):
+    """Wrapper to gclient_utils.SubprocessCallAndFilter()."""
+    return gclient_utils.SubprocessCallAndFilter([GIT.COMMAND] + args, **kwargs)
 
   @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)[0].strip()
 
   @staticmethod
@@ skipping 176 matching lines @@
       elif ver > min_ver:
         return (True, current_version)
     return (True, current_version)
 
 
 class SVN(object):
   COMMAND = "svn"
   current_version = None
 
   @staticmethod
-  def Run(args, in_directory):
-    """Runs svn, sending output to stdout.
-
-    Args:
-      args: A sequence of command line parameters to be passed to svn.
-      in_directory: The directory where svn is to be run.
-
-    Raises:
-      Error: An error occurred while running the svn command.
-    """
-    c = [SVN.COMMAND]
-    c.extend(args)
-    # TODO(maruel): This is very gclient-specific.
-    gclient_utils.SubprocessCall(c, in_directory)
+  def Run(args, **kwargs):
+    """Wrappers to gclient_utils.SubprocessCall()."""
+    return gclient_utils.SubprocessCall([SVN.COMMAND] + args, **kwargs)
 
   @staticmethod
   def Capture(args, in_directory=None, print_error=True):
     """Runs svn, capturing output sent to stdout as a string.
 
     Args:
       args: A sequence of command line parameters to be passed to svn.
       in_directory: The directory where svn is to be run.
 
     Returns:
       The output sent to stdout as a string.
     """
     c = [SVN.COMMAND]
     c.extend(args)
     stderr = None
     if not print_error:
       stderr = subprocess.PIPE
     return gclient_utils.Popen(c, cwd=in_directory, stdout=subprocess.PIPE,
         stderr=stderr).communicate()[0]
 
   @staticmethod
-  def RunAndGetFileList(verbose, args, in_directory, file_list, stdout=None):
+  def RunAndGetFileList(verbose, args, cwd, file_list, stdout=None):
     """Runs svn checkout, update, or status, output to stdout.
 
     The first item in args must be either "checkout", "update", or "status".
 
     svn's stdout is parsed to collect a list of files checked out or updated.
     These files are appended to file_list.  svn's stdout is also printed to
     sys.stdout as in Run.
 
     Args:
       verbose: If True, uses verbose output
       args: A sequence of command line parameters to be passed to svn.
-      in_directory: The directory where svn is to be run.
+      cwd: The directory where svn is to be run.
 
     Raises:
       Error: An error occurred while running the svn command.
     """
-    command = [SVN.COMMAND]
-    command.extend(args)
+    stdout = stdout or sys.stdout
 
     # svn update and svn checkout use the same pattern: the first three columns
     # are for file status, property status, and lock status.  This is followed
     # by two spaces, and then the path to the file.
     update_pattern = '^...  (.*)$'
 
     # The first three columns of svn status are the same as for svn update and
     # svn checkout.  The next three columns indicate addition-with-history,
     # switch, and remote lock status.  This is followed by one space, and then
     # the path to the file.
@@ skipping 15 matching lines @@
       failure = []
 
       def CaptureMatchingLines(line):
         match = compiled_pattern.search(line)
         if match:
           file_list.append(match.group(1))
         if line.startswith('svn: '):
           failure.append(line)
 
       try:
-        SVN.RunAndFilterOutput(args,
-                               in_directory,
-                               verbose,
-                               True,
-                               CaptureMatchingLines,
+        SVN.RunAndFilterOutput(args, cwd=cwd, print_messages=verbose,
+                               print_stdout=True,
+                               filter_fn=CaptureMatchingLines,
                                stdout=stdout)
       except gclient_utils.Error:
         def IsKnownFailure():
           for x in failure:
             if (x.startswith('svn: OPTIONS of') or
                 x.startswith('svn: PROPFIND of') or
                 x.startswith('svn: REPORT of') or
                 x.startswith('svn: Unknown hostname') or
                 x.startswith('svn: Server sent unexpected return value')):
               return True
@@ skipping 22 matching lines @@
           # We enforce that some progress has been made or a known failure.
           if len(file_list) == previous_list_len and not IsKnownFailure():
             # No known svn error was found and no progress, bail out.
             raise
         print "Sleeping 15 seconds and retrying...."
         time.sleep(15)
         continue
       break
 
   @staticmethod
-  def RunAndFilterOutput(args,
-                         in_directory,
-                         print_messages,
-                         print_stdout,
-                         filter_fn,
-                         stdout=None):
-    """Runs a command, optionally outputting to stdout.
-
-    stdout is passed line-by-line to the given filter_fn function. If
-    print_stdout is true, it is also printed to sys.stdout as in Run.
-
-    Args:
-      args: A sequence of command line parameters to be passed.
-      in_directory: The directory where svn is to be run.
-      print_messages: Whether to print status messages to stdout about
-        which commands are being run.
-      print_stdout: Whether to forward program's output to stdout.
-      filter_fn: A function taking one argument (a string) which will be
-        passed each line (with the ending newline character removed) of
-        program's output for filtering.
-
-    Raises:
-      gclient_utils.Error: An error occurred while running the command.
-    """
-    command = [SVN.COMMAND]
-    command.extend(args)
-    gclient_utils.SubprocessCallAndFilter(command,
-                                          in_directory,
-                                          print_messages,
-                                          print_stdout,
-                                          filter_fn=filter_fn,
-                                          stdout=stdout)
+  def RunAndFilterOutput(args, **kwargs):
+    """Wrapper for gclient_utils.SubprocessCallAndFilter()."""
+    return gclient_utils.SubprocessCallAndFilter([SVN.COMMAND] + args, **kwargs)
 
   @staticmethod
   def CaptureInfo(relpath, in_directory=None, print_error=True):
     """Returns a dictionary from the svn info output for the given file.
 
     Args:
       relpath: The directory where the working copy resides relative to
         the directory given by in_directory.
       in_directory: The directory where svn is to be run.
     """
@@ skipping 408 matching lines @@
     if not SVN.current_version:
       SVN.current_version = SVN.Capture(['--version']).split()[2]
     current_version_list = map(only_int, SVN.current_version.split('.'))
     for min_ver in map(int, min_version.split('.')):
       ver = current_version_list.pop(0)
       if ver < min_ver:
         return (False, SVN.current_version)
       elif ver > min_ver:
         return (True, SVN.current_version)
     return (True, SVN.current_version)