Add pylint to depot_tools.

presubmit_canned_checks.py

 # Copyright (c) 2012 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.
 
 """Generic presubmit checks that can be reused by other presubmit checks."""
 
 import os as _os
 _HERE = _os.path.dirname(_os.path.abspath(__file__))
 
 
@@ skipping 209 matching lines @@
   if cr_files:
     outputs.append(output_api.PresubmitPromptWarning(
         'Found a CR character in these files:', items=cr_files))
   if eof_files:
     outputs.append(output_api.PresubmitPromptWarning(
       'These files should end in one (and only one) newline character:',
       items=eof_files))
   return outputs
 
 
-def _ReportErrorFileAndLine(filename, line_num, line):
+def _ReportErrorFileAndLine(filename, line_num, dummy_line):
   """Default error formatter for _FindNewViolationsOfRule."""
   return '%s, line %s' % (filename, line_num)
 
 
 def _FindNewViolationsOfRule(callable_rule, input_api, source_file_filter=None,
                              error_formatter=_ReportErrorFileAndLine):
   """Find all newly introduced violations of a per-line rule (a callable).
 
   Arguments:
     callable_rule: a callable taking a file extension and line of input and
@@ skipping 374 matching lines @@
       filepath = input_api.os_path.join(dirpath, item)[path_len + 1:]
       if Find(filepath, white_list) and not Find(filepath, black_list):
         files.append(filepath)
   return files
 
 
 def RunPylint(input_api, output_api, white_list=None, black_list=None,
               disabled_warnings=None):
   """Run pylint on python files.
 
-  The default white_list enforces looking only a *.py files.
+  The default white_list enforces looking only at *.py files.
   """
   white_list = tuple(white_list or ('.*\.py$',))
   black_list = tuple(black_list or input_api.DEFAULT_BLACK_LIST)
   if input_api.is_committing:
     error_type = output_api.PresubmitError
   else:
     error_type = output_api.PresubmitPromptWarning
 
   # Only trigger if there is at least one python file affected.
   src_filter = lambda x: input_api.FilterSourceFile(x, white_list, black_list)
   if not input_api.AffectedSourceFiles(src_filter):
     return []
 
   extra_args = ['--rcfile=%s' % input_api.os_path.join(_HERE, 'pylintrc')]
   if disabled_warnings:
     extra_args.extend(['-d', ','.join(disabled_warnings)])
 
   # On certain pylint/python version combination, running pylint throws a lot of
   # warning messages.
   import warnings
   warnings.filterwarnings('ignore', category=DeprecationWarning)
   try:
     files = _FetchAllFiles(input_api, white_list, black_list)
     if not files:
       return []
-    # Now that at least one python file was modified and all the python files
-    # were listed, try to run pylint.
-    try:
-      from pylint import lint
-      from pylint.utils import UnknownMessage
-      input_api.logging.debug(
-          'Using pylint v%s from %s' % (lint.version, lint.__file__))
-    except ImportError:
-      if input_api.platform == 'win32':
-        return [output_api.PresubmitNotifyResult(
-          'Warning: Can\'t run pylint because it is not installed. Please '
-          'install manually\n'
-          'Cannot do static analysis of python files.')]
-      return [output_api.PresubmitError(
-          'Please install pylint with "sudo apt-get install python-setuptools; '
-          'sudo easy_install pylint"\n'
-          'or visit http://pypi.python.org/pypi/setuptools.\n'
-          'Cannot do static analysis of python files.')]
 
     def run_lint(files):
+      # We can't import pylint directly due to licensing issues, so we run
+      # it in another process. Windows needs help running python files so we
+      # explicitly specify the interpreter to use.
+      command = [input_api.python_executable,
+                 input_api.os_path.join(_HERE, 'third_party', 'pylint.py')]
       try:
-        lint.Run(files + extra_args)
-        assert False
-      except SystemExit, e:
-        # pylint has the bad habit of calling sys.exit(), trap it here.
-        return e.code
-      except UnknownMessage, e:
-        return 'Please upgrade pylint: %s' % e
+        return input_api.subprocess.call(command + files + extra_args)
+      except OSError:
+        return 'Pylint failed!'
 
     result = None
     if not input_api.verbose:
       result = run_lint(sorted(files))
     else:
       for filename in sorted(files):
         print('Running pylint on %s' % filename)
         result = run_lint([filename]) or result
     if isinstance(result, basestring):
       return [error_type(result)]
     elif result:
       return [error_type('Fix pylint errors first.')]
     return []
   finally:
     warnings.filterwarnings('default', category=DeprecationWarning)
 
 
 # TODO(dpranke): Get the host_url from the input_api instead
-def CheckRietveldTryJobExecution(input_api, output_api, host_url, platforms,
-                                 owner):
+def CheckRietveldTryJobExecution(dummy_input_api, dummy_output_api,
+                                 dummy_host_url, dummy_platforms,
+                                 dummy_owner):
   # Temporarily 'fix' the check while the Rietveld API is being upgraded to
   # something sensible.
   return []
 
 
 def CheckBuildbotPendingBuilds(input_api, output_api, url, max_pendings,
     ignored):
   try:
     connection = input_api.urllib2.urlopen(url)
     raw_data = connection.read()
@@ skipping 240 matching lines @@
     results.extend(input_api.canned_checks.CheckSvnForCommonMimeTypes(
         input_api, output_api))
     snapshot("checking license")
     results.extend(input_api.canned_checks.CheckLicense(
         input_api, output_api, license_header, source_file_filter=sources))
     snapshot("checking was uploaded")
     results.extend(input_api.canned_checks.CheckChangeWasUploaded(
         input_api, output_api))
   snapshot("done")
   return results