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:
+
+      filter=+filter1,-filter2,...
+      exclude_files=regex
+
+    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 GetConfigOverrideFiles(filename):
+  """ Looks for CPPLINT.cfg files in the directory containing |filename| and

[sosa, 2014/07/23 20:25:42]

docstring issue

[Alex Vakulenko (Google), 2014/07/23 20:44:32]

Done.

+  its parents and returns a list of configuration files found.
+
+  Args:
+    filename: The name of the file being processed by the linter.
+  """
+
+  cfg_override_files = []
+  abs_path = os.path.abspath(os.path.dirname(filename))
+
+  while True:
+    file = os.path.join(abs_path, "CPPLINT.cfg")
+    if os.path.isfile(file):
+      cfg_override_files.append(file)
+    parent = os.path.dirname(abs_path)
+    if parent == abs_path:
+      break
+    abs_path = parent
+
+  return reversed(cfg_override_files)
+
+def ProcessConfigFile(cfg_file, filename):
+  """ Loads the configuration file and processes the config overrides.
+
+  Args:
+    cfg_file: config file to process
+    filename: The name of the file being processed by the linter.
+
+  Returns:
+    false if the current |filename| should not be processed further.
+  """
+
+  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 == 'filter':
+            _AddFilters(val)
+          elif name == 'exclude_files':
+            pattern = re.compile(val)
+            if pattern.match(filename):
+              sys.stderr.write('Ignoring %s; file excluded by (%s)\n' %
+                               (filename, cfg_file))
+              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)
+    _RestoreFilters()
+    return True
+
+  return True
+
+
+def ProcessConfigOverrides(cfg_override_files, filename):
+  """ Loads the configuration files and processes the config overrides.
+
+  Args:
+    cfg_override_files: list of cfg files to process
+    filename: The name of the file being processed by the linter.
+
+  Returns:
+    false if the current |filename| should not be processed further.
+  """
+  for cfg_file in cfg_override_files:
+    if not ProcessConfigFile(cfg_file, filename):
+      return False
+
+  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()
+
+  cfg_override_files = GetConfigOverrideFiles(filename)
+  if not ProcessConfigOverrides(cfg_override_files, 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()