Make docstrings more consistent using format-webkitpy.

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

 # Copyright (C) 2010 Chris Jerdonek (cjerdonek@webkit.org)
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions
 # are met:
 # 1.  Redistributions of source code must retain the above copyright
 #     notice, this list of conditions and the following disclaimer.
 # 2.  Redistributions in binary form must reproduce the above copyright
 #     notice, this list of conditions and the following disclaimer in the
 #     documentation and/or other materials provided with the distribution.
@@ skipping 90 matching lines @@
 
 
 # This class should not have knowledge of the flag key names.
 class DefaultCommandOptionValues(object):
 
     """Stores the default check-webkit-style command-line options.
 
     Attributes:
       output_format: A string that is the default output format.
       min_confidence: An integer that is the default minimum confidence level.
-
     """
 
     def __init__(self, min_confidence, output_format):
         self.min_confidence = min_confidence
         self.output_format = output_format
 
 
 # This class should not have knowledge of the flag key names.
 class CommandOptionValues(object):
 
@@ skipping 10 matching lines @@
       git_commit: A string representing the git commit to check.
                   The default is None.
 
       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 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.
-
     """
 
     def __init__(self,
                  filter_rules=None,
                  git_commit=None,
                  diff_files=None,
                  is_verbose=False,
                  min_confidence=1,
                  output_format="emacs"):
         if filter_rules is None:
@@ skipping 47 matching lines @@
     def _flag_pair_to_string(self, flag_key, flag_value):
         return '--%(key)s=%(val)s' % {'key': flag_key, 'val': flag_value}
 
     def to_flag_string(self, options):
         """Return a flag string of the given CommandOptionValues instance.
 
         This method orders the flag values alphabetically by the flag key.
 
         Args:
           options: A CommandOptionValues instance.
-
         """
         flags = {}
         flags['min-confidence'] = options.min_confidence
         flags['output'] = options.output_format
         # Only include the filter flag if user-provided rules are present.
         filter_rules = options.filter_rules
         if filter_rules:
             flags['filter'] = ",".join(filter_rules)
         if options.git_commit:
             flags['git-commit'] = options.git_commit
@@ skipping 18 matching lines @@
       create_usage: A function that accepts a DefaultCommandOptionValues
                     instance and returns a string of usage instructions.
                     Defaults to the function that generates the usage
                     string for check-webkit-style.
       default_options: A DefaultCommandOptionValues instance that provides
                        the default values for options not explicitly
                        provided by the user.
       stderr_write: A function that takes a string as a parameter and
                     serves as stderr.write.  Defaults to sys.stderr.write.
                     This parameter should be specified only for unit tests.
-
     """
 
     def __init__(self,
                  all_categories,
                  default_options,
                  base_filter_rules=None,
                  mock_stderr=None,
                  usage=None):
         """Create an ArgumentParser instance.
 
         Args:
           all_categories: The set of all available style categories.
           default_options: See the corresponding attribute in the class
                            docstring.
         Keyword Args:
           base_filter_rules: The list of filter rules at the beginning of
                              the list of rules used to check style.  This
                              list has the least precedence when checking
                              style and precedes any user-provided rules.
                              The class uses this parameter only for display
                              purposes to the user.  Defaults to the empty list.
           create_usage: See the documentation of the corresponding
                         attribute in the class docstring.
           stderr_write: See the documentation of the corresponding
                         attribute in the class docstring.
-
         """
         if base_filter_rules is None:
             base_filter_rules = []
         stderr = sys.stderr if mock_stderr is None else mock_stderr
         if usage is None:
             usage = _USAGE
 
         self._all_categories = all_categories
         self._base_filter_rules = base_filter_rules
 
@@ skipping 98 matching lines @@
                           'and before any --filter flag.\n\n')
 
         sys.exit(0)
 
     def _parse_filter_flag(self, flag_value):
         """Parse the --filter flag, and return a list of filter rules.
 
         Args:
           flag_value: A string of comma-separated filter rules, for
                       example "-whitespace,+whitespace/indent".
-
         """
         filters = []
         for uncleaned_filter in flag_value.split(','):
             filter = uncleaned_filter.strip()
             if not filter:
                 continue
             filters.append(filter)
         return filters
 
     def parse(self, args):
         """Parse the command line arguments to check-webkit-style.
 
         Args:
           args: A list of command-line arguments as returned by sys.argv[1:].
 
         Returns:
           A tuple of (paths, options)
 
           paths: The list of paths to check.
           options: A CommandOptionValues instance.
-
         """
         (options, paths) = self._parser.parse_args(args=args)
 
         filter_value = options.filter_value
         git_commit = options.git_commit
         diff_files = options.diff_files
         is_verbose = options.is_verbose
         min_confidence = options.min_confidence
         output_format = options.output_format
 
@@ skipping 21 matching lines @@
             self._parse_error(err)
 
         options = CommandOptionValues(filter_rules=filter_rules,
                                       git_commit=git_commit,
                                       diff_files=diff_files,
                                       is_verbose=is_verbose,
                                       min_confidence=min_confidence,
                                       output_format=output_format)
 
         return (paths, options)