Add support for methods for Google style arg check (#384)

This patch adds support for checking the Args section of
methods.

Author: sambhav

docs/error_codes.rst

@@ -9,16 +9,19 @@ Grouping
 Default conventions
 -------------------
 
-Not all error codes are checked for by default.  There are two
-conventions that may be used by pydocstyle: pep257 and numpy.
+Not all error codes are checked for by default.  There are three
+conventions that may be used by pydocstyle: pep257, numpy and google.
 
 The pep257 convention, which is enabled by default in pydocstyle,
 checks for all of the above errors except for D203, D212, D213, D214,
-D215, D404, D405, D406, D407, D408, D409, D410, and D411 (as specified
-in `PEP257 <http://www.python.org/dev/peps/pep-0257/>`_).
+D215, D404, D405, D406, D407, D408, D409, D410, D411, D415, D416 and D417
+(as specified in `PEP257 <http://www.python.org/dev/peps/pep-0257/>`_).
 
 The numpy convention checks for all of the above errors except for
-D107, D203, D212, D213, D402, and D413.
+D107, D203, D212, D213, D402, D413, D415, D416 and D417.
+
+The google convention checks for all of the above errors except for
+D203, D204, D213, D215, D400, D401, D404, D406, D407, D408 and D409.
 
 These conventions may be specified using `--convention=<name>` when
 running pydocstyle from the command line or by specifying the

docs/release_notes.rst

@@ -4,6 +4,14 @@ Release Notes
 **pydocstyle** version numbers follow the
 `Semantic Versioning <http://semver.org/>`_ specification.
 
+Current Development Version
+---------------------------
+
+New Features
+
+* Extend support for detecting missing arguments in Google style
+  docstrings to method calls (#384).
+
 4.0.1 - August 14th, 2019
 -------------------------
 

docs/snippets/cli.rst

@@ -54,7 +54,7 @@ Usage
         --convention=<name>
                             choose the basic list of checked errors by specifying
                             an existing convention. Possible conventions: pep257,
-                            numpy.
+                            numpy, google.
         --add-select=<codes>
                             add extra error codes to check to the basic list of
                             errors previously set by --select, --ignore or

src/pydocstyle/checker.py

@@ -682,16 +682,21 @@ def _check_args_section(docstring, definition, context):
                 except `self` or `cls` if it is a method.
 
         """
-        if definition.kind == 'function':
-            function_pos_args = get_function_args(definition.source)
-            docstring_args = set()
-            for line in context.following_lines:
-                match = ConventionChecker.GOOGLE_ARGS_REGEX.match(line)
-                if match:
-                    docstring_args.add(match.group(1))
-            missing_args = function_pos_args - docstring_args
-            if missing_args:
-                yield violations.D417(", ".join(missing_args), definition.name)
+        docstring_args = set()
+        for line in context.following_lines:
+            match = ConventionChecker.GOOGLE_ARGS_REGEX.match(line)
+            if match:
+                docstring_args.add(match.group(1))
+        function_args = get_function_args(definition.source)
+        # If the method isn't static, then we skip the first
+        # positional argument as it is `cls` or `self`
+        if definition.kind == 'method' and not definition.is_static:
+            function_args = function_args[1:]
+        missing_args = set(function_args) - docstring_args
+        if missing_args:
+            yield violations.D417(", ".join(sorted(missing_args)),
+                                  definition.name)
+
 
     @classmethod
     def _check_google_section(cls, docstring, definition, context):
@@ -921,4 +926,4 @@ def get_function_args(function_string):
     function_arg_node = ast.parse(textwrap.dedent(function_string)).body[0].args
     arg_nodes = function_arg_node.args
     kwonly_arg_nodes = function_arg_node.kwonlyargs
-    return set(arg_node.arg for arg_node in chain(arg_nodes, kwonly_arg_nodes))
+    return [arg_node.arg for arg_node in chain(arg_nodes, kwonly_arg_nodes)]

src/pydocstyle/parser.py

@@ -181,6 +181,13 @@ def is_public(self):
                           self.is_magic)
         return self.parent.is_public and name_is_public
 
+    @property
+    def is_static(self):
+        for decorator in self.decorators:
+            if decorator.name == "staticmethod":
+                return True
+        return False
+
 
 class Class(Definition):
     """A Python source code class."""

src/pydocstyle/violations.py

@@ -252,8 +252,8 @@ def to_rst(cls) -> str:
                                  'mark, or exclamation point', 'not {0!r}')
 D416 = D4xx.create_error('D416', 'Section name should end with a semicolon',
                          '{0!r}, not {1!r}')
-D417 = D4xx.create_error('D417', 'Missing arguments in the function docstring',
-                         'argument(s) {0!r} missing in function {1!r} docstring')
+D417 = D4xx.create_error('D417', 'Missing arguments in the docstring',
+                         'argument(s) {0!r} missing in {1!r} docstring')
 
 class AttrDict(dict):
     def __getattr__(self, item: str) -> Any:

src/tests/test_cases/expected.py

@@ -4,12 +4,14 @@ class Expectation:
     def __init__(self):
         self.expected = set()
 
-    def expect(self, *args):
+    def expect(self, *args, arg_count=0):
         """Decorator that expects a certain PEP 257 violation."""
-        def none(_):
-            return None
-
+        # The `arg_count` parameter helps the decorator
+        # with functions that have positional arguments.
         if len(args) == 1:
-            return lambda f: (self.expected.add((f.__name__, args[0])) or
-                              none(f()) or f)
+            def decorate(f):
+                self.expected.add((f.__name__, args[0]))
+                f(*[None]*arg_count)
+                return f
+            return decorate
         self.expected.add(args)

src/tests/test_cases/sections.py

@@ -275,13 +275,61 @@ def missing_colon_google_style_section():  # noqa: D406, D407
 
 
 @expect(_D213)
-@expect("D417: Missing arguments in the function docstring "
-        "(argument(s) 'y' missing in function "
+@expect("D417: Missing arguments in the docstring "
+        "(argument(s) 'y' missing in "
         "'test_missing_args' docstring)")
-def test_missing_args(x=1, y=2):  # noqa: D407, D407
+def test_missing_args(x=1, y=2):  # noqa: D406, D407
     """Toggle the gizmo.
 
     Args:
         x (int): The greatest integer.
 
     """
+
+
+class Test:  # noqa: D203
+    """Test class."""
+
+    def test_method(self, test, another_test):  # noqa: D213, D407
+        """Test a valid args section.
+
+        Args:
+            test: A parameter.
+            another_test: Another parameter.
+
+        """
+
+    @expect("D417: Missing arguments in the docstring "
+            "(argument(s) 'test, y, z' missing in "
+            "'test_missing_args' docstring)", arg_count=4)
+    def test_missing_args(self, test, x, y, z=3):  # noqa: D213, D407
+        """Test a valid args section.
+
+        Args:
+            x: Another parameter.
+
+        """
+
+    @classmethod
+    @expect("D417: Missing arguments in the docstring "
+            "(argument(s) 'test, y, z' missing in "
+            "'test_missing_args_class_method' docstring)", arg_count=4)
+    def test_missing_args_class_method(cls, test, x, y, z=3):  # noqa: D213, D407
+        """Test a valid args section.
+
+        Args:
+            x: Another parameter.
+
+        """
+
+    @staticmethod
+    @expect("D417: Missing arguments in the docstring "
+            "(argument(s) 'a, y, z' missing in "
+            "'test_missing_args_static_method' docstring)", arg_count=3)
+    def test_missing_args_static_method(a, x, y, z=3):  # noqa: D213, D407
+        """Test a valid args section.
+
+        Args:
+            x: Another parameter.
+
+        """