#129 - Parse function parameters

Author: shacharoo

src/pydocstyle.py

@@ -18,6 +18,7 @@
 from re import compile as re
 import itertools
 from collections import defaultdict, namedtuple, Set
+from functools import partial
 
 try:  # Python 3.x
     from ConfigParser import RawConfigParser
@@ -119,6 +120,7 @@ class Definition(Value):
     all = property(lambda self: self.module.all)
     _slice = property(lambda self: slice(self.start - 1, self.end))
     is_class = False
+    is_function = False
 
     def __iter__(self):
         return chain([self], *self.children)
@@ -161,6 +163,9 @@ class Package(Module):
 
 class Function(Definition):
 
+    is_function = True
+    _fields = ('name', '_source', 'start', 'end', 'decorators', 'docstring',
+               'children', 'parent', 'parameters')
     _nest = staticmethod(lambda s: {'def': NestedFunction,
                                     'class': NestedClass}[s])
 
@@ -448,6 +453,8 @@ def parse_definition(self, class_):
         self.stream.move()
         if self.current.kind == tk.OP and self.current.value == '(':
             parenthesis_level = 0
+            arguments = []
+            is_default_assignment = False
             while True:
                 if self.current.kind == tk.OP:
                     if self.current.value == '(':
@@ -456,6 +463,14 @@ def parse_definition(self, class_):
                         parenthesis_level -= 1
                         if parenthesis_level == 0:
                             break
+                    elif self.current.value == '=':
+                        is_default_assignment = True
+                elif self.current.kind == tk.NAME:
+                    if is_default_assignment:
+                        is_default_assignment = False
+                    else:
+                        arguments.append(self.current.value)
+
                 self.stream.move()
         if self.current.kind != tk.OP or self.current.value != ':':
             self.leapfrog(tk.OP, value=":")
@@ -477,8 +492,11 @@ def parse_definition(self, class_):
             children = []
             end = self.line
             self.leapfrog(tk.NEWLINE)
-        definition = class_(name, self.source, start, end,
-                            decorators, docstring, children, None)
+
+        creator = partial(class_, name, self.source, start, end,
+                          decorators, docstring, children, None)
+
+        definition = creator(arguments) if class_.is_function else creator()
         for child in definition.children:
             child.parent = definition
         log.debug("finished parsing %s '%s'. Next token is %r (%s)",

src/tests/test_definitions.py

@@ -24,7 +24,8 @@ class class_(object):
     """Class."""
     def method_1(self):
         """Method."""
-    def method_2(self):
+    def method_2(self,
+                 param=None):
         def nested_3(self):
             """Nested."""
 '''
@@ -142,25 +143,26 @@ def test_parser():
 
     function, class_ = module.children
     assert Function('function', _, _, _, _, '"Function."', _,
-                    module) == function
+                    module, []) == function
     assert Class('class_', _, _, _, _, '"""Class."""', _, module) == class_
 
     nested_1, nested_2 = function.children
     assert NestedFunction('nested_1', _, _, _, _,
-                          '"""Nested."""', _, function) == nested_1
+                          '"""Nested."""', _, function, []) == nested_1
     assert NestedFunction('nested_2', _, _, _, _, None, _,
-                          function) == nested_2
+                          function, []) == nested_2
     assert nested_1.is_public is False
 
     method_1, method_2 = class_.children
     assert method_1.parent == method_2.parent == class_
     assert Method('method_1', _, _, _, _, '"""Method."""', _,
-                  class_) == method_1
-    assert Method('method_2', _, _, _, _, None, _, class_) == method_2
+                  class_, ['self']) == method_1
+    assert Method('method_2', _, _, _, _, None, _,
+                  class_, ['self', 'param']) == method_2
 
     nested_3, = method_2.children
     assert NestedFunction('nested_3', _, _, _, _,
-                          '"""Nested."""', _, method_2) == nested_3
+                          '"""Nested."""', _, method_2, ['self']) == nested_3
     assert nested_3.module == module
     assert nested_3.all == dunder_all