Largely reduce the number of pylint warnings and fix one typo.

presubmit_support.py

 #!/usr/bin/python
-# Copyright (c) 2006-2009 The Chromium Authors. All rights reserved.
+# 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.
 
 """Enables directory-specific presubmit checks to run at upload and/or commit.
 """
 
 __version__ = '1.3.5'
 
 # TODO(joi) Add caching where appropriate/needed. The API is designed to allow
 # caching (between all different invocations of presubmit scripts for a given
@@ skipping 12 matching lines @@
 import random
 import re  # Exposed through the API.
 import subprocess  # Exposed through the API.
 import sys  # Parts exposed through API.
 import tempfile  # Exposed through the API.
 import time
 import traceback  # Exposed through the API.
 import types
 import unittest  # Exposed through the API.
 import urllib2  # Exposed through the API.
-import warnings
+from warnings import warn
 
 try:
   import simplejson as json
 except ImportError:
   try:
     import json
     # Some versions of python2.5 have an incomplete json module.  Check to make
     # sure loads exists.
     json.loads
   except (ImportError, AttributeError):
     # Import the one included in depot_tools.
     sys.path.append(os.path.join(os.path.dirname(__file__), 'third_party'))
     import simplejson as json
 
 # Local imports.
-import gcl
 import gclient_utils
 import presubmit_canned_checks
 import scm
 
 
 # Ask for feedback only once in program lifetime.
 _ASKED_FOR_FEEDBACK = False
 
 
 class NotImplementedException(Exception):
   """We're leaving placeholders in a bunch of places to remind us of the
   design of the API, but we have not implemented all of it yet. Implement as
   the need arises.
   """
   pass
 
 
 def normpath(path):
   '''Version of os.path.normpath that also changes backward slashes to
   forward slashes when not running on Windows.
   '''
   # This is safe to always do because the Windows version of os.path.normpath
   # will replace forward slashes with backward slashes.
   path = path.replace(os.sep, '/')
   return os.path.normpath(path)
 
+
 def PromptYesNo(input_stream, output_stream, prompt):
   output_stream.write(prompt)
   response = input_stream.readline().strip().lower()
   return response == 'y' or response == 'yes'
 
+
+def _RightHandSideLinesImpl(affected_files):
+  """Implements RightHandSideLines for InputApi and GclChange."""
+  for af in affected_files:
+    lines = af.NewContents()
+    line_number = 0
+    for line in lines:
+      line_number += 1
+      yield (af, line_number, line)
+
+
 class OutputApi(object):
   """This class (more like a module) gets passed to presubmit scripts so that
   they can specify various types of results.
   """
 
   class PresubmitResult(object):
     """Base class for result objects."""
 
     def __init__(self, message, items=None, long_text=''):
       """
@@ skipping 58 matching lines @@
     def ShouldPrompt(self):
       return True
 
   class PresubmitNotifyResult(PresubmitResult):
     """Just print something to the screen -- but it's not even a warning."""
     pass
 
   class MailTextResult(PresubmitResult):
     """A warning that should be included in the review request email."""
     def __init__(self, *args, **kwargs):
-      raise NotImplementedException()  # TODO(joi) Implement.
+      super(OutputApi.MailTextResult, self).__init__()
+      raise NotImplementedException()
 
 
 class InputApi(object):
   """An instance of this object is passed to presubmit scripts so they can
   know stuff about the change they're looking at.
   """
 
   # File extensions that are considered source files from a style guide
   # perspective. Don't modify this list from a presubmit script!
   DEFAULT_WHITE_LIST = (
@@ skipping 130 matching lines @@
   def ServerPaths(self, include_dirs=False):
     """Returns server paths of input_api.AffectedFiles()."""
     return [af.ServerPath() for af in self.AffectedFiles(include_dirs)]
 
   def AffectedTextFiles(self, include_deletes=None):
     """Same as input_api.change.AffectedTextFiles() except only lists files
     in the same directory as the current presubmit script, or subdirectories
     thereof.
     """
     if include_deletes is not None:
-      warnings.warn("AffectedTextFiles(include_deletes=%s)"
-                        " is deprecated and ignored" % str(include_deletes),
-                    category=DeprecationWarning,
-                    stacklevel=2)
+      warn("AffectedTextFiles(include_deletes=%s)"
+               " is deprecated and ignored" % str(include_deletes),
+           category=DeprecationWarning,
+           stacklevel=2)
     return filter(lambda x: x.IsTextFile(),
                   self.AffectedFiles(include_dirs=False, include_deletes=False))
 
   def FilterSourceFile(self, affected_file, white_list=None, black_list=None):
     """Filters out files that aren't considered "source file".
 
     If white_list or black_list is None, InputApi.DEFAULT_WHITE_LIST
     and InputApi.DEFAULT_BLACK_LIST is used respectively.
 
     The lists will be compiled as regular expression and
     AffectedFile.LocalPath() needs to pass both list.
 
     Note: Copy-paste this function to suit your needs or use a lambda function.
     """
-    def Find(affected_file, list):
-      for item in list:
+    def Find(affected_file, items):
+      for item in items:
         local_path = affected_file.LocalPath()
         if self.re.match(item, local_path):
           logging.debug("%s matched %s" % (item, local_path))
           return True
       return False
     return (Find(affected_file, white_list or self.DEFAULT_WHITE_LIST) and
             not Find(affected_file, black_list or self.DEFAULT_BLACK_LIST))
 
   def AffectedSourceFiles(self, source_file):
     """Filter the list of AffectedTextFiles by the function source_file.
@@ skipping 15 matching lines @@
 
     Yields:
       a 3 tuple:
         the AffectedFile instance of the current file;
         integer line number (1-based); and
         the contents of the line as a string.
 
     Note: The cariage return (LF or CR) is stripped off.
     """
     files = self.AffectedSourceFiles(source_file_filter)
-    return InputApi._RightHandSideLinesImpl(files)
+    return _RightHandSideLinesImpl(files)
 
   def ReadFile(self, file_item, mode='r'):
     """Reads an arbitrary file.
 
     Deny reading anything outside the repository.
     """
     if isinstance(file_item, AffectedFile):
       file_item = file_item.AbsoluteLocalPath()
     if not file_item.startswith(self.change.RepositoryRoot()):
       raise IOError('Access outside the repository root is denied.')
     return gclient_utils.FileRead(file_item, mode)
 
-  @staticmethod
-  def _RightHandSideLinesImpl(affected_files):
-    """Implements RightHandSideLines for InputApi and GclChange."""
-    for af in affected_files:
-      lines = af.NewContents()
-      line_number = 0
-      for line in lines:
-        line_number += 1
-        yield (af, line_number, line)
-
 
 class AffectedFile(object):
   """Representation of a file in a change."""
 
   def __init__(self, path, action, repository_root=''):
     self._path = path
     self._action = action
     self._local_root = repository_root
     self._is_directory = None
     self._properties = {}
@@ skipping 258 matching lines @@
       affected = filter(lambda x: not x.IsDirectory(), self._affected_files)
 
     if include_deletes:
       return affected
     else:
       return filter(lambda x: x.Action() != 'D', affected)
 
   def AffectedTextFiles(self, include_deletes=None):
     """Return a list of the existing text files in a change."""
     if include_deletes is not None:
-      warnings.warn("AffectedTextFiles(include_deletes=%s)"
-                        " is deprecated and ignored" % str(include_deletes),
-                    category=DeprecationWarning,
-                    stacklevel=2)
+      warn("AffectedTextFiles(include_deletes=%s)"
+               " is deprecated and ignored" % str(include_deletes),
+           category=DeprecationWarning,
+           stacklevel=2)
     return filter(lambda x: x.IsTextFile(),
                   self.AffectedFiles(include_dirs=False, include_deletes=False))
 
   def LocalPaths(self, include_dirs=False):
     """Convenience function."""
     return [af.LocalPath() for af in self.AffectedFiles(include_dirs)]
 
   def AbsoluteLocalPaths(self, include_dirs=False):
     """Convenience function."""
     return [af.AbsoluteLocalPath() for af in self.AffectedFiles(include_dirs)]
 
   def ServerPaths(self, include_dirs=False):
     """Convenience function."""
     return [af.ServerPath() for af in self.AffectedFiles(include_dirs)]
 
   def RightHandSideLines(self):
     """An iterator over all text lines in "new" version of changed files.
 
     Lists lines from new or modified text files in the change.
 
     This is useful for doing line-by-line regex checks, like checking for
     trailing whitespace.
 
     Yields:
       a 3 tuple:
         the AffectedFile instance of the current file;
         integer line number (1-based); and
         the contents of the line as a string.
     """
-    return InputApi._RightHandSideLinesImpl(
-        filter(lambda x: x.IsTextFile(),
-               self.AffectedFiles(include_deletes=False)))
+    return _RightHandSideLinesImpl(
+        x for x in self.AffectedFiles(include_deletes=False)
+        if x.IsTextFile())
 
 
 class SvnChange(Change):
   _AFFECTED_FILES = SvnAffectedFile
 
   def __init__(self, *args, **kwargs):
     Change.__init__(self, *args, **kwargs)
     self.scm = 'svn'
     self._changelists = None
 
   def _GetChangeLists(self):
     """Get all change lists."""
     if self._changelists == None:
       previous_cwd = os.getcwd()
       os.chdir(self.RepositoryRoot())
+      # Need to import here to avoid circular dependency.
+      import gcl
       self._changelists = gcl.GetModifiedFiles()
       os.chdir(previous_cwd)
     return self._changelists
 
   def GetAllModifiedFiles(self):
     """Get all modified files."""
     changelists = self._GetChangeLists()
     all_modified_files = []
     for cl in changelists.values():
       all_modified_files.extend(
@@ skipping 56 matching lines @@
   results = []
   for directory in sorted(list(candidates)):
     p = os.path.join(directory, 'PRESUBMIT.py')
     if os.path.isfile(p):
       results.append(p)
 
   return results
 
 
 class GetTrySlavesExecuter(object):
-  def ExecPresubmitScript(self, script_text):
+  @staticmethod
+  def ExecPresubmitScript(script_text):
     """Executes GetPreferredTrySlaves() from a single presubmit script.
 
     Args:
       script_text: The text of the presubmit script.
 
     Return:
       A list of try slaves.
     """
     context = {}
     exec script_text in context
@@ skipping 289 matching lines @@
                                options.commit,
                                options.verbose,
                                sys.stdout,
                                sys.stdin,
                                options.default_presubmit,
                                options.may_prompt)
 
 
 if __name__ == '__main__':
   sys.exit(Main(sys.argv))