initial builder implementation (robotframework#65)

Rewrite keyword argument, types and doc building.

Author: aaltat

atest/DynamicTypesLibrary.py

@@ -53,10 +53,6 @@ def keyword_default_types(self, arg=None):
     def keyword_many_default_types(self, arg1=1, arg2='Foobar'):
         return arg1, arg2
 
-    @keyword
-    def keyword_booleans(self, arg1=True, arg2=False):
-        return '%s: %s, %s: %s' % (arg1, type(arg1), arg2, type(arg2))
-
     @keyword
     def keyword_none(self, arg=None):
         return '%s: %s' % (arg, type(arg))
@@ -79,3 +75,7 @@ def keyword_wrapped(self, number=1, arg=''):
     @keyword
     def varargs_and_kwargs(self, *args, **kwargs):
         return '%s, %s' % (args, kwargs)
+
+    @keyword
+    def keyword_booleans(self, arg1=True, arg2=False):
+        return '%s: %s, %s: %s' % (arg1, type(arg1), arg2, type(arg2))

atest/moc_library.py

@@ -0,0 +1,29 @@
+from robot.api.deco import keyword
+
+
+class MockLibrary(object):
+
+    def no_args(self):
+        pass
+
+    @keyword(types={'arg1': str, 'arg2': int})
+    def positional_args(self, arg1, arg2):
+        """Some documentation
+
+        Multi line docs
+        """
+        pass
+
+    @keyword(types=None)
+    def types_disabled(self, arg=False):
+        pass
+
+    @keyword
+    def positional_and_default(self, arg1, arg2, named1='string1', named2=123):
+        pass
+
+    def default_only(self, named1='string1', named2=123):
+        pass
+
+    def varargs_kwargs(self, *vargs, **kwargs):
+        pass

atest/moc_library_py3.py

@@ -0,0 +1,13 @@
+class MockLibraryPy3:
+
+    def named_only(self, *varargs, key1, key2):
+        pass
+
+    def named_only_with_defaults(self, *varargs, key1, key2, key3='default1', key4=True):
+        pass
+
+    def args_with_type_hints(self, arg1, arg2, arg3: str, arg4: None) -> bool:
+        pass
+
+    def self_and_keyword_only_types(x: 'MockLibraryPy3', mandatory, *varargs: int, other: bool, **kwargs: int):
+        pass

atest/tests_types.robot

@@ -19,10 +19,6 @@ Keyword Default As Booleans With Defaults
     ${return}    DynamicTypesLibrary.Keyword Booleans
     Should Match Regexp    ${return}    True: <(class|type) 'bool'>, False: <(class|type) 'bool'>
 
-Keyword Default As Booleans With Strings
-    ${return} =    DynamicTypesLibrary.Keyword Booleans    False    True
-    Should Match Regexp    ${return}    False: <(class|type) 'bool'>, True: <(class|type) 'bool'>
-
 Keyword Default As Booleans With Objects
     ${return} =    DynamicTypesLibrary.Keyword Booleans    ${False}    ${True}
     Should Match Regexp    ${return}    False: <(class|type) 'bool'>, True: <(class|type) 'bool'>

src/robotlibcore.py

@@ -41,17 +41,20 @@ class HybridCore(object):
 
     def __init__(self, library_components):
         self.keywords = {}
+        self.keywords_spec = {}
         self.attributes = {}
         self.add_library_components(library_components)
         self.add_library_components([self])
 
     def add_library_components(self, library_components):
+        self.keywords_spec['__init__'] = KeywordBuilder.build(self.__init__)
         for component in library_components:
             for name, func in self.__get_members(component):
                 if callable(func) and hasattr(func, 'robot_name'):
                     kw = getattr(component, name)
                     kw_name = func.robot_name or name
                     self.keywords[kw_name] = kw
+                    self.keywords_spec[kw_name] = KeywordBuilder.build(kw)
                     # Expose keywords as attributes both using original
                     # method names as well as possible custom names.
                     self.attributes[name] = self.attributes[kw_name] = kw
@@ -98,37 +101,23 @@ def run_keyword(self, name, args, kwargs=None):
         return self.keywords[name](*args, **(kwargs or {}))
 
     def get_keyword_arguments(self, name):
-        kw_method = self.__get_keyword(name)
-        if kw_method is None:
-            return None
-        spec = ArgumentSpec.from_function(kw_method)
-        return spec.get_arguments()
+        spec = self.keywords_spec.get(name)
+        return spec.argument_specification
 
     def get_keyword_tags(self, name):
         return self.keywords[name].robot_tags
 
     def get_keyword_documentation(self, name):
         if name == '__intro__':
             return inspect.getdoc(self) or ''
-        if name == '__init__':
-            return inspect.getdoc(self.__init__) or ''
-        kw = self.keywords[name]
-        return inspect.getdoc(kw) or ''
+        spec = self.keywords_spec.get(name)
+        return spec.documentation
 
-    def get_keyword_types(self, keyword_name):
-        method = self.__get_keyword(keyword_name)
-        if method is None:
-            return method
-        types = getattr(method, 'robot_types', ())
-        if types is None:
-            return types
-        if not types:
-            types = self.__get_typing_hints(method)
-        if RF31:
-            types = self.__join_defaults_with_types(method, types)
-        else:
-            types.pop('return', None)
-        return types
+    def get_keyword_types(self, name):
+        spec = self.keywords_spec.get(name)
+        if spec is None:
+            raise ValueError('Keyword "%s" not found.' % name)
+        return spec.argument_types
 
     def __get_keyword(self, keyword_name):
         if keyword_name == '__init__':
@@ -140,22 +129,6 @@ def __get_keyword(self, keyword_name):
             raise ValueError('Keyword "%s" not found.' % keyword_name)
         return method
 
-    def __get_typing_hints(self, method):
-        if PY2:
-            return {}
-        spec = ArgumentSpec.from_function(method)
-        return spec.get_typing_hints()
-
-    def __join_defaults_with_types(self, method, types):
-        spec = ArgumentSpec.from_function(method)
-        for name, value in spec.defaults:
-            if name not in types and isinstance(value, (bool, type(None))):
-                types[name] = type(value)
-        for name, value in spec.kwonlydefaults:
-            if name not in types and isinstance(value, (bool, type(None))):
-                types[name] = type(value)
-        return types
-
     def get_keyword_source(self, keyword_name):
         method = self.__get_keyword(keyword_name)
         path = self.__get_keyword_path(method)
@@ -185,91 +158,128 @@ def __get_keyword_path(self, method):
             return None
 
 
-class ArgumentSpec(object):
-
-    _function = None
-
-    def __init__(self, positional=None, defaults=None, varargs=None, kwonlyargs=None,
-                 kwonlydefaults=None, kwargs=None):
-        self.positional = positional or []
-        self.defaults = defaults or []
-        self.varargs = varargs
-        self.kwonlyargs = kwonlyargs or []
-        self.kwonlydefaults = kwonlydefaults or []
-        self.kwargs = kwargs
-
-    def __contains__(self, item):
-        if item in self.positional:
-            return True
-        if self.varargs and item in self.varargs:
-            return True
-        if item in self.kwonlyargs:
-            return True
-        if self.kwargs and item in self.kwargs:
-            return True
-        return False
-
-    def get_arguments(self):
-        args = self._format_positional(self.positional, self.defaults)
-        args += self._format_default(self.defaults)
-        if self.varargs:
-            args.append('*%s' % self.varargs)
-        args += self._format_positional(self.kwonlyargs, self.kwonlydefaults)
-        args += self._format_default(self.kwonlydefaults)
-        if self.kwargs:
-            args.append('**%s' % self.kwargs)
-        return args
-
-    def get_typing_hints(self):
-        try:
-            hints = typing.get_type_hints(self._function)
-        except Exception:
-            hints = self._function.__annotations__
-        for arg in list(hints):
-            # remove return and self statements
-            if arg not in self:
-                hints.pop(arg)
-        return hints
+class KeywordBuilder(object):
 
-    def _format_positional(self, positional, defaults):
-        for argument, _ in defaults:
-            positional.remove(argument)
-        return positional
+    @classmethod
+    def build(cls, function):
+        return KeywordSpecification(
+            argument_specification=cls._get_arguments(function),
+            documentation=inspect.getdoc(function) or '',
+            argument_types=cls._get_types(function)
+        )
 
-    def _format_default(self, defaults):
-        if not RF31:
-            return [default for default in defaults]
-        return ['%s=%s' % (argument, default) for argument, default in defaults]
+    @classmethod
+    def _get_arguments(cls, function):
+        arg_spec = cls._get_arg_spec(function)
+        argument_specification = cls._get_default_and_named_args(
+            arg_spec, function
+        )
+        argument_specification.extend(cls._get_var_args(arg_spec))
+        kw_only_args = cls._get_kw_only(arg_spec)
+        if kw_only_args:
+            argument_specification.extend(kw_only_args)
+        argument_specification.extend(cls._get_kwargs(arg_spec))
+        return argument_specification
 
     @classmethod
-    def from_function(cls, function):
-        cls._function = function
+    def _get_arg_spec(cls, function):
         if PY2:
-            spec = inspect.getargspec(function)
-        else:
-            spec = inspect.getfullargspec(function)
-        args = spec.args[1:] if inspect.ismethod(function) else spec.args  # drop self
-        defaults = cls._get_defaults(spec)
-        kwonlyargs, kwonlydefaults, kwargs = cls._get_kw_args(spec)
-        return cls(positional=args,
-                   defaults=defaults,
-                   varargs=spec.varargs,
-                   kwonlyargs=kwonlyargs,
-                   kwonlydefaults=kwonlydefaults,
-                   kwargs=kwargs)
+            return inspect.getargspec(function)
+        return inspect.getfullargspec(function)
+
+    @classmethod
+    def _get_default_and_named_args(cls, arg_spec, function):
+        args = cls._drop_self_from_args(function, arg_spec)
+        args.reverse()
+        defaults = list(arg_spec.defaults) if arg_spec.defaults else []
+        formated_args = []
+        for arg in args:
+            if defaults:
+                formated_args.append(
+                    cls._format_defaults(arg, defaults.pop())
+                )
+            else:
+                formated_args.append(arg)
+        formated_args.reverse()
+        return formated_args
+
+    @classmethod
+    def _drop_self_from_args(cls, function, arg_spec):
+        return arg_spec.args[1:] if inspect.ismethod(function) else arg_spec.args
 
     @classmethod
-    def _get_defaults(cls, spec):
-        if not spec.defaults:
-            return []
-        names = spec.args[-len(spec.defaults):]
-        return list(zip(names, spec.defaults))
+    def _get_var_args(cls, arg_spec):
+        if arg_spec.varargs:
+            return ['*%s' % arg_spec.varargs]
+        return []
 
     @classmethod
-    def _get_kw_args(cls, spec):
+    def _get_kwargs(cls, arg_spec):
         if PY2:
-            return [], [], spec.keywords
-        kwonlyargs = spec.kwonlyargs or []
-        defaults = spec.kwonlydefaults or {}
-        kwonlydefaults = [(arg, name) for arg, name in defaults.items()]
-        return kwonlyargs, kwonlydefaults, spec.varkw
+            return ['**%s' % arg_spec.keywords] if arg_spec.keywords else []
+        return ['**%s' % arg_spec.varkw] if arg_spec.varkw else []
+
+    @classmethod
+    def _get_kw_only(cls, arg_spec):
+        kw_only_args = []
+        if PY2:
+            return kw_only_args
+        for arg in arg_spec.kwonlyargs:
+            if not arg_spec.kwonlydefaults or arg not in arg_spec.kwonlydefaults:
+                kw_only_args.append(arg)
+            else:
+                value = arg_spec.kwonlydefaults.get(arg, '')
+                kw_only_args.append(cls._format_defaults(arg, value))
+        return kw_only_args
+
+    @classmethod
+    def _format_defaults(cls, arg, value):
+        if RF31:
+            return '%s=%s' % (arg, value)
+        return arg, value
+
+    @classmethod
+    def _get_types(cls, function):
+        if function is None:
+            return function
+        types = getattr(function, 'robot_types', ())
+        if types is None or types:
+            return types
+        if not types:
+            types = cls._get_typing_hints(function)
+        return types
+
+    @classmethod
+    def _get_typing_hints(cls, function):
+        if PY2:
+            return {}
+        try:
+            hints = typing.get_type_hints(function)
+        except Exception:
+            hints = function.__annotations__
+        all_args = cls._args_as_list(function)
+        for arg_with_hint in list(hints):
+            # remove return and self statements
+            if arg_with_hint not in all_args:
+                hints.pop(arg_with_hint)
+        return hints
+
+    @classmethod
+    def _args_as_list(cls, function):
+        arg_spec = cls._get_arg_spec(function)
+        function_args = []
+        function_args.extend(cls._drop_self_from_args(function, arg_spec))
+        if arg_spec.varargs:
+            function_args.append(arg_spec.varargs)
+        function_args.extend(arg_spec.kwonlyargs or [])
+        if arg_spec.varkw:
+            function_args.append(arg_spec.varkw)
+        return function_args
+
+
+class KeywordSpecification(object):
+
+    def __init__(self, argument_specification=None, documentation=None, argument_types=None):
+        self.argument_specification = argument_specification
+        self.documentation = documentation
+        self.argument_types = argument_types

utest/test_get_keyword_source.py

@@ -52,7 +52,7 @@ def test_location_in_class(lib, lib_path_components):
 @pytest.mark.skipif(PY2, reason='Only applicable on Python 3')
 def test_decorator_wrapper(lib_types, lib_path_types):
     source = lib_types.get_keyword_source('keyword_wrapped')
-    assert source == '%s:76' % lib_path_types
+    assert source == '%s:72' % lib_path_types
 
 
 def test_location_in_class_custom_keyword_name(lib, lib_path_components):
@@ -81,7 +81,7 @@ def test_no_path_and_no_line_number(lib, when):
 
 def test_def_in_decorator(lib_types, lib_path_types):
     source = lib_types.get_keyword_source('keyword_with_def_deco')
-    assert source == '%s:70' % lib_path_types
+    assert source == '%s:66' % lib_path_types
 
 
 def test_error_in_getfile(lib, when):