docsig 0.47.0__tar.gz → 0.48.0__tar.gz

{docsig-0.47.0 → docsig-0.48.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: docsig
-Version: 0.47.0
+Version: 0.48.0
 Summary: Check signature params for proper documentation
 Home-page: https://pypi.org/project/docsig/
 License: MIT
@@ -22,7 +22,6 @@ Requires-Dist: Sphinx (>=7.0.0,<8.0.0)
 Requires-Dist: arcon (>=0.4.0)
 Requires-Dist: astroid (>=3.0.1,<4.0.0)
 Requires-Dist: object-colors (>=2.1.0,<3.0.0)
-Requires-Dist: typing-extensions (>=4.8.0,<5.0.0)
 Project-URL: Documentation, https://docsig.readthedocs.io/en/latest
 Project-URL: Repository, https://github.com/jshwi/docsig
 Description-Content-Type: text/x-rst
@@ -139,7 +138,7 @@ Commandline
       -s STR, --string STR                 string to parse instead of files
       -d LIST, --disable LIST              comma separated list of rules to disable
       -t LIST, --target LIST               comma separated list of rules to target
-      -e EXCLUDE, --exclude EXCLUDE        regular expression of files or dirs to exclude
+      -e PATTERN, --exclude PATTERN        regular expression of files or dirs to exclude
                                            from checks
 
 Options can also be configured with the pyproject.toml file
@@ -182,7 +181,7 @@ API
     ...     :param param3: About param3.
     ...     '''
     ...     """
-    >>> docsig(string=string)
+    >>> docsig(string=string, no_ansi=True)
     0
 
 .. code-block:: python
@@ -196,7 +195,7 @@ API
     ...     :param param3: About param3.
     ...     '''
     ... """
-    >>> docsig(string=string)
+    >>> docsig(string=string, no_ansi=True)
     2
     -
     def function(✓param1, ✓param2, ✖None) -> ✓None:
@@ -233,7 +232,7 @@ It can be added to your .pre-commit-config.yaml as follows:
 
     repos:
       - repo: https://github.com/jshwi/docsig
-        rev: v0.47.0
+        rev: v0.48.0
         hooks:
           - id: docsig
             args:

{docsig-0.47.0 → docsig-0.48.0}/README.rst

@@ -110,7 +110,7 @@ Commandline
       -s STR, --string STR                 string to parse instead of files
       -d LIST, --disable LIST              comma separated list of rules to disable
       -t LIST, --target LIST               comma separated list of rules to target
-      -e EXCLUDE, --exclude EXCLUDE        regular expression of files or dirs to exclude
+      -e PATTERN, --exclude PATTERN        regular expression of files or dirs to exclude
                                            from checks
 
 Options can also be configured with the pyproject.toml file
@@ -153,7 +153,7 @@ API
     ...     :param param3: About param3.
     ...     '''
     ...     """
-    >>> docsig(string=string)
+    >>> docsig(string=string, no_ansi=True)
     0
 
 .. code-block:: python
@@ -167,7 +167,7 @@ API
     ...     :param param3: About param3.
     ...     '''
     ... """
-    >>> docsig(string=string)
+    >>> docsig(string=string, no_ansi=True)
     2
     -
     def function(✓param1, ✓param2, ✖None) -> ✓None:
@@ -204,7 +204,7 @@ It can be added to your .pre-commit-config.yaml as follows:
 
     repos:
       - repo: https://github.com/jshwi/docsig
-        rev: v0.47.0
+        rev: v0.48.0
         hooks:
           - id: docsig
             args:

{docsig-0.47.0 → docsig-0.48.0}/docsig/_config.py

@@ -149,5 +149,6 @@ class Parser(_ArgumentParser):
         self.add_argument(
             "-e",
             "--exclude",
+            metavar="PATTERN",
             help="regular expression of files or dirs to exclude from checks",
         )

{docsig-0.47.0 → docsig-0.48.0}/docsig/_core.py

@@ -16,7 +16,7 @@ from ._message import Message as _Message
 from ._module import Function as _Function
 from ._module import Modules as _Modules
 from ._module import Parent as _Parent
-from ._report import generate_report as _generate_report
+from ._report import Report as _Report
 from .messages import TEMPLATE as _TEMPLATE
 from .messages import E as _E
 
@@ -73,7 +73,7 @@ def _run_check(  # pylint: disable=too-many-arguments
             and not (child.isdunder and not check_dunders)
             and not (child.docstring.bare and ignore_no_params)
         ):
-            report = _generate_report(
+            report = _Report(
                 child, targets, child.disabled, check_property_returns
             )
             if report:

{docsig-0.47.0 → docsig-0.48.0}/docsig/_decorators.py

@@ -59,7 +59,7 @@ def validate_args(func: _FuncType) -> _WrappedFuncType:
             for message in kwargs.get("targets") or []:
                 if not message.isknown:
                     stderr.append(
-                        f"unknown option to target '{message.description}'",
+                        f"unknown option to target '{message.description}'"
                     )
 
             if kwargs.get("check_class") and kwargs.get(

{docsig-0.47.0 → docsig-0.48.0}/docsig/_directives.py

@@ -10,8 +10,6 @@ import tokenize as _tokenize
 import typing as _t
 from io import StringIO as _StringIO
 
-from typing_extensions import Self as _Self
-
 from ._message import Message as _Message
 from .messages import E as _E
 
@@ -96,7 +94,7 @@ class Directive:
         return self._kind == self._valid_kinds[1]
 
     @classmethod
-    def parse(cls, comment: str, col: int) -> _Self | None:
+    def parse(cls, comment: str, col: int) -> Directive | None:
         """Parse string into directive object if possible.
 
         :param comment: Comment to parse.

{docsig-0.47.0 → docsig-0.48.0}/docsig/_display.py

@@ -209,15 +209,7 @@ class Failures(_t.List[Failure]):
     """Sequence of failed functions."""
 
 
-class _DisplaySequence(_t.Dict[str, _t.List[Failures]]):
-    def __getitem__(self, key: str) -> list[Failures]:
-        if key not in super().__iter__():
-            super().__setitem__(key, [])
-
-        return super().__getitem__(key)
-
-
-class Display(_DisplaySequence):
+class Display(_t.Dict[str, _t.List[Failures]]):
     """Collect and display report.
 
     :param no_ansi: Disable ANSI output.
@@ -227,6 +219,12 @@ class Display(_DisplaySequence):
         super().__init__()
         self._ansi = _ANSI(no_ansi)
 
+    def __getitem__(self, key: str) -> list[Failures]:
+        if key not in super().__iter__():
+            super().__setitem__(key, [])
+
+        return super().__getitem__(key)
+
     def report(self) -> None:
         """Display report if any checks have failed."""
         for key, value in self.items():
@@ -253,8 +251,8 @@ class Display(_DisplaySequence):
 
                     header += f" in {function}"
                     print(
-                        "{}\n\t{}".format(
+                        "{}\n    {}".format(
                             self._ansi.color(header, color.magenta),
-                            failure.report.get_report("\t").strip(),
+                            failure.report.get_report("    ").strip(),
                         )
                     )

docsig-0.48.0/docsig/_main.py

@@ -0,0 +1,45 @@
+"""
+docsig._main
+============
+
+Contains package entry point.
+"""
+
+from __future__ import annotations as _
+
+from ._config import Parser as _Parser
+from ._core import docsig as _docsig
+from ._hooks import pretty_print_error as _pretty_print_error
+
+
+def main() -> str | int:
+    """Main function for package.
+
+    Collect config and arguments for the commandline.
+
+    :return: Exit status for whether test failed or not.
+    """
+    p = _Parser()
+    _pretty_print_error()
+    return _docsig(
+        *p.args.path,
+        string=p.args.string,
+        list_checks=p.args.list_checks,
+        check_class=p.args.check_class,
+        check_class_constructor=p.args.check_class_constructor,
+        check_dunders=p.args.check_dunders,
+        check_protected_class_methods=p.args.check_protected_class_methods,
+        check_nested=p.args.check_nested,
+        check_overridden=p.args.check_overridden,
+        check_protected=p.args.check_protected,
+        check_property_returns=p.args.check_property_returns,
+        ignore_no_params=p.args.ignore_no_params,
+        ignore_args=p.args.ignore_args,
+        ignore_kwargs=p.args.ignore_kwargs,
+        no_ansi=p.args.no_ansi,
+        summary=p.args.summary,
+        verbose=p.args.verbose,
+        targets=p.args.target,
+        disable=p.args.disable,
+        exclude=p.args.exclude,
+    )

docsig-0.48.0/docsig/_report.py

@@ -0,0 +1,196 @@
+"""
+docsig._report
+==============
+"""
+
+from __future__ import annotations as _
+
+import typing as _t
+
+from ._message import Message as _Message
+from ._module import Function as _Function
+from ._stub import RETURN as _RETURN
+from ._stub import Param as _Param
+from ._utils import almost_equal as _almost_equal
+from .messages import TEMPLATE as _TEMPLATE
+from .messages import E as _E
+
+_MIN_MATCH = 0.8
+_MAX_MATCH = 1.0
+
+
+class Report(_t.List[str]):
+    """Compile and produce report.
+
+    :param func: Function object.
+    :param targets: List of errors to target.
+    :param disable: List of errors to disable.
+    :param check_property_returns: Run return checks on properties.
+    """
+
+    def __init__(
+        self,
+        func: _Function,
+        targets: list[_Message],
+        disable: list[_Message],
+        check_property_returns: bool,
+    ) -> None:
+        super().__init__()
+        self._disable = list(disable)
+        if targets:
+            errors = list(_E.all(1))
+            for target in targets:
+                errors.remove(target)
+
+            self._disable.extend(errors)
+
+        self._errors: list[_Message] = []
+        self._func = func
+        self._no_prop_return = func.isproperty and not check_property_returns
+        self._no_returns = func.isinit or self._no_prop_return
+        self._invalid_directive()
+        self._invalid_directive_options()
+        self._missing_class_docstring()
+        self._missing_func_docstring()
+        if func.docstring.string is not None:
+            self._return_not_typed()
+            self._exists()
+            self._missing()
+            self._duplicates()
+            self._extra_return()
+            self._missing_return()
+            self._property_return()
+            self._class_return()
+            for index in range(len(func)):
+                arg = func.signature.args.get(index)
+                doc = func.docstring.args.get(index)
+                self._description_syntax(doc)
+                self._indent_syntax(doc)
+                if arg != doc:
+                    self._order(arg, doc)
+                    self._incorrect(arg, doc)
+                    self._misspelled(arg, doc)
+                    self._not_equal(arg, doc)
+
+        self.sort()
+
+    def _add(self, value: _Message, hint: bool = False, **kwargs) -> None:
+        self._errors.append(value)
+        message = value.fstring(_TEMPLATE)
+        if kwargs:
+            message = message.format(**kwargs)
+
+        if hint:
+            message += f"\nhint: {value.hint}"
+
+        if value not in self._disable and message not in self:
+            super().append(message)
+
+    def _order(self, sig: _Param, doc: _Param) -> None:
+        if any(sig.name == i.name for i in self._func.docstring.args) or any(
+            doc.name == i.name for i in self._func.signature.args
+        ):
+            self._add(_E[101])
+
+    def _exists(self) -> None:
+        if len(self._func.docstring.args) > len(self._func.signature.args):
+            self._add(_E[102])
+
+    def _missing_func_docstring(self) -> None:
+        if not self._func.isinit and self._func.docstring.string is None:
+            self._add(_E[113])
+
+    def _missing_class_docstring(self) -> None:
+        if self._func.isinit and self._func.docstring.string is None:
+            self._add(_E[114])
+
+    def _missing(self) -> None:
+        if len(self._func.signature.args) > len(self._func.docstring.args):
+            self._add(_E[103])
+
+    def _duplicates(self) -> None:
+        if self._func.docstring.args.duplicated:
+            self._add(_E[106])
+
+    def _extra_return(self) -> None:
+        if (
+            self._func.docstring.returns
+            and self._func.signature.rettype == "None"
+            and not self._no_returns
+        ):
+            self._add(_E[104])
+
+    def _property_return(self) -> None:
+        if self._func.docstring.returns and self._no_prop_return:
+            self._add(_E[108], hint=True)
+
+    def _return_not_typed(self) -> None:
+        if self._func.signature.rettype is None and not self._no_returns:
+            self._add(_E[109])
+
+    def _missing_return(self) -> None:
+        hint = False
+        if (
+            self._func.signature.returns
+            and not self._func.docstring.returns
+            and not self._no_returns
+        ):
+            docstring = self._func.docstring.string
+            if docstring is not None and _RETURN in docstring:
+                hint = True
+
+            self._add(_E[105], hint=hint)
+
+    def _incorrect(self, sig: _Param, doc: _Param) -> None:
+        if sig.name is None and doc.name is None:
+            self._add(_E[107])
+
+    # final catch-all
+    def _not_equal(self, sig: _Param, doc: _Param) -> None:
+        if sig.name is not None and doc.name is not None and not self._errors:
+            self._add(_E[110])
+
+    def _class_return(self) -> None:
+        if self._func.docstring.returns and self._func.isinit:
+            self._add(_E[111], hint=True)
+
+    def _misspelled(self, sig: _Param, doc: _Param) -> None:
+        if (
+            sig.name is not None
+            and doc.name is not None
+            and not self._errors
+            and _almost_equal(sig.name, doc.name, _MIN_MATCH, _MAX_MATCH)
+        ):
+            self._add(_E[112])
+
+    def _description_syntax(self, doc: _Param) -> None:
+        if doc.description is not None and not doc.description.startswith(" "):
+            self._add(_E[115])
+
+    def _indent_syntax(self, doc: _Param) -> None:
+        if doc.indent > 0:
+            self._add(_E[116])
+
+    def _invalid_directive(self) -> None:
+        for directive in self._func.directives:
+            if not directive.isvalid:
+                err = _E[int(f"20{1 if directive.ismodule else 2}")]
+                self._add(err, directive=directive.kind)
+
+    def _invalid_directive_options(self) -> None:
+        for directive in self._func.directives:
+            if directive.rules.unknown:
+                err = _E[int(f"20{3 if directive.ismodule else 4}")]
+                for rule in directive.rules.unknown:
+                    self._add(
+                        err, directive=directive.kind, option=rule.description
+                    )
+
+    def get_report(self, prefix: str = "") -> str:
+        """Get report compiled as a string.
+
+        :param prefix: Prefix report.
+        :return: Current report.
+        """
+        report = f"\n{prefix}".join(self)
+        return f"{report}\n"

{docsig-0.47.0 → docsig-0.48.0}/docsig/_version.py

@@ -8,4 +8,4 @@ Allows for access to the version internally without cyclic imports
 caused by accessing it through __init__.
 """
 
-__version__ = "0.47.0"
+__version__ = "0.48.0"

{docsig-0.47.0 → docsig-0.48.0}/pyproject.toml

@@ -72,7 +72,7 @@ maintainers = [
 name = "docsig"
 readme = "README.rst"
 repository = "https://github.com/jshwi/docsig"
-version = "0.47.0"
+version = "0.48.0"
 
 [tool.poetry.dependencies]
 Pygments = "^2.13.0"
@@ -81,7 +81,6 @@ arcon = ">=0.4.0"
 astroid = "^3.0.1"
 object-colors = "^2.1.0"
 python = "^3.8"
-typing-extensions = "^4.8.0"
 
 [tool.poetry.dev-dependencies]
 bump2version = "^1.0.1"

docsig-0.47.0/docsig/_main.py

@@ -1,47 +0,0 @@
-"""
-docsig._main
-============
-
-Contains package entry point.
-"""
-
-from __future__ import annotations as _
-
-from ._config import Parser as _Parser
-from ._core import docsig as _docsig
-from ._hooks import pretty_print_error as _pretty_print_error
-
-
-def main() -> str | int:
-    """Main function for package.
-
-    Collect config and arguments for the commandline.
-
-    :return: Exit status for whether test failed or not.
-    """
-    parser = _Parser()
-    _pretty_print_error()
-    return _docsig(
-        *parser.args.path,
-        string=parser.args.string,
-        list_checks=parser.args.list_checks,
-        check_class=parser.args.check_class,
-        check_class_constructor=parser.args.check_class_constructor,
-        check_dunders=parser.args.check_dunders,
-        check_protected_class_methods=(
-            parser.args.check_protected_class_methods
-        ),
-        check_nested=parser.args.check_nested,
-        check_overridden=parser.args.check_overridden,
-        check_protected=parser.args.check_protected,
-        check_property_returns=parser.args.check_property_returns,
-        ignore_no_params=parser.args.ignore_no_params,
-        ignore_args=parser.args.ignore_args,
-        ignore_kwargs=parser.args.ignore_kwargs,
-        no_ansi=parser.args.no_ansi,
-        summary=parser.args.summary,
-        verbose=parser.args.verbose,
-        targets=parser.args.target,
-        disable=parser.args.disable,
-        exclude=parser.args.exclude,
-    )

docsig-0.47.0/docsig/_report.py

@@ -1,275 +0,0 @@
-"""
-docsig._report
-==============
-"""
-
-from __future__ import annotations as _
-
-import typing as _t
-
-from ._message import Message as _Message
-from ._module import Function as _Function
-from ._stub import RETURN as _RETURN
-from ._stub import Param as _Param
-from ._utils import almost_equal as _almost_equal
-from .messages import TEMPLATE as _TEMPLATE
-from .messages import E as _E
-
-_MIN_MATCH = 0.8
-_MAX_MATCH = 1.0
-
-
-class _MessageSequence(_t.List[str]):
-    def __init__(
-        self,
-        targets: list[_Message],
-        disable: list[_Message],
-    ) -> None:
-        super().__init__()
-        self._disable = list(disable)
-        if targets:
-            errors = list(_E.all(1))
-            for target in targets:
-                errors.remove(target)
-
-            self._disable.extend(errors)
-
-        self._errors: list[_Message] = []
-
-    def add(self, value: _Message, hint: bool = False, **kwargs) -> None:
-        """Add an error to the container.
-
-        :param value: Value to add.
-        :param hint: Whether to print a hint or not.
-        :param kwargs: Variable(s) if format string.
-        """
-        self._errors.append(value)
-        message = value.fstring(_TEMPLATE)
-        if kwargs:
-            message = message.format(**kwargs)
-
-        if hint:
-            message += f"\nhint: {value.hint}"
-
-        if value not in self._disable and message not in self:
-            super().append(message)
-
-
-class Report(_MessageSequence):
-    """Compile and produce report.
-
-    :param func: Function object.
-    :param targets: List of errors to target.
-    :param disable: List of errors to disable.
-    :param check_property_returns: Run return checks on properties.
-    """
-
-    def __init__(
-        self,
-        func: _Function,
-        targets: list[_Message],
-        disable: list[_Message],
-        check_property_returns: bool,
-    ) -> None:
-        super().__init__(targets, disable)
-        self._func = func
-        self._no_prop_return = func.isproperty and not check_property_returns
-        self._no_returns = func.isinit or self._no_prop_return
-
-    def order(self, sig: _Param, doc: _Param) -> None:
-        """Test for documented parameters and their order.
-
-        :param sig: Signature argument.
-        :param doc: Docstring argument.
-        """
-        if any(sig.name == i.name for i in self._func.docstring.args) or any(
-            doc.name == i.name for i in self._func.signature.args
-        ):
-            self.add(_E[101])
-
-    def exists(self) -> None:
-        """Test that non-existing parameter is not documented."""
-        if len(self._func.docstring.args) > len(self._func.signature.args):
-            self.add(_E[102])
-
-    def missing_func_docstring(self) -> None:
-        """Test that docstring is not missing from func."""
-        if not self._func.isinit and self._func.docstring.string is None:
-            self.add(_E[113])
-
-    def missing_class_docstring(self) -> None:
-        """Test that docstring is not missing from class."""
-        if self._func.isinit and self._func.docstring.string is None:
-            self.add(_E[114])
-
-    def missing(self) -> None:
-        """Test that parameter is not missing from documentation."""
-        if len(self._func.signature.args) > len(self._func.docstring.args):
-            self.add(_E[103])
-
-    def duplicates(self) -> None:
-        """Test that there are no duplicate parameters in docstring."""
-        if self._func.docstring.args.duplicated:
-            self.add(_E[106])
-
-    def extra_return(self) -> None:
-        """Check that return is not documented when there is none."""
-        if (
-            self._func.docstring.returns
-            and self._func.signature.rettype == "None"
-            and not self._no_returns
-        ):
-            self.add(_E[104])
-
-    def property_return(self) -> None:
-        """Check that return is not documented for property."""
-        if self._func.docstring.returns and self._no_prop_return:
-            self.add(_E[108], hint=True)
-
-    def return_not_typed(self) -> None:
-        """Check that return is not documented when no type provided."""
-        if self._func.signature.rettype is None and not self._no_returns:
-            self.add(_E[109])
-
-    def missing_return(self) -> None:
-        """Check that return is documented when func returns value."""
-        hint = False
-        if (
-            self._func.signature.returns
-            and not self._func.docstring.returns
-            and not self._no_returns
-        ):
-            docstring = self._func.docstring.string
-            if docstring is not None and _RETURN in docstring:
-                hint = True
-
-            self.add(_E[105], hint=hint)
-
-    def incorrect(self, sig: _Param, doc: _Param) -> None:
-        """Test that proper syntax is used when documenting parameters.
-
-        :param sig: Signature argument.
-        :param doc: Docstring argument.
-        """
-        if sig.name is None and doc.name is None:
-            self.add(_E[107])
-
-    def not_equal(self, sig: _Param, doc: _Param) -> None:
-        """Final catch-all.
-
-        Only applies if no other errors, including disabled, have been
-        triggered
-
-        :param sig: Signature argument.
-        :param doc: Docstring argument.
-        """
-        if sig.name is not None and doc.name is not None and not self._errors:
-            self.add(_E[110])
-
-    def class_return(self) -> None:
-        """Check that return is not documented for __init__."""
-        if self._func.docstring.returns and self._func.isinit:
-            self.add(_E[111], hint=True)
-
-    def misspelled(self, sig: _Param, doc: _Param) -> None:
-        """Test whether there is a spelling error in documentation.
-
-        To avoid false positives also check whether doc param is almost
-        equal amongst its sibling params. If params are too similarly
-        named then this error won't be raised.
-
-        :param sig: Signature argument.
-        :param doc: Docstring argument.
-        """
-        if (
-            sig.name is not None
-            and doc.name is not None
-            and not self._errors
-            and _almost_equal(sig.name, doc.name, _MIN_MATCH, _MAX_MATCH)
-        ):
-            self.add(_E[112])
-
-    def description_syntax(self, doc: _Param) -> None:
-        """Test whether docstring description has correct spacing.
-
-        :param doc: Docstring argument.
-        """
-        if doc.description is not None and not doc.description.startswith(" "):
-            self.add(_E[115])
-
-    def indent_syntax(self, doc: _Param) -> None:
-        """Test whether docstring description is indented correctly.
-
-        :param doc: Docstring argument.
-        """
-        if doc.indent > 0:
-            self.add(_E[116])
-
-    def invalid_directive(self) -> None:
-        """Report on any invalid directives belonging to this func."""
-        for directive in self._func.directives:
-            if not directive.isvalid:
-                err = _E[int(f"20{1 if directive.ismodule else 2}")]
-                self.add(err, directive=directive.kind)
-
-    def invalid_directive_options(self) -> None:
-        """Report on any invalid directive options belonging to this."""
-        for directive in self._func.directives:
-            if directive.rules.unknown:
-                err = _E[int(f"20{3 if directive.ismodule else 4}")]
-                for rule in directive.rules.unknown:
-                    self.add(
-                        err, directive=directive.kind, option=rule.description
-                    )
-
-    def get_report(self, prefix: str = "") -> str:
-        """Get report compiled as a string.
-
-        :param prefix: Prefix report.
-        :return: Current report.
-        """
-        report = f"\n{prefix}".join(self)
-        return f"{report}\n"
-
-
-def generate_report(
-    func: _Function,
-    targets: list[_Message],
-    disable: list[_Message],
-    check_property_returns: bool,
-) -> Report:
-    """Generate report if function or method has failed.
-
-    :param func: Function object.
-    :param targets: List of errors to target.
-    :param disable: List of errors to disable.
-    :param check_property_returns: Run return checks on properties.
-    :return: Compiled report.
-    """
-    report = Report(func, targets, disable, check_property_returns)
-    report.invalid_directive()
-    report.invalid_directive_options()
-    report.missing_class_docstring()
-    report.missing_func_docstring()
-    if func.docstring.string is not None:
-        report.return_not_typed()
-        report.exists()
-        report.missing()
-        report.duplicates()
-        report.extra_return()
-        report.missing_return()
-        report.property_return()
-        report.class_return()
-        for index in range(len(func)):
-            arg = func.signature.args.get(index)
-            doc = func.docstring.args.get(index)
-            report.description_syntax(doc)
-            report.indent_syntax(doc)
-            if arg != doc:
-                report.order(arg, doc)
-                report.incorrect(arg, doc)
-                report.misspelled(arg, doc)
-                report.not_equal(arg, doc)
-
-    report.sort()
-    return report