transformers.py

Go to the documentation of this file.

#  Copyright 2008-2015 Nokia Networks
#  Copyright 2016-     Robot Framework Foundation
#
#  Licensed under the Apache License, Version 2.0 (the "License");
#  you may not use this file except in compliance with the License.
#  You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
#  Unless required by applicable law or agreed to in writing, software
#  distributed under the License is distributed on an "AS IS" BASIS,
#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#  See the License for the specific language governing permissions and
#  limitations under the License.
 
from ast import NodeVisitor
 
from robot.output import LOGGER
from robot.variables import VariableIterator
 
from .settings import Defaults, TestSettings
 
 
class SettingsBuilder(NodeVisitor):
 
    def __init__(self, suite, defaults):
        self.suitesuite = suite
        self.defaultsdefaults = defaults
 
    def visit_Documentation(self, node):
        self.suitesuite.doc = node.value
 
    def visit_Metadata(self, node):
        self.suitesuite.metadata[node.name] = node.value
 
    def visit_SuiteSetup(self, node):
        self.suitesuite.setup.config(name=node.name, args=node.args,
                                lineno=node.lineno)
 
    def visit_SuiteTeardown(self, node):
        self.suitesuite.teardown.config(name=node.name, args=node.args,
                                   lineno=node.lineno)
 
    def visit_TestSetup(self, node):
        self.defaultsdefaults.setup = {
            'name': node.name, 'args': node.args, 'lineno': node.lineno
        }
 
    def visit_TestTeardown(self, node):
        self.defaultsdefaults.teardown = {
            'name': node.name, 'args': node.args, 'lineno': node.lineno
        }
 
    def visit_TestTimeout(self, node):
        self.defaultsdefaults.timeout = node.value
 
    def visit_DefaultTags(self, node):
        self.defaultsdefaults.default_tags = node.values
 
    def visit_ForceTags(self, node):
        self.defaultsdefaults.force_tags = node.values
 
    def visit_KeywordTags(self, node):
        self.defaultsdefaults.keyword_tags = node.values
 
    def visit_TestTemplate(self, node):
        self.defaultsdefaults.template = node.value
 
    def visit_ResourceImport(self, node):
        self.suitesuite.resource.imports.create(type='Resource', name=node.name,
                                           lineno=node.lineno)
 
    def visit_LibraryImport(self, node):
        self.suitesuite.resource.imports.create(type='Library', name=node.name,
                                           args=node.args, alias=node.alias,
                                           lineno=node.lineno)
 
    def visit_VariablesImport(self, node):
        self.suitesuite.resource.imports.create(type='Variables', name=node.name,
                                           args=node.args, lineno=node.lineno)
 
    def visit_VariableSection(self, node):
        pass
 
    def visit_TestCaseSection(self, node):
        pass
 
    def visit_KeywordSection(self, node):
        pass
 
 
class SuiteBuilder(NodeVisitor):
 
    def __init__(self, suite, defaults):
        self.suitesuite = suite
        self.defaultsdefaults = defaults
 
    def visit_SettingSection(self, node):
        pass
 
    def visit_Variable(self, node):
        self.suite.resource.variables.create(name=node.name,
                                             value=node.value,
                                             lineno=node.lineno,
                                             error=format_error(node.errors))
 
    def visit_TestCase(self, node):
        TestCaseBuilder(self.suitesuite, self.defaultsdefaults).visit(node)
 
    def visit_Keyword(self, node):
        KeywordBuilder(self.suitesuite.resource, self.defaultsdefaults).visit(node)
 
 
class ResourceBuilder(NodeVisitor):
 
    def __init__(self, resource):
        self.resourceresource = resource
        self.defaultsdefaults = Defaults()
 
    def visit_Documentation(self, node):
        self.resourceresource.doc = node.value
 
    def visit_KeywordTags(self, node):
        self.defaultsdefaults.keyword_tags = node.values
 
    def visit_LibraryImport(self, node):
        self.resourceresource.imports.create(type='Library', name=node.name,
                                     args=node.args, alias=node.alias,
                                     lineno=node.lineno)
 
    def visit_ResourceImport(self, node):
        self.resourceresource.imports.create(type='Resource', name=node.name,
                                     lineno=node.lineno)
 
    def visit_VariablesImport(self, node):
        self.resourceresource.imports.create(type='Variables', name=node.name,
                                     args=node.args, lineno=node.lineno)
 
    def visit_Variable(self, node):
        self.resourceresource.variables.create(name=node.name,
                                       value=node.value,
                                       lineno=node.lineno,
                                       error=format_error(node.errors))
 
    def visit_Keyword(self, node):
        KeywordBuilder(self.resourceresource, self.defaultsdefaults).visit(node)
 
 
class TestCaseBuilder(NodeVisitor):
 
    def __init__(self, suite, defaults):
        self.suitesuite = suite
        self.settingssettings = TestSettings(defaults)
        self.testtest = None
 
    def visit_TestCase(self, node):
        self.testtest = self.suitesuite.tests.create(name=node.name, lineno=node.lineno)
        self.generic_visit(node)
        self._set_settings_set_settings(self.testtest, self.settingssettings)
 
    def _set_settings(self, test, settings):
        if settings.setup:
            test.setup.config(**settings.setup)
        if settings.teardown:
            test.teardown.config(**settings.teardown)
        if settings.timeout:
            test.timeout = settings.timeout
        if settings.tags:
            test.tags = settings.tags
        if settings.template:
            test.template = settings.template
            self._set_template_set_template(test, settings.template)
 
    def _set_template(self, parent, template):
        for item in parent.body:
            if item.type == item.FOR:
                self._set_template_set_template(item, template)
            elif item.type == item.IF_ELSE_ROOT:
                for branch in item.body:
                    self._set_template_set_template(branch, template)
            elif item.type == item.KEYWORD:
                name, args = self._format_template_format_template(template, item.args)
                item.name = name
                item.args = args
 
    def _format_template(self, template, arguments):
        variables = VariableIterator(template, identifiers='$')
        count = len(variables)
        if count == 0 or count != len(arguments):
            return template, arguments
        temp = []
        for (before, _, after), arg in zip(variables, arguments):
            temp.extend([before, arg])
        temp.append(after)
        return ''.join(temp), ()
 
    def visit_For(self, node):
        ForBuilder(self.testtest).build(node)
 
    def visit_While(self, node):
        WhileBuilder(self.testtest).build(node)
 
    def visit_If(self, node):
        IfBuilder(self.testtest).build(node)
 
    def visit_Try(self, node):
        TryBuilder(self.testtest).build(node)
 
    def visit_TemplateArguments(self, node):
        self.testtest.body.create_keyword(args=node.args, lineno=node.lineno)
 
    def visit_Documentation(self, node):
        self.testtest.doc = node.value
 
    def visit_Setup(self, node):
        self.settingssettings.setup = {
            'name': node.name, 'args': node.args, 'lineno': node.lineno
        }
 
    def visit_Teardown(self, node):
        self.settingssettings.teardown = {
            'name': node.name, 'args': node.args, 'lineno': node.lineno
        }
 
    def visit_Timeout(self, node):
        self.settingssettings.timeout = node.value
 
    def visit_Tags(self, node):
        deprecate_tags_starting_with_hyphen(node, self.suitesuite.source)
        self.settingssettings.tags = node.values
 
    def visit_Template(self, node):
        self.settingssettings.template = node.value
 
    def visit_KeywordCall(self, node):
        self.testtest.body.create_keyword(name=node.keyword, args=node.args,
                                      assign=node.assign, lineno=node.lineno)
 
    def visit_ReturnStatement(self, node):
        self.testtest.body.create_return(node.values, lineno=node.lineno,
                                     error=format_error(node.errors))
 
    def visit_Continue(self, node):
        self.testtest.body.create_continue(lineno=node.lineno,
                                       error=format_error(node.errors))
 
    def visit_Break(self, node):
        self.testtest.body.create_break(lineno=node.lineno,
                                    error=format_error(node.errors))
 
 
class KeywordBuilder(NodeVisitor):
 
    def __init__(self, resource, defaults):
        self.resourceresource = resource
        self.defaultsdefaults = defaults
        self.kwkw = None
 
    def visit_Keyword(self, node):
        self.kwkw = self.resourceresource.keywords.create(name=node.name,
                                                tags=self.defaultsdefaults.keyword_tags,
                                                lineno=node.lineno)
        self.generic_visit(node)
 
    def visit_Documentation(self, node):
        self.kwkw.doc = node.value
 
    def visit_Arguments(self, node):
        self.kwkw.args = node.values
        if node.errors:
            error = format_error(node.errors)
            self.kwkw.error = f'Invalid argument specification: {error}'
 
    def visit_Tags(self, node):
        deprecate_tags_starting_with_hyphen(node, self.resourceresource.source)
        self.kwkw.tags.add(node.values)
 
    def visit_Return(self, node):
        self.kwkw.return_ = node.values
 
    def visit_Timeout(self, node):
        self.kwkw.timeout = node.value
 
    def visit_Teardown(self, node):
        self.kwkw.teardown.config(name=node.name, args=node.args,
                                lineno=node.lineno)
 
    def visit_KeywordCall(self, node):
        self.kwkw.body.create_keyword(name=node.keyword, args=node.args,
                                    assign=node.assign, lineno=node.lineno)
 
    def visit_ReturnStatement(self, node):
        self.kwkw.body.create_return(node.values, lineno=node.lineno,
                                   error=format_error(node.errors))
 
    def visit_Continue(self, node):
        self.kwkw.body.create_continue(lineno=node.lineno,
                                     error=format_error(node.errors))
 
    def visit_Break(self, node):
        self.kwkw.body.create_break(lineno=node.lineno,
                                  error=format_error(node.errors))
 
    def visit_For(self, node):
        ForBuilder(self.kwkw).build(node)
 
    def visit_While(self, node):
        WhileBuilder(self.kwkw).build(node)
 
    def visit_If(self, node):
        IfBuilder(self.kwkw).build(node)
 
    def visit_Try(self, node):
        TryBuilder(self.kwkw).build(node)
 
 
class ForBuilder(NodeVisitor):
 
    def __init__(self, parent):
        self.parentparent = parent
        self.modelmodel = None
 
    def build(self, node):
        error = format_error(self._get_errors_get_errors(node))
        self.modelmodel = self.parentparent.body.create_for(
            node.variables, node.flavor, node.values, lineno=node.lineno, error=error
        )
        for step in node.body:
            self.visit(step)
        return self.modelmodel
 
    def _get_errors(self, node):
        errors = node.header.errors + node.errors
        if node.end:
            errors += node.end.errors
        return errors
 
    def visit_KeywordCall(self, node):
        self.modelmodel.body.create_keyword(name=node.keyword, args=node.args,
                                       assign=node.assign, lineno=node.lineno)
 
    def visit_TemplateArguments(self, node):
        self.modelmodel.body.create_keyword(args=node.args, lineno=node.lineno)
 
    def visit_For(self, node):
        ForBuilder(self.modelmodel).build(node)
 
    def visit_While(self, node):
        WhileBuilder(self.modelmodel).build(node)
 
    def visit_If(self, node):
        IfBuilder(self.modelmodel).build(node)
 
    def visit_Try(self, node):
        TryBuilder(self.modelmodel).build(node)
 
    def visit_ReturnStatement(self, node):
        self.modelmodel.body.create_return(node.values, lineno=node.lineno,
                                      error=format_error(node.errors))
 
    def visit_Continue(self, node):
        self.modelmodel.body.create_continue(lineno=node.lineno,
                                        error=format_error(node.errors))
 
    def visit_Break(self, node):
        self.modelmodel.body.create_break(lineno=node.lineno,
                                     error=format_error(node.errors))
 
 
class IfBuilder(NodeVisitor):
 
    def __init__(self, parent):
        self.parentparent = parent
        self.modelmodel = None
 
    def build(self, node):
        root = self.parentparent.body.create_if(lineno=node.lineno,
                                          error=format_error(self._get_errors_get_errors(node)))
        assign = node.assign
        node_type = None
        while node:
            node_type = node.type if node.type != 'INLINE IF' else 'IF'
            self.modelmodel = root.body.create_branch(node_type, node.condition,
                                                 lineno=node.lineno)
            for step in node.body:
                self.visit(step)
            if assign:
                for item in self.modelmodel.body:
                    # Having assign when model item doesn't support assign is an error,
                    # but it has been handled already when model was validated.
                    if hasattr(item, 'assign'):
                        item.assign = assign
            node = node.orelse
        # Smallish hack to make sure assignment is always run.
        if assign and node_type != 'ELSE':
            root.body.create_branch('ELSE').body.create_keyword(
                assign=assign, name='BuiltIn.Set Variable', args=['${NONE}']
            )
        return root
 
    def _get_errors(self, node):
        errors = node.header.errors + node.errors
        if node.orelse:
            errors += self._get_errors_get_errors(node.orelse)
        if node.end:
            errors += node.end.errors
        return errors
 
    def visit_KeywordCall(self, node):
        self.modelmodel.body.create_keyword(name=node.keyword, args=node.args,
                                       assign=node.assign, lineno=node.lineno)
 
    def visit_TemplateArguments(self, node):
        self.modelmodel.body.create_keyword(args=node.args, lineno=node.lineno)
 
    def visit_For(self, node):
        ForBuilder(self.modelmodel).build(node)
 
    def visit_While(self, node):
        WhileBuilder(self.modelmodel).build(node)
 
    def visit_If(self, node):
        IfBuilder(self.modelmodel).build(node)
 
    def visit_Try(self, node):
        TryBuilder(self.modelmodel).build(node)
 
    def visit_ReturnStatement(self, node):
        self.modelmodel.body.create_return(node.values, lineno=node.lineno,
                                      error=format_error(node.errors))
 
    def visit_Continue(self, node):
        self.modelmodel.body.create_continue(lineno=node.lineno,
                                        error=format_error(node.errors))
 
    def visit_Break(self, node):
        self.modelmodel.body.create_break(lineno=node.lineno,
                                     error=format_error(node.errors))
 
 
class TryBuilder(NodeVisitor):
 
    def __init__(self, parent):
        self.parentparent = parent
        self.modelmodel = None
        self.template_errortemplate_error = None
 
    def build(self, node):
        root = self.parentparent.body.create_try(lineno=node.lineno)
        errors = self._get_errors_get_errors(node)
        while node:
            self.modelmodel = root.body.create_branch(node.type, node.patterns,
                                                 node.pattern_type, node.variable,
                                                 lineno=node.lineno)
            for step in node.body:
                self.visit(step)
            node = node.next
        if self.template_errortemplate_error:
            errors += (self.template_errortemplate_error,)
        if errors:
            root.error = format_error(errors)
        return root
 
    def _get_errors(self, node):
        errors = node.header.errors + node.errors
        if node.next:
            errors += self._get_errors_get_errors(node.next)
        if node.end:
            errors += node.end.errors
        return errors
 
    def visit_For(self, node):
        ForBuilder(self.modelmodel).build(node)
 
    def visit_While(self, node):
        WhileBuilder(self.modelmodel).build(node)
 
    def visit_If(self, node):
        IfBuilder(self.modelmodel).build(node)
 
    def visit_Try(self, node):
        TryBuilder(self.modelmodel).build(node)
 
    def visit_ReturnStatement(self, node):
        self.modelmodel.body.create_return(node.values, lineno=node.lineno,
                                      error=format_error(node.errors))
 
    def visit_Continue(self, node):
        self.modelmodel.body.create_continue(lineno=node.lineno,
                                        error=format_error(node.errors))
 
    def visit_Break(self, node):
        self.modelmodel.body.create_break(lineno=node.lineno,
                                     error=format_error(node.errors))
 
    def visit_KeywordCall(self, node):
        self.modelmodel.body.create_keyword(name=node.keyword, args=node.args,
                                       assign=node.assign, lineno=node.lineno)
 
    def visit_TemplateArguments(self, node):
        self.template_errortemplate_error = 'Templates cannot be used with TRY.'
 
 
class WhileBuilder(NodeVisitor):
 
    def __init__(self, parent):
        self.parentparent = parent
        self.modelmodel = None
 
    def build(self, node):
        error = format_error(self._get_errors_get_errors(node))
        self.modelmodel = self.parentparent.body.create_while(
            node.condition, node.limit, lineno=node.lineno, error=error
        )
        for step in node.body:
            self.visit(step)
        return self.modelmodel
 
    def _get_errors(self, node):
        errors = node.header.errors + node.errors
        if node.end:
            errors += node.end.errors
        return errors
 
    def visit_KeywordCall(self, node):
        self.modelmodel.body.create_keyword(name=node.keyword, args=node.args,
                                       assign=node.assign, lineno=node.lineno)
 
    def visit_TemplateArguments(self, node):
        self.modelmodel.body.create_keyword(args=node.args, lineno=node.lineno)
 
    def visit_For(self, node):
        ForBuilder(self.modelmodel).build(node)
 
    def visit_While(self, node):
        WhileBuilder(self.modelmodel).build(node)
 
    def visit_If(self, node):
        IfBuilder(self.modelmodel).build(node)
 
    def visit_Try(self, node):
        TryBuilder(self.modelmodel).build(node)
 
    def visit_ReturnStatement(self, node):
        self.modelmodel.body.create_return(node.values, lineno=node.lineno,
                                      error=format_error(node.errors))
 
    def visit_Break(self, node):
        self.modelmodel.body.create_break(error=format_error(node.errors))
 
    def visit_Continue(self, node):
        self.modelmodel.body.create_continue(error=format_error(node.errors))
 
 
def format_error(errors):
    if not errors:
        return None
    if len(errors) == 1:
        return errors[0]
    return '\n- '.join(('Multiple errors:',) + errors)
 
 
def deprecate_tags_starting_with_hyphen(node, source):
    for tag in node.values:
        if tag.startswith('-'):
            LOGGER.warn(
                f"Error in file '{source}' on line {node.lineno}: "
                f"Settings tags starting with a hyphen using the '[Tags]' setting "
                f"is deprecated. In Robot Framework 6.1 this syntax will be used "
                f"for removing tags. Escape '{tag}' like '\\{tag}' to use the "
                f"literal value and to avoid this warning."
            )