Add pylintrc and fix style for many scripts.

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
 import shutil
 import subprocess
 import sys
 import tempfile
 import time
 import xml.dom.minidom
 
 import gclient_utils
 
 def ValidateEmail(email):
- return (re.match(r"^[a-zA-Z0-9._%-+]+@[a-zA-Z0-9._%-]+.[a-zA-Z]{2,6}$", email)
-         is not None)
+  return (re.match(r"^[a-zA-Z0-9._%-+]+@[a-zA-Z0-9._%-]+.[a-zA-Z]{2,6}$", email)
+          is not None)
 
 
 def GetCasedPath(path):
   """Elcheapos way to get the real path case on Windows."""
   if sys.platform.startswith('win') and os.path.exists(path):
     # Reconstruct the path.
     path = os.path.abspath(path)
     paths = path.split('\\')
     for i in range(len(paths)):
       if i == 0:
@@ skipping 81 matching lines @@
         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):
+                         filter_fn):
     """Runs a command, optionally outputting to stdout.
 
-    stdout is passed line-by-line to the given filter function. If
+    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: A function taking one argument (a string) which will be
+      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=filter)
+                                          filter_fn=filter_fn)
 
   @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 297 matching lines @@
           continue
         # No progress was made or an unknown error we aren't sure, bail out.
         raise
       break
 
   @staticmethod
   def RunAndFilterOutput(args,
                          in_directory,
                          print_messages,
                          print_stdout,
-                         filter):
+                         filter_fn):
     """Runs a command, optionally outputting to stdout.
 
-    stdout is passed line-by-line to the given filter function. If
+    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: A function taking one argument (a string) which will be
+      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=filter)
+                                          filter_fn=filter_fn)
 
   @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.
     """
     output = SVN.Capture(["info", "--xml", relpath], in_directory, print_error)
     dom = gclient_utils.ParseXML(output)
     result = {}
     if dom:
       GetNamedNodeText = gclient_utils.GetNamedNodeText
       GetNodeNamedAttributeText = gclient_utils.GetNodeNamedAttributeText
       def C(item, f):
-        if item is not None: return f(item)
+        if item is not None:
+          return f(item)
       # /info/entry/
       #   url
       #   reposityory/(root|uuid)
       #   wc-info/(schedule|depth)
       #   commit/(author|date)
       # str() the results because they may be returned as Unicode, which
       # interferes with the higher layers matching up things in the deps
       # dictionary.
-      # TODO(maruel): Fix at higher level instead (!)
       result['Repository Root'] = C(GetNamedNodeText(dom, 'root'), str)
       result['URL'] = C(GetNamedNodeText(dom, 'url'), str)
       result['UUID'] = C(GetNamedNodeText(dom, 'uuid'), str)
       result['Revision'] = C(GetNodeNamedAttributeText(dom, 'entry',
                                                        'revision'),
                              int)
       result['Node Kind'] = C(GetNodeNamedAttributeText(dom, 'entry', 'kind'),
                               str)
       # Differs across versions.
       if result['Node Kind'] == 'dir':
@@ skipping 110 matching lines @@
     return SVN.IsMovedInfo(SVN.CaptureInfo(filename))
 
   @staticmethod
   def IsMovedInfo(info):
     """Determine if a file has been added through svn mv"""
     return (info.get('Copied From URL') and
             info.get('Copied From Rev') and
             info.get('Schedule') == 'add')
 
   @staticmethod
-  def GetFileProperty(file, property_name):
+  def GetFileProperty(filename, property_name):
     """Returns the value of an SVN property for the given file.
 
     Args:
-      file: The file to check
+      filename: The file to check
       property_name: The name of the SVN property, e.g. "svn:mime-type"
 
     Returns:
       The value of the property, which will be the empty string if the property
       is not set on the file.  If the file is not under version control, the
       empty string is also returned.
     """
-    output = SVN.Capture(["propget", property_name, file])
+    output = SVN.Capture(["propget", property_name, filename])
     if (output.startswith("svn: ") and
         output.endswith("is not under version control")):
       return ""
     else:
       return output
 
   @staticmethod
   def DiffItem(filename, full_move=False, revision=None):
     """Diffs a single file.
 
     Should be simple, eh? No it isn't.
     Be sure to be in the appropriate directory before calling to have the
     expected relative path.
     full_move means that move or copy operations should completely recreate the
     files, usually in the prospect to apply the patch for a try job."""
     # If the user specified a custom diff command in their svn config file,
     # then it'll be used when we do svn diff, which we don't want to happen
     # since we want the unified diff.  Using --diff-cmd=diff doesn't always
     # work, since they can have another diff executable in their path that
     # gives different line endings.  So we use a bogus temp directory as the
     # config directory, which gets around these problems.
     bogus_dir = tempfile.mkdtemp()
     try:
       # Use "svn info" output instead of os.path.isdir because the latter fails
       # when the file is deleted.
-      return SVN._DiffItemInternal(SVN.CaptureInfo(filename),
+      return SVN._DiffItemInternal(filename, SVN.CaptureInfo(filename),
+                                   bogus_dir,
                                    full_move=full_move, revision=revision)
     finally:
       shutil.rmtree(bogus_dir)
 
   @staticmethod
   def _DiffItemInternal(filename, info, bogus_dir, full_move=False,
                         revision=None):
     """Grabs the diff data."""
     command = ["diff", "--config-dir", bogus_dir, filename]
     if revision:
@@ skipping 129 matching lines @@
                               'svn.simple')
     for credfile in os.listdir(auth_dir):
       cred_info = SVN.ReadSimpleAuth(os.path.join(auth_dir, credfile))
       if regexp.match(cred_info.get('svn:realmstring')):
         return cred_info.get('username')
 
   @staticmethod
   def ReadSimpleAuth(filename):
     f = open(filename, 'r')
     values = {}
-    def ReadOneItem(type):
-      m = re.match(r'%s (\d+)' % type, f.readline())
+    def ReadOneItem(item_type):
+      m = re.match(r'%s (\d+)' % item_type, f.readline())
       if not m:
         return None
       data = f.read(int(m.group(1)))
       if f.read(1) != '\n':
         return None
       return data
 
     while True:
       key = ReadOneItem('K')
       if not key:
@@ skipping 35 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)