Initial version

Author: pekkaklarck

atest/DynamicLibrary.py

@@ -0,0 +1,17 @@
+from robotlibcore import DynamicCore
+
+import librarycomponents
+
+
+class DynamicLibrary(DynamicCore):
+    """General library documentation."""
+    class_attribute = 'not keyword'
+
+    def __init__(self, arg=None):
+        """Library init doc."""
+        components = [librarycomponents,
+                      librarycomponents.Names(),
+                      librarycomponents.Arguments(),
+                      librarycomponents.DocsAndTags()]
+        DynamicCore.__init__(self, components)
+        self.instance_attribute = 'not keyword'

atest/HybridLibrary.py

@@ -0,0 +1,16 @@
+from robotlibcore import HybridCore
+
+import librarycomponents
+
+
+class HybridLibrary(HybridCore):
+    """General library documentation."""
+    class_attribute = 'not keyword'
+
+    def __init__(self):
+        components = [librarycomponents,
+                      librarycomponents.Names(),
+                      librarycomponents.Arguments(),
+                      librarycomponents.DocsAndTags()]
+        HybridCore.__init__(self, components)
+        self.instance_attribute = 'not keyword'

atest/librarycomponents.py

@@ -0,0 +1,76 @@
+from __future__ import print_function
+
+from robotlibcore import keyword
+
+
+@keyword
+def function():
+    return 1
+
+
+class Names(object):
+    attribute = 'not keyword'
+
+    @keyword
+    def method(self):
+        return 2
+
+    @keyword('Custom name')
+    def _whatever(self):
+        return 3
+
+    def not_keyword(self):
+        pass
+
+
+class Arguments(object):
+
+    @keyword
+    def mandatory(self, arg1, arg2):
+        return self.format_args(arg1, arg2)
+
+    @keyword
+    def defaults(self, arg1, arg2='default', arg3=3):
+        return self.format_args(arg1, arg2, arg3)
+
+    @keyword
+    def varargs_and_kwargs(self, *args, **kws):
+        return self.format_args(*args, **kws)
+
+    @keyword
+    def all_arguments(self, mandatory, default='value', *varargs, **kwargs):
+        return self.format_args(mandatory, default, *varargs, **kwargs)
+
+    @keyword('Embedded arguments "${here}"')
+    def embedded(self, arg):
+        assert arg == 'work', arg
+
+    def format_args(self, *args, **kwargs):
+        def ru(item):
+            return repr(item).lstrip('u')
+        args = [ru(a) for a in args]
+        kwargs = ['%s=%s' % (k, ru(kwargs[k])) for k in sorted(kwargs)]
+        return ', '.join(args + kwargs)
+
+
+class DocsAndTags(object):
+
+    @keyword
+    def one_line_doc(self):
+        """I got doc!"""
+
+    @keyword
+    def multi_line_doc(self):
+        """I got doc!
+
+        With multiple lines!!
+        Yeah!!!!
+        """
+
+    @keyword(tags=['tag', 'another tag'])
+    def tags(self):
+        pass
+
+    @keyword(tags=['tag'])
+    def doc_and_tags(self):
+        """I got doc!"""

atest/run.py

@@ -0,0 +1,29 @@
+#!/usr/bin/env python
+
+from __future__ import print_function
+from os.path import abspath, dirname, join
+import sys
+
+from robot import run, rebot
+from robotstatuschecker import process_output
+
+
+curdir = dirname(abspath(__file__))
+outdir = join(curdir, 'results')
+tests = join(curdir, 'tests.robot')
+sys.path.insert(0, join(curdir, '..', 'src'))
+for variant in ['Hybrid', 'Dynamic']:
+    output = join(outdir, variant + '.xml')
+    rc = run(tests, name=variant, variable='LIBRARY:%sLibrary' % variant,
+             output=output, report=None, log=None)
+    if rc > 250:
+        sys.exit(rc)
+    process_output(output, verbose=False)
+print('\nCombining results.')
+rc = rebot(join(outdir, 'Hybrid.xml'), join(outdir, 'Dynamic.xml'),
+           name='Acceptance Tests', outputdir=outdir)
+if rc == 0:
+    print('\nAll tests passed/failed as expected.')
+else:
+    print('\n%d test%s failed.' % (rc, 's' if rc != 1 else ''))
+sys.exit(rc)

atest/tests.robot

@@ -0,0 +1,48 @@
+*** Settings ***
+Library        ${LIBRARY}.py
+
+*** Variables ***
+${LIBRARY}    DynamicLibrary
+
+*** Test Cases ***
+Keyword names
+    Function
+    FUNCTION
+    Method
+    Custom name
+    Cust omna me
+
+Method without @keyword are not keyowrds
+    [Documentation]    FAIL    No keyword with name 'Not keyword' found.
+    Not keyword
+
+Arguments
+    [Template]    Return value should be
+    'foo', 'bar'           Mandatory    foo    bar
+    'foo', 'default', 3    Defaults     foo
+    'foo', 2, 3            Defaults     foo    ${2}
+    'a', 'b', 'c'          Defaults     a    b    c
+
+Named arguments
+    [Template]    Return value should be
+    'foo', 'bar'           Mandatory    foo    arg2=bar
+    '1', 2                 Mandatory    arg2=${2}    arg1=1
+    'x', 'default', 'y'    Defaults     x    arg3=y
+
+Varargs and kwargs
+    [Template]    Return value should be
+    ${EMPTY}               Varargs and kwargs
+    'a', 'b', 'c'          Varargs and kwargs    a    b    c
+    a\='1', b\=2           Varargs and kwargs    a=1    b=${2}
+    'a', 'b\=b', c\='c'    Varargs and kwargs    a    b\=b    c=c
+
+Embedded arguments
+    [Documentation]    FAIL    Work but this fails
+    Embedded arguments "work"
+    embeDded ArgumeNtS "Work but this fails"
+
+*** Keywords ***
+Return value should be
+    [Arguments]    ${expected}    ${keyword}    @{args}    &{kwargs}
+    ${result} =    Run Keyword    ${keyword}    @{args}    &{kwargs}
+    Should Be Equal    ${result}    ${expected}

requirements-dev.txt

@@ -0,0 +1,2 @@
+pytest
+robotstatuschecker

src/robotlibcore.py

@@ -0,0 +1,92 @@
+import inspect
+import sys
+
+try:
+    from robot.api.deco import keyword
+except ImportError:  # Support RF < 2.9
+    def keyword(name=None, tags=()):
+        if callable(name):
+            return keyword()(name)
+        def decorator(func):
+            func.robot_name = name
+            func.robot_tags = tags
+            return func
+        return decorator
+
+
+PY2 = sys.version_info < (3,)
+
+
+class HybridCore(object):
+
+    def __init__(self, libraries):
+        self.keywords = dict(self._find_keywords(libraries))
+
+    def _find_keywords(self, libraries):
+        for library in libraries:
+            for name, func in self._get_members(library):
+                if callable(func) and hasattr(func, 'robot_name'):
+                    kw_name = func.robot_name or name
+                    yield kw_name, getattr(library, name)
+
+    def _get_members(self, library):
+        # Avoid calling properties by getting members from class, not instance.
+        if inspect.isclass(library):
+            library = type(library)
+        return inspect.getmembers(library)
+
+    def __getattr__(self, name):
+        if name in self.keywords:
+            return self.keywords[name]
+        raise AttributeError('{!r} object has no attribute {!r}'
+                             .format(type(self).__name__, name))
+
+    def __dir__(self):
+        if PY2:
+            my_attrs = dir(type(self)) + list(self.__dict__)
+        else:
+            my_attrs = super().__dir__()
+        return sorted(set(my_attrs + list(self.keywords)))
+
+    def get_keyword_names(self):
+        return sorted(self.keywords)
+
+
+class DynamicCore(HybridCore):
+
+    def run_keyword(self, name, args, kwargs):
+        return self.keywords[name](*args, **kwargs)
+
+    def get_keyword_arguments(self, name):
+        kw = self.keywords[name] if name != '__init__' else self.__init__
+        args, defaults, varargs, kwargs = self._get_arg_spec(kw)
+        args += ['{}={}'.format(name, value) for name, value in defaults]
+        if varargs:
+            args.append('*{}'.format(varargs))
+        if kwargs:
+            args.append('**{}'.format(kwargs))
+        return args
+
+    def _get_arg_spec(self, kw):
+        spec = inspect.getargspec(kw)
+        args = spec.args[1:] if inspect.ismethod(kw) else spec.args  # drop self
+        defaults = spec.defaults or ()
+        nargs = len(args) - len(defaults)
+        mandatory = args[:nargs]
+        defaults = zip(args[nargs:], defaults)
+        return mandatory, defaults, spec.varargs, spec.keywords
+
+    def get_keyword_documentation(self, name):
+        doc, tags = self._get_doc_and_tags(name)
+        doc = doc or ''
+        tags = 'Tags: {}'.format(', '.join(tags)) if tags else ''
+        sep = '\n\n' if doc and tags else ''
+        return doc + sep + tags
+
+    def _get_doc_and_tags(self, name):
+        if name == '__intro__':
+            return inspect.getdoc(self), None
+        if name == '__init__':
+            return inspect.getdoc(self.__init__), None
+        kw = self.keywords[name]
+        return inspect.getdoc(kw), kw.robot_tags

utest/run.py

@@ -0,0 +1,13 @@
+#!/usr/bin/env python
+
+from os.path import abspath, dirname, join
+import sys
+
+import pytest
+
+
+curdir = dirname(abspath(__file__))
+sys.path.insert(0, join(curdir, '..', 'src'))
+sys.path.insert(0, join(curdir, '..', 'atest'))
+rc = pytest.main(sys.argv[1:] + ['-p', 'no:cacheprovider', curdir])
+sys.exit(rc)

utest/test_robotlibcore.py

@@ -0,0 +1,86 @@
+import pytest
+
+from HybridLibrary import HybridLibrary
+from DynamicLibrary import DynamicLibrary
+
+
+def test_keyword_names():
+    expected = ['Custom name',
+                'Embedded arguments "${here}"',
+                'all_arguments',
+                'defaults',
+                'doc_and_tags',
+                'function',
+                'mandatory',
+                'method',
+                'multi_line_doc',
+                'one_line_doc',
+                'tags',
+                'varargs_and_kwargs']
+    assert HybridLibrary().get_keyword_names() == expected
+    assert DynamicLibrary().get_keyword_names() == expected
+
+
+def test_dir():
+    expected = ['Custom name',
+                'Embedded arguments "${here}"',
+                'all_arguments',
+                'class_attribute',
+                'defaults',
+                'doc_and_tags',
+                'function',
+                'get_keyword_arguments',
+                'get_keyword_documentation',
+                'get_keyword_names',
+                'instance_attribute',
+                'keywords',
+                'mandatory',
+                'method',
+                'multi_line_doc',
+                'one_line_doc',
+                'run_keyword',
+                'tags',
+                'varargs_and_kwargs']
+    assert [a for a in dir(DynamicLibrary()) if a[0] != '_'] == expected
+    expected = [e for e in expected if e not in ('get_keyword_arguments',
+                                                 'get_keyword_documentation',
+                                                 'run_keyword')]
+    assert [a for a in dir(HybridLibrary()) if a[0] != '_'] == expected
+
+
+def test_getattr():
+    for lib in [HybridLibrary(), DynamicLibrary()]:
+        assert lib.class_attribute == 'not keyword'
+        assert lib.instance_attribute == 'not keyword'
+        assert lib.function() == 1
+        assert lib.method() == 2
+        assert getattr(lib, 'Custom name')() == 3
+        with pytest.raises(AttributeError) as excinfo:
+            lib.attribute
+        assert str(excinfo.value) == \
+            "'%s' object has no attribute 'attribute'" % type(lib).__name__
+
+
+def test_get_keyword_arguments():
+    args = DynamicLibrary().get_keyword_arguments
+    assert args('mandatory') == ['arg1', 'arg2']
+    assert args('defaults') == ['arg1', 'arg2=default', 'arg3=3']
+    assert args('varargs_and_kwargs') == ['*args', '**kws']
+    assert args('all_arguments') == ['mandatory', 'default=value', '*varargs', '**kwargs']
+    assert args('__init__') == ['arg=None']
+
+
+def test_get_keyword_documentation():
+    doc = DynamicLibrary().get_keyword_documentation
+    assert doc('function') == ''
+    assert doc('method') == ''
+    assert doc('one_line_doc') == 'I got doc!'
+    assert doc('multi_line_doc') == 'I got doc!\n\nWith multiple lines!!\nYeah!!!!'
+    assert doc('__intro__') == 'General library documentation.'
+    assert doc('__init__') == 'Library init doc.'
+
+
+def test_tags():
+    doc = DynamicLibrary().get_keyword_documentation
+    assert doc('tags') == 'Tags: tag, another tag'
+    assert doc('doc_and_tags') == 'I got doc!\n\nTags: tag'