depot_tools: modify cpplint.py to allow CPPLINT.cfg overrides

cpplint.py

 #!/usr/bin/env python
 #
 # Copyright (c) 2009 Google Inc. All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
 # met:
 #
 #    * Redistributions of source code must retain the above copyright
 # notice, this list of conditions and the following disclaimer.
@@ skipping 115 matching lines @@
       80 characters.
 
       Examples:
         --linelength=120
 
     extensions=extension,extension,...
       The allowed file extensions that cpplint will check
 
       Examples:
         --extensions=hpp,cpp
+
+    cpplint.py supports per-directory configurations specified in CPPLINT.cfg
+    files. CPPLINT.cfg file can contain a number of key=value pairs.
+    Currently the following options are supported:
+
+      set noparent
+      filter=+filter1,-filter2,...
+      exclude_files=regex
+
+    "set noparent" option prevents cpplint from traversing directory tree
+    upwards looking for more .cfg files in parent directories. This option
+    is usually placed in the top-level project directory.
+
+    The "filter" option is similar in function to --filter flag. It specifies
+    message filters in addition to the |_DEFAULT_FILTERS| and those specified
+    through --filter command-line flag.
+
+    "exclude_files" allows to specify a regular expression to be matched against
+    a file name. If the expression matches, the file is skipped and not run
+    through liner.
+
+    CPPLINT.cfg has an effect on files in the same directory and all
+    sub-directories, unless overridden by a nested configuration file.
+
+      Example file:
+        filter=-build/include_order,+build/include_alpha
+        exclude_files=.*\.cc
+
+    The above example disables build/include_order warning and enables
+    build/include_alpha as well as excludes all .cc from being
+    processed by linter, in the current directory (where the .cfg
+    file is located) and all sub-directories.
 """
 
 # We categorize each error message we print.  Here are the categories.
 # We want an explicit list so we can list them all in cpplint --filter=.
 # If you add a new error message with a new category, add it to the list
 # here!  cpplint_unittest.py should tell you if you forget to do this.
 _ERROR_CATEGORIES = [
   'build/class',
   'build/c++11',
   'build/deprecated',
@@ skipping 529 matching lines @@
 
 
 class _CppLintState(object):
   """Maintains module-wide state.."""
 
   def __init__(self):
     self.verbose_level = 1  # global setting.
     self.error_count = 0    # global count of reported errors
     # filters to apply when emitting error messages
     self.filters = _DEFAULT_FILTERS[:]
+    # backup of filter list. Used to restore the state after each file.
+    self._filters_backup = self.filters[:]
     self.counting = 'total'  # In what way are we counting errors?
     self.errors_by_category = {}  # string to int dict storing error counts
 
     # output format:
     # "emacs" - format that emacs can parse (default)
     # "vs7" - format that Microsoft Visual Studio 7 can parse
     self.output_format = 'emacs'
 
   def SetOutputFormat(self, output_format):
     """Sets the output format for errors."""
@@ skipping 18 matching lines @@
     Args:
       filters: A string of comma-separated filters (eg "+whitespace/indent").
                Each filter should start with + or -; else we die.
 
     Raises:
       ValueError: The comma-separated filters did not all start with '+' or '-'.
                   E.g. "-,+whitespace,-whitespace/indent,whitespace/badfilter"
     """
     # Default filters always have less priority than the flag ones.
     self.filters = _DEFAULT_FILTERS[:]
+    self.AddFilters(filters)
+
+  def AddFilters(self, filters):
+    """ Adds more filters to the existing list of error-message filters. """
     for filt in filters.split(','):
       clean_filt = filt.strip()
       if clean_filt:
         self.filters.append(clean_filt)
     for filt in self.filters:
       if not (filt.startswith('+') or filt.startswith('-')):
         raise ValueError('Every filter in --filters must start with + or -'
                          ' (%s does not)' % filt)
 
+  def BackupFilters(self):
+    """ Saves the current filter list to backup storage."""
+    self._filters_backup = self.filters[:]
+
+  def RestoreFilters(self):
+    """ Restores filters previously backed up."""
+    self.filters = self._filters_backup[:]
+
   def ResetErrorCounts(self):
     """Sets the module's error statistic back to zero."""
     self.error_count = 0
     self.errors_by_category = {}
 
   def IncrementErrorCount(self, category):
     """Bumps the module's error statistic."""
     self.error_count += 1
     if self.counting in ('toplevel', 'detailed'):
       if self.counting != 'detailed':
@@ skipping 47 matching lines @@
 
   These filters are applied when deciding whether to emit a given
   error message.
 
   Args:
     filters: A string of comma-separated filters (eg "whitespace/indent").
              Each filter should start with + or -; else we die.
   """
   _cpplint_state.SetFilters(filters)
 
+def _AddFilters(filters):
+  """Adds more filter overrides.
+ 
+  Unlike _SetFilters, this function does not reset the current list of filters
+  available.
+
+  Args:
+    filters: A string of comma-separated filters (eg "whitespace/indent").
+             Each filter should start with + or -; else we die.
+  """
+  _cpplint_state.AddFilters(filters)
+
+def _BackupFilters():
+  """ Saves the current filter list to backup storage."""
+  _cpplint_state.BackupFilters()
+
+def _RestoreFilters():
+  """ Restores filters previously backed up."""
+  _cpplint_state.RestoreFilters()
 
 class _FunctionState(object):
   """Tracks current function name and the number of lines in its body."""
 
   _NORMAL_TRIGGER = 250  # for --v=0, 500 for --v=1, etc.
   _TEST_TRIGGER = 400    # about 50% more than _NORMAL_TRIGGER.
 
   def __init__(self):
     self.in_a_function = False
     self.lines_in_function = 0
@@ skipping 4512 matching lines @@
   CheckForNonConstReference(filename, clean_lines, line, nesting_state, error)
   CheckForNonStandardConstructs(filename, clean_lines, line,
                                 nesting_state, error)
   CheckVlogArguments(filename, clean_lines, line, error)
   CheckPosixThreading(filename, clean_lines, line, error)
   CheckInvalidIncrement(filename, clean_lines, line, error)
   CheckMakePairUsesDeduction(filename, clean_lines, line, error)
   CheckDefaultLambdaCaptures(filename, clean_lines, line, error)
   for check_fn in extra_check_functions:
     check_fn(filename, clean_lines, line, error)
-        
+
 def FlagCxx11Features(filename, clean_lines, linenum, error):
   """Flag those c++11 features that we only allow in certain places.
 
   Args:
     filename: The name of the current file.
     clean_lines: A CleansedLines instance containing the file.
     linenum: The number of the line to check.
     error: The function to call with any errors found.
   """
   line = clean_lines.elided[linenum]
@@ skipping 75 matching lines @@
   nesting_state.CheckCompletedBlocks(filename, error)
 
   CheckForIncludeWhatYouUse(filename, clean_lines, include_state, error)
 
   # We check here rather than inside ProcessLine so that we see raw
   # lines rather than "cleaned" lines.
   CheckForBadCharacters(filename, lines, error)
 
   CheckForNewlineAtEOF(filename, lines, error)
 
+def ProcessConfigOverrides(filename):
+  """ Loads the configuration files and processes the config overrides.
+
+  Args:
+    filename: The name of the file being processed by the linter.
+
+  Returns:
+    False if the current |filename| should not be processed further.
+  """
+
+  abs_filename = os.path.abspath(filename)
+  cfg_filters = []
+  keep_looking = True
+  while keep_looking:
+    abs_path, base_name = os.path.split(abs_filename)
+    if not base_name:
+        break  # Reached the root directory.

[sosa, 2014/07/28 20:28:45]

Too much indentation

+    cfg_file = os.path.join(abs_path, "CPPLINT.cfg")
+    if os.path.isfile(cfg_file):

[sosa, 2014/07/28 20:28:45]

This is very nesty. I'd consider negating these if's with continue so you don't
have to indent as much. I'll leave it up to you (this one here and the
line.strip below are a couple examples).

+      try:
+        with open(cfg_file) as file_handle:
+          for line in file_handle:
+            line, _, _ = line.partition('#')  # Remove comments.
+            if line.strip():
+              name, _, val = line.partition('=')
+              name = name.strip()
+              val = val.strip()
+              if name == 'set noparent':
+                keep_looking = False
+              elif name == 'filter':
+                cfg_filters.append(val)
+              elif name == 'exclude_files':
+                # When matching exclude_files pattern, use the base_name of
+                # the current file name or the directory name we are processing.
+                # For example, if we are checking for lint errors /foo/bar/baz
+                # and we found the .cfg file in the parent directory (/foo),
+                # then the config file's "exclude_files" filter is meant to
+                # be checked against "bar" and not "baz" or "bar/baz".
+                if base_name:
+                  pattern = re.compile(val)
+                  if pattern.match(base_name):
+                    sys.stderr.write('Ignoring "%s": file excluded by "%s". '
+                                     'File path component "%s" matches '
+                                     'pattern "%s"\n' %
+                                     (filename, cfg_file, base_name, val))
+                    return False
+              else:
+                sys.stderr.write(
+                    'Invalid configuration option (%s) in file %s\n' %
+                    (name, cfg_file))
+
+      except IOError:
+        sys.stderr.write(
+            "Skipping config file '%s': Can't open for reading\n" % cfg_file)
+        keep_looking = False
+
+    abs_filename = abs_path
+
+  # Apply all the accumulated filters in reverse order (top-level directory
+  # config options having the least priority).
+  for filter in reversed(cfg_filters):
+     _AddFilters(filter)
+
+  return True
+
 
 def ProcessFile(filename, vlevel, extra_check_functions=[]):
   """Does google-lint on a single file.
 
   Args:
     filename: The name of the file to parse.
 
     vlevel: The level of errors to report.  Every error of confidence
     >= verbose_level will be reported.  0 is a good default.
 
     extra_check_functions: An array of additional check functions that will be
                            run on each source line. Each function takes 4
                            arguments: filename, clean_lines, line, error
   """
 
   _SetVerboseLevel(vlevel)
+  _BackupFilters()
+
+  if not ProcessConfigOverrides(filename):
+    _RestoreFilters()
+    return
 
   lf_lines = []
   crlf_lines = []
   try:
     # Support the UNIX convention of using "-" for stdin.  Note that
     # we are not opening the file with universal newline support
     # (which codecs doesn't support anyway), so the resulting lines do
     # contain trailing '\r' characters if we are reading a file that
     # has CRLF endings.
     # If after the split a trailing '\r' is present, it is removed
@@ skipping 11 matching lines @@
     for linenum in range(len(lines) - 1):
       if lines[linenum].endswith('\r'):
         lines[linenum] = lines[linenum].rstrip('\r')
         crlf_lines.append(linenum + 1)
       else:
         lf_lines.append(linenum + 1)
 
   except IOError:
     sys.stderr.write(
         "Skipping input '%s': Can't open for reading\n" % filename)
+    _RestoreFilters()
     return
 
   # Note, if no dot is found, this will give the entire filename as the ext.
   file_extension = filename[filename.rfind('.') + 1:]
 
   # When reading from stdin, the extension is unknown, so no cpplint tests
   # should rely on the extension.
   if filename != '-' and file_extension not in _valid_extensions:
     sys.stderr.write('Ignoring %s; not a valid file name '
                      '(%s)\n' % (filename, ', '.join(_valid_extensions)))
@@ skipping 13 matching lines @@
     # server-side end-of-line sequence.
     if lf_lines and crlf_lines:
       # Warn on every line with CR.  An alternative approach might be to
       # check whether the file is mostly CRLF or just LF, and warn on the
       # minority, we bias toward LF here since most tools prefer LF.
       for linenum in crlf_lines:
         Error(filename, linenum, 'whitespace/newline', 1,
               'Unexpected \\r (^M) found; better to use only \\n')
 
   sys.stderr.write('Done processing %s\n' % filename)
+  _RestoreFilters()
 
 
 def PrintUsage(message):
   """Prints a brief usage string and exits, optionally with an error message.
 
   Args:
     message: The optional error message.
   """
   sys.stderr.write(_USAGE)
   if message:
@@ skipping 94 matching lines @@
   _cpplint_state.ResetErrorCounts()
   for filename in filenames:
     ProcessFile(filename, _cpplint_state.verbose_level)
   _cpplint_state.PrintErrorCounts()
 
   sys.exit(_cpplint_state.error_count > 0)
 
 
 if __name__ == '__main__':
   main()