Add InputApi.AffectedSourceFile() and custom filtering support.

presubmit_support.py

 #!/usr/bin/python
 # 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.
 
 """Enables directory-specific presubmit checks to run at upload and/or commit.
 """
 
 __version__ = '1.3.1'
 
@@ skipping 119 matching lines @@
     """A warning that should be included in the review request email."""
     def __init__(self, *args, **kwargs):
       raise NotImplementedException()  # TODO(joi) Implement.
 
 
 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 = [
+      # C++ and friends
+      r".*\.c", r".*\.cc", r".*\.cpp", r".*\.h", r".*\.m", r".*\.mm",
+      r".*\.inl", r".*\.asm", r".*\.hxx", r".*\.hpp",
+      # Scripts
+      r".*\.js", r".*\.py", r".*\.json", r".*\.sh", r".*\.rb",
+      # No extension at all
+      r"(^|.*[\\\/])[^.]+$",
+      # Other
+      r".*\.java", r".*\.mk", r".*\.am",
+  ]
+
+  # Path regexp that should be excluded from being considered containing source
+  # files. Don't modify this list from a presubmit script!
+  DEFAULT_BLACK_LIST = [
+      r".*\bexperimental[\\\/].*",
+      r".*\bthird_party[\\\/].*",
+      # Output directories (just in case)
+      r".*\bDebug[\\\/].*",
+      r".*\bRelease[\\\/].*",
+      r".*\bxcodebuild[\\\/].*",
+      r".*\bsconsbuild[\\\/].*",
+      # All caps files like README and LICENCE.
+      r".*\b[A-Z0-9_]+",
+      # SCM (can happen in dual SCM configuration)
+      r".*\b\.git[\\\/].*",
+      r".*\b\.svn[\\\/].*",
+  ]
+
   def __init__(self, change, presubmit_path, is_committing):
     """Builds an InputApi object.
 
     Args:
       change: A presubmit.GclChange object.
       presubmit_path: The path to the presubmit script being processed.
       is_committing: True if the change is about to be committed.
     """
     # Version number of the presubmit_support script.
     self.version = [int(x) for x in __version__.split('.')]
@@ skipping 93 matching lines @@
     thereof.
     """
     if include_deletes is not None:
       warnings.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 RightHandSideLines(self):
+  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:
+        if self.re.match(item, affected_file.LocalPath()):
+          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.
+
+    If source_file is None, InputApi.FilterSourceFile() is used.
+    """
+    if not source_file:
+      source_file = self.FilterSourceFile
+    return filter(source_file, self.AffectedTextFiles())
+
+  def RightHandSideLines(self, source_file_filter=None):
     """An iterator over all text lines in "new" version of changed files.
 
     Only lists lines from new or modified text files in the change that are
     contained by the directory of the currently executing presubmit script.
 
     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.
 
     Note: The cariage return (LF or CR) is stripped off.
     """
-    return InputApi._RightHandSideLinesImpl(
-        filter(lambda x: x.IsTextFile(),
-               self.AffectedFiles(include_deletes=False)))
+    files = self.AffectedSourceFiles(source_file_filter)
+    return InputApi._RightHandSideLinesImpl(files)
 
   def ReadFile(self, file, mode='r'):
     """Reads an arbitrary file.
     
     Deny reading anything outside the repository.
     """
     if isinstance(file, AffectedFile):
       file = file.AbsoluteLocalPath()
     if not file.startswith(self.change.RepositoryRoot()):
       raise IOError('Access outside the repository root is denied.')
@@ skipping 462 matching lines @@
   return not DoPresubmitChecks(gcl.ChangeInfo('No name', 0, 0, '', files),
                                options.commit,
                                options.verbose,
                                sys.stdout,
                                sys.stdin,
                                default_presubmit=None)
 
 
 if __name__ == '__main__':
   sys.exit(Main(sys.argv))