Make docstrings more consistent using format-webkitpy.

third_party/WebKit/Tools/Scripts/webkitpy/style/checker.py

 # Copyright (C) 2009 Google Inc. All rights reserved.
 # Copyright (C) 2010 Chris Jerdonek (chris.jerdonek@gmail.com)
 # Copyright (C) 2010 ProFUSION embedded systems
 #
 # 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 256 matching lines @@
     return ArgumentParser(all_categories=all_categories,
                           base_filter_rules=_BASE_FILTER_RULES,
                           default_options=default_options)
 
 
 def check_webkit_style_configuration(options):
     """Return a StyleProcessorConfiguration instance for check-webkit-style.
 
     Args:
       options: A CommandOptionValues instance.
-
     """
     filter_configuration = FilterConfiguration(
         base_rules=_BASE_FILTER_RULES,
         path_specific=_PATH_RULES_SPECIFIER,
         user_rules=options.filter_rules)
 
     return StyleProcessorConfiguration(filter_configuration=filter_configuration,
                                        max_reports_per_category=_MAX_REPORTS_PER_CATEGORY,
                                        min_confidence=options.min_confidence,
                                        output_format=options.output_format,
                                        stderr_write=sys.stderr.write)
 
 
 def _create_log_handlers(stream):
     """Create and return a default list of logging.Handler instances.
 
     Format WARNING messages and above to display the logging level, and
     messages strictly below WARNING not to display it.
 
     Args:
       stream: See the configure_logging() docstring.
-
     """
     # Handles logging.WARNING and above.
     error_handler = logging.StreamHandler(stream)
     error_handler.setLevel(logging.WARNING)
     formatter = logging.Formatter("%(levelname)s: %(message)s")
     error_handler.setFormatter(formatter)
 
     # Create a logging.Filter instance that only accepts messages
     # below WARNING (i.e. filters out anything WARNING or above).
     non_error_filter = logging.Filter()
     # The filter method accepts a logging.LogRecord instance.
     non_error_filter.filter = lambda record: record.levelno < logging.WARNING
 
     non_error_handler = logging.StreamHandler(stream)
     non_error_handler.addFilter(non_error_filter)
     formatter = logging.Formatter("%(message)s")
     non_error_handler.setFormatter(formatter)
 
     return [error_handler, non_error_handler]
 
 
 def _create_debug_log_handlers(stream):
     """Create and return a list of logging.Handler instances for debugging.
 
     Args:
       stream: See the configure_logging() docstring.
-
     """
     handler = logging.StreamHandler(stream)
     formatter = logging.Formatter("%(name)s: %(levelname)-8s %(message)s")
     handler.setFormatter(formatter)
 
     return [handler]
 
 
 def configure_logging(stream, logger=None, is_verbose=False):
     """Configure logging, and return the list of handlers added.
 
     Returns:
       A list of references to the logging handlers added to the root
       logger.  This allows the caller to later remove the handlers
       using logger.removeHandler.  This is useful primarily during unit
       testing where the caller may want to configure logging temporarily
       and then undo the configuring.
 
     Args:
       stream: A file-like object to which to log.  The stream must
               define an "encoding" data attribute, or else logging
               raises an error.
       logger: A logging.logger instance to configure.  This parameter
               should be used only in unit tests.  Defaults to the
               root logger.
       is_verbose: A boolean value of whether logging should be verbose.
-
     """
     # If the stream does not define an "encoding" data attribute, the
     # logging module can throw an error like the following:
     #
     # Traceback (most recent call last):
     #   File "/System/Library/Frameworks/Python.framework/Versions/2.6/...
     #         lib/python2.6/logging/__init__.py", line 761, in emit
     #     self.stream.write(fs % msg.encode(self.stream.encoding))
     # LookupError: unknown encoding: unknown
     if logger is None:
@@ skipping 156 matching lines @@
 
     Attributes:
       min_confidence: An integer between 1 and 5 inclusive that is the
                       minimum confidence level of style errors to report.
 
       max_reports_per_category: The maximum number of errors to report
                                 per category, per file.
 
       stderr_write: A function that takes a string as a parameter and
                     serves as stderr.write.
-
     """
 
     def __init__(self,
                  filter_configuration,
                  max_reports_per_category,
                  min_confidence,
                  output_format,
                  stderr_write):
         """Create a StyleProcessorConfiguration instance.
 
         Args:
           filter_configuration: A FilterConfiguration instance.  The default
                                 is the "empty" filter configuration, which
                                 means that all errors should be checked.
 
           max_reports_per_category: The maximum number of errors to report
                                     per category, per file.
 
           min_confidence: An integer between 1 and 5 inclusive that is the
                           minimum confidence level of style errors to report.
                           The default is 1, which reports all style errors.
 
           output_format: A string that is the output format.  The supported
                          output formats are "emacs" which emacs can parse
                          and "vs7" which Microsoft Visual Studio 7 can parse.
 
           stderr_write: A function that takes a string as a parameter and
                         serves as stderr.write.
-
         """
         self._filter_configuration = filter_configuration
         self._output_format = output_format
 
         self.max_reports_per_category = max_reports_per_category
         self.min_confidence = min_confidence
         self.stderr_write = stderr_write
 
     def is_reportable(self, category, confidence_in_error, file_path):
         """Return whether an error is reportable.
 
         An error is reportable if both the confidence in the error is
         at least the minimum confidence level and the current filter
         says the category should be checked for the given path.
 
         Args:
           category: A string that is a style category.
           confidence_in_error: An integer between 1 and 5 inclusive that is
                                the application's confidence in the error.
                                A higher number means greater confidence.
           file_path: The path of the file being checked
-
         """
         if confidence_in_error < self.min_confidence:
             return False
 
         return self._filter_configuration.should_check(category, file_path)
 
     def write_style_error(self,
                           category,
                           confidence_in_error,
                           file_path,
@@ skipping 15 matching lines @@
 class ProcessorBase(object):
 
     """The base class for processors of lists of lines."""
 
     def should_process(self, file_path):
         """Return whether the file at file_path should be processed.
 
         The TextFileReader class calls this method prior to reading in
         the lines of a file.  Use this method, for example, to prevent
         the style checker from reading binary files into memory.
-
         """
         raise NotImplementedError('Subclasses should implement.')
 
     def process(self, lines, file_path, **kwargs):
         """Process lines of text read from a file.
 
         Args:
           lines: A list of lines of text to process.
           file_path: The path from which the lines were read.
           **kwargs: This argument signifies that the process() method of
                     subclasses of ProcessorBase may support additional
                     keyword arguments.
                         For example, a style checker's check() method
                     may support a "reportable_lines" parameter that represents
                     the line numbers of the lines for which style errors
                     should be reported.
-
         """
         raise NotImplementedError('Subclasses should implement.')
 
 
 class StyleProcessor(ProcessorBase):
 
     """A ProcessorBase for checking style.
 
     Attributes:
       error_count: An integer that is the total number of reported
                    errors for the lifetime of this instance.
-
     """
 
     def __init__(self, configuration, mock_dispatcher=None,
                  mock_increment_error_count=None,
                  mock_carriage_checker_class=None):
         """Create an instance.
 
         Args:
           configuration: A StyleProcessorConfiguration instance.
           mock_dispatcher: A mock CheckerDispatcher instance.  This
                            parameter is for unit testing.  Defaults to a
                            CheckerDispatcher instance.
           mock_increment_error_count: A mock error-count incrementer.
           mock_carriage_checker_class: A mock class for checking and
                                        transforming carriage returns.
                                        This parameter is for unit testing.
                                        Defaults to CarriageReturnChecker.
-
         """
         if mock_dispatcher is None:
             dispatcher = CheckerDispatcher()
         else:
             dispatcher = mock_dispatcher
 
         if mock_increment_error_count is None:
             # The following blank line is present to avoid flagging by pep8.py.
 
             def increment_error_count():
@@ skipping 31 matching lines @@
         Arguments:
           lines: A list of all lines in the file to check.
           file_path: The path of the file to process.  If possible, the path
                      should be relative to the source root.  Otherwise,
                      path-specific logic may not behave as expected.
           line_numbers: A list of line numbers of the lines for which
                         style errors should be reported, or None if errors
                         for all lines should be reported.  When not None, this
                         list normally contains the line numbers corresponding
                         to the modified lines of a patch.
-
         """
         _log.debug("Checking style: " + file_path)
 
         style_error_handler = DefaultStyleErrorHandler(
             configuration=self._configuration,
             file_path=file_path,
             increment_error_count=self._increment_error_count,
             line_numbers=line_numbers)
 
         carriage_checker = self._carriage_checker_class(style_error_handler)
 
         # Check for and remove trailing carriage returns ("\r").
         if self._dispatcher.should_check_and_strip_carriage_returns(file_path):
             lines = carriage_checker.check(lines)
 
         min_confidence = self._configuration.min_confidence
         checker = self._dispatcher.dispatch(file_path,
                                             style_error_handler,
                                             min_confidence)
 
         if checker is None:
             raise AssertionError("File should not be checked: '%s'" % file_path)
 
         _log.debug("Using class: " + checker.__class__.__name__)
 
         checker.check(lines)