Make docstrings more consistent using format-webkitpy.

third_party/WebKit/Tools/Scripts/webkitpy/style/checkers/cpp.py

 # -*- coding: utf-8 -*-
 #
 # Copyright (C) 2009, 2010, 2012 Google Inc. All rights reserved.
 # Copyright (C) 2009 Torch Mobile Inc.
 # Copyright (C) 2009 Apple Inc. All rights reserved.
 # 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:
@@ skipping 260 matching lines @@
     Args:
       s: a string which is a substring of line after '('
       (e.g., "a == (b + c))").
 
     Returns:
       A pair of strings (prefix before first unmatched ')',
       remainder of s after first unmatched ')'), e.g.,
       up_to_unmatched_closing_paren("a == (b + c)) { ")
       returns "a == (b + c)", " {".
       Returns None, None if there is no unmatched ')'
-
     """
     i = 1
     for pos, c in enumerate(s):
         if c == '(':
             i += 1
         elif c == ')':
             i -= 1
             if i == 0:
                 return s[:pos], s[pos + 1:]
     return None, None
 
 
 class _IncludeState(dict):
     """Tracks line numbers for includes, and the order in which includes appear.
 
     As a dict, an _IncludeState object serves as a mapping between include
     filename and line number on which that file was included.
 
     Call check_next_include_order() once for each header in the file, passing
     in the type constants defined above. Calls in an illegal order will
     raise an _IncludeError with an appropriate error message.
-
     """
     # self._section will move monotonically through this set. If it ever
     # needs to move backwards, check_next_include_order will raise an error.
     _INITIAL_SECTION = 0
     _PRIMARY_SECTION = 1
     _OTHER_SECTION = 2
 
     _TYPE_NAMES = {
         _PRIMARY_HEADER: 'header this file implements',
         _OTHER_HEADER: 'other header',
@@ skipping 20 matching lines @@
         This function also updates the internal state to be ready to check
         the next include.
 
         Args:
           header_type: One of the _XXX_HEADER constants defined above.
           file_is_header: Whether the file that owns this _IncludeState is itself a header
 
         Returns:
           The empty string if the header is in the right order, or an
           error message describing what's wrong.
-
         """
         if header_type == _PRIMARY_HEADER and file_is_header:
             return 'Header file should not contain itself.'
         if header_type == _MOC_HEADER:
             return ''
 
         error_message = ''
         if self._section != self._OTHER_SECTION:
             before_error_message = ('Found %s before %s' %
                                     (self._TYPE_NAMES[header_type],
@@ skipping 41 matching lines @@
         self.row = row
 
     @memoized
     def lower_with_underscores_name(self):
         """Returns the parameter name in the lower with underscores format."""
         return _convert_to_lower_with_underscores(self.name)
 
 
 class SingleLineView(object):
     """Converts multiple lines into a single line (with line breaks replaced by a
-       space) to allow for easier searching."""
+       space) to allow for easier searching.
+       """
 
     def __init__(self, lines, start_position, end_position):
         """Create a SingleLineView instance.
 
         Args:
           lines: a list of multiple lines to combine into a single line.
           start_position: offset within lines of where to start the single line.
           end_position: just after where to end (like a slice operation).
         """
         # Get the rows of interest.
@@ skipping 15 matching lines @@
         self._row_lengths = [len(line) + 1 for line in trimmed_lines]
         self._starting_row = start_position.row
 
     def convert_column_to_row(self, single_line_column_number):
         """Convert the column number from the single line into the original
         line number.
 
         Special cases:
         * Columns in the added spaces are considered part of the previous line.
         * Columns beyond the end of the line are consider part the last line
-        in the view."""
+        in the view.
+        """
         total_columns = 0
         row_offset = 0
         while row_offset < len(self._row_lengths) - 1 and single_line_column_number >= total_columns + self._row_lengths[row_offset]:
             total_columns += self._row_lengths[row_offset]
             row_offset += 1
         return self._starting_row + row_offset
 
 
 def create_skeleton_parameters(all_parameters):
     """Converts a parameter list to a skeleton version.
 
     The skeleton only has one word for the parameter name, one word for the type,
     and commas after each parameter and only there. Everything in the skeleton
-    remains in the same columns as the original."""
+    remains in the same columns as the original.
+    """
     all_simplifications = (
         # Remove template parameters, function declaration parameters, etc.
         r'(<[^<>]*?>)|(\([^\(\)]*?\))|(\{[^\{\}]*?\})',
         # Remove all initializers.
         r'=[^,]*',
         # Remove :: and everything before it.
         r'[^,]*::',
         # Remove modifiers like &, *.
         r'[&*]',
         # Remove const modifiers.
@@ skipping 45 matching lines @@
         name_offset = find_parameter_name_index(skeleton_parameter)
         parameter = single_line_view.single_line[start_index:end_index]
         yield Parameter(parameter, name_offset, row)
 
 
 class _FunctionState(object):
     """Tracks current function name and the number of lines in its body.
 
     Attributes:
       min_confidence: The minimum confidence level to use while checking style.
-
     """
 
     _NORMAL_TRIGGER = 250  # for --v=0, 500 for --v=1, etc.
     _TEST_TRIGGER = 400    # about 50% more than _NORMAL_TRIGGER.
 
     def __init__(self, min_confidence):
         self.min_confidence = min_confidence
         self.current_function = ''
         self.in_a_function = False
         self.lines_in_function = 0
@@ skipping 395 matching lines @@
 # simultaneously.
 def get_legacy_header_guard_cpp_variable(filename):
     """Returns the CPP variable that should be used as a header guard.
 
     Args:
       filename: The name of a C++ header file.
 
     Returns:
       The CPP variable that should be used as a header guard in the
       named file.
-
     """
 
     # Restores original filename in case that style checker is invoked from Emacs's
     # flymake.
     filename = re.sub(r'_flymake\.h$', '.h', filename)
 
     standard_name = sub(r'[-.\s]', '_', os.path.basename(filename))
 
     # Files under WTF typically have header guards that start with WTF_.
     if '/wtf/' in filename:
         special_name = "WTF_" + standard_name
     else:
         special_name = standard_name
     return (special_name, standard_name)
 
 
 def get_header_guard_cpp_variable(filename):
     """Returns the CPP variable that should be used as a header guard in Chromium-style.
 
     Args:
       filename: The name of a C++ header file.
 
     Returns:
       The CPP variable that should be used as a header guard in the
       named file in Chromium-style.
-
     """
 
     # Restores original filename in case that style checker is invoked from Emacs's
     # flymake.
     filename = re.sub(r'_flymake\.h$', '.h', filename)
 
     # If it's a full path and starts with Source/, replace Source with blink
     # since that will be the new style directory.
     filename = sub(r'^Source\/', 'blink/', filename)
 
@@ skipping 1306 matching lines @@
 def check_ctype_functions(clean_lines, line_number, file_state, error):
     """Looks for use of the standard functions in ctype.h and suggest they be replaced
        by use of equivalent ones in <wtf/ASCIICType.h>?.
 
     Args:
       clean_lines: A CleansedLines instance containing the file.
       line_number: The number of the line to check.
       file_state: A _FileState instance which maintains information about
                   the state of things in the file.
       error: The function to call with any errors found.
-    """
+       """
 
     line = clean_lines.elided[line_number]  # Get rid of comments and strings.
 
     ctype_function_search = search(
         r'\b(?P<ctype_function>(isalnum|isalpha|isascii|isblank|iscntrl|isdigit|isgraph|islower|isprint|ispunct|isspace|isupper|isxdigit|toascii|tolower|toupper))\s*\(', line)
     if not ctype_function_search:
         return
 
     ctype_function = ctype_function_search.group('ctype_function')
     error(line_number, 'runtime/ctype_function', 4,
@@ skipping 1242 matching lines @@
         # declaration because we need to check its arguments.
         # Also, we need to check multiple declarations.
         if character_after_identifier != '(' and character_after_identifier != ',':
             return
 
         number_of_identifiers += 1
         line = line[matched.end():]
 
 
 def check_for_toFoo_definition(filename, pattern, error):
-    """ Reports for using static_cast instead of toFoo convenience function.
+    """Reports for using static_cast instead of toFoo convenience function.
 
     This function will output warnings to make sure you are actually using
     the added toFoo conversion functions rather than directly hard coding
     the static_cast<Classname*> call. For example, you should toHTMLELement(Node*)
     to convert Node* to HTMLElement*, instead of static_cast<HTMLElement*>(Node*)
 
     Args:
       filename: The name of the header file in which to check for toFoo definition.
       pattern: The conversion function pattern to grep for.
       error: The function to call with any errors found.
@@ skipping 425 matching lines @@
       include_state: An _IncludeState instance in which the headers are inserted.
       function_state: A _FunctionState instance which counts function lines, etc.
       class_state: A _ClassState instance which maintains information about
                    the current stack of nested class declarations being parsed.
       file_state: A _FileState instance which maintains information about
                   the state of things in the file.
       enum_state: A _EnumState instance which maintains an enum declaration
                   state.
       error: A callable to which errors are reported, which takes arguments:
              line number, error level, and message
-
     """
     raw_lines = clean_lines.raw_lines
     detect_functions(clean_lines, line, function_state, error)
     check_for_function_lengths(clean_lines, line, function_state, error)
     if search(r'\bNOLINT\b', raw_lines[line]):  # ignore nolint lines
         return
     if match(r'\s*\b__asm\b', raw_lines[line]):  # Ignore asm lines as they format differently.
         return
     check_function_definition(filename, file_extension, clean_lines, line, function_state, error)
     check_pass_ptr_usage(clean_lines, line, function_state, error)
@@ skipping 136 matching lines @@
 
     fs = None
 
     def __init__(self, file_path, file_extension, handle_style_error,
                  min_confidence, fs=None):
         """Create a CppChecker instance.
 
         Args:
           file_extension: A string that is the file extension, without
                           the leading dot.
-
         """
         self.file_extension = file_extension
         self.file_path = file_path
         self.handle_style_error = handle_style_error
         self.min_confidence = min_confidence
         CppChecker.fs = fs or FileSystem()
 
     # Useful for unit testing.
     def __eq__(self, other):
         """Return whether this CppChecker instance is equal to another."""
@@ skipping 15 matching lines @@
 
     def check(self, lines):
         _process_lines(self.file_path, self.file_extension, lines,
                        self.handle_style_error, self.min_confidence)
 
 
 # FIXME: Remove this function (requires refactoring unit tests).
 def process_file_data(filename, file_extension, lines, error, min_confidence, fs=None):
     checker = CppChecker(filename, file_extension, error, min_confidence, fs)
     checker.check(lines)