blocks.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.
 
import ast
 
from robot.utils import file_writer, is_pathlike, is_string
 
from .statements import Comment, EmptyLine
from .visitor import ModelVisitor
from ..lexer import Token
 
 
class Block(ast.AST):
    
    _fields = ()
    
    _attributes = ('lineno', 'col_offset', 'end_lineno', 'end_col_offset', 'errors')
    errors = ()
 
    @property
    lineno = property
    
    def lineno(self):
        statement = FirstStatementFinder.find_from(self)
        return statement.lineno if statement else -1
 
    @property
    col_offset = property
    
    def col_offset(self):
        statement = FirstStatementFinder.find_from(self)
        return statement.col_offset if statement else -1
 
    @property
    end_lineno = property
    
    def end_lineno(self):
        statement = LastStatementFinder.find_from(self)
        return statement.end_lineno if statement else -1
 
    @property
    end_col_offset = property
    
    def end_col_offset(self):
        statement = LastStatementFinder.find_from(self)
        return statement.end_col_offset if statement else -1
 
    def validate_model(self):
        ModelValidator().visit(self)
 
    def validate(self, context):
        pass
 
    def _body_is_empty(self):
        for node in self.body:
            if not isinstance(node, (EmptyLine, Comment)):
                return False
        return True
 
 
class HeaderAndBody(Block):
    
    _fields = ('header', 'body')
 
    def __init__(self, header, body=None, errors=()):
        self.headerheader = header
        self.bodybody = body or []
        self.errorserrorserrors = errors
 
 
class File(Block):
    
    _fields = ('sections',)
    
    _attributes = ('source', 'languages') + Block._attributes
 
    def __init__(self, sections=None, source=None, languages=()):
        self.sectionssections = sections or []
        self.sourcesource = source
        self.languageslanguages = languages
 
    
    def save(self, output=None):
        output = output or self.sourcesource
        if output is None:
            raise TypeError('Saving model requires explicit output '
                            'when original source is not path.')
        ModelWriter(output).write(self)
 
 
class Section(Block):
    
    _fields = ('header', 'body')
 
    def __init__(self, header=None, body=None):
        self.headerheader = header
        self.bodybody = body or []
 
 
class SettingSection(Section):
    pass
 
 
class VariableSection(Section):
    pass
 
 
# FIXME: should there be a separate TaskSection?
class TestCaseSection(Section):
 
    @property
    tasks = property
    
    def tasks(self):
        return self.headerheader.type == Token.TASK_HEADER
 
 
class KeywordSection(Section):
    pass
 
 
class CommentSection(Section):
    pass
 
 
class TestCase(Block):
    
    _fields = ('header', 'body')
 
    def __init__(self, header, body=None):
        self.headerheader = header
        self.bodybody = body or []
 
    @property
    name = property
    
    def name(self):
        return self.headerheader.name
 
 
class Keyword(Block):
    
    _fields = ('header', 'body')
 
    def __init__(self, header, body=None):
        self.headerheader = header
        self.bodybody = body or []
 
    @property
    name = property
    
    def name(self):
        return self.headerheader.name
 
 
 
class If(Block):
    
    _fields = ('header', 'body', 'orelse', 'end')
 
    def __init__(self, header, body=None, orelse=None, end=None, errors=()):
        self.headerheader = header
        self.bodybody = body or []
        self.orelseorelse = orelse
        self.endend = end
        self.errorserrorserrors = errors
 
    @property
    type = property
    
    def type(self):
        return self.headerheader.type
 
    @property
    condition = property
    
    def condition(self):
        return self.headerheader.condition
 
    @property
    assign = property
    
    def assign(self):
        return self.headerheader.assign
 
    def validate(self, context):
        self._validate_body_validate_body()
        if self.typetypetype == Token.IF:
            self._validate_structure_validate_structure()
            self._validate_end_validate_end()
        if self.typetypetype == Token.INLINE_IF:
            self._validate_structure_validate_structure()
            self._validate_inline_if_validate_inline_if()
 
    def _validate_body(self):
        if self._body_is_empty_body_is_empty():
            type = self.typetypetype if self.typetypetype != Token.INLINE_IF else 'IF'
            self.errorserrorserrors += (f'{type} branch cannot be empty.',)
 
    def _validate_structure(self):
        orelse = self.orelseorelse
        else_seen = False
        while orelse:
            if else_seen:
                if orelse.type == Token.ELSE:
                    error = 'Only one ELSE allowed.'
                else:
                    error = 'ELSE IF not allowed after ELSE.'
                if error not in self.errorserrorserrors:
                    self.errorserrorserrors += (error,)
            else_seen = else_seen or orelse.type == Token.ELSE
            orelse = orelse.orelse
 
    def _validate_end(self):
        if not self.endend:
            self.errorserrorserrors += ('IF must have closing END.',)
 
    def _validate_inline_if(self):
        branch = self
        assign = branch.assign
        while branch:
            if branch.body:
                item = branch.body[0]
                if assign and item.type != Token.KEYWORD:
                    self.errorserrorserrors += ('Inline IF with assignment can only contain '
                                    'keyword calls.',)
                if getattr(item, 'assign', None):
                    self.errorserrorserrors += ('Inline IF branches cannot contain assignments.',)
                if item.type == Token.INLINE_IF:
                    self.errorserrorserrors += ('Inline IF cannot be nested.',)
            branch = branch.orelse
 
 
class For(Block):
    
    _fields = ('header', 'body', 'end')
 
    def __init__(self, header, body=None, end=None, errors=()):
        self.headerheader = header
        self.bodybody = body or []
        self.endend = end
        self.errorserrorserrors = errors
 
    @property
    variables = property
    
    def variables(self):
        return self.headerheader.variables
 
    @property
    values = property
    
    def values(self):
        return self.headerheader.values
 
    @property
    flavor = property
    
    def flavor(self):
        return self.headerheader.flavor
 
    def validate(self, context):
        if self._body_is_empty_body_is_empty():
            self.errorserrorserrors += ('FOR loop cannot be empty.',)
        if not self.endend:
            self.errorserrorserrors += ('FOR loop must have closing END.',)
 
 
class Try(Block):
    
    _fields = ('header', 'body', 'next', 'end')
 
    def __init__(self, header, body=None, next=None, end=None, errors=()):
        self.headerheader = header
        self.bodybody = body or []
        self.nextnext = next
        self.endend = end
        self.errorserrorserrors = errors
 
    @property
    type = property
    
    def type(self):
        return self.headerheader.type
 
    @property
    patterns = property
    
    def patterns(self):
        return getattr(self.headerheader, 'patterns', ())
 
    @property
    pattern_type = property
    
    def pattern_type(self):
        return getattr(self.headerheader, 'pattern_type', None)
 
    @property
    variable = property
    
    def variable(self):
        return getattr(self.headerheader, 'variable', None)
 
    def validate(self, context):
        self._validate_body_validate_body()
        if self.typetypetype == Token.TRY:
            self._validate_structure_validate_structure()
            self._validate_end_validate_end()
 
    def _validate_body(self):
        if self._body_is_empty_body_is_empty():
            self.errorserrorserrors += (f'{self.type} branch cannot be empty.',)
 
    def _validate_structure(self):
        else_count = 0
        finally_count = 0
        except_count = 0
        empty_except_count = 0
        branch = self.nextnext
        while branch:
            if branch.type == Token.EXCEPT:
                if else_count:
                    self.errorserrorserrors += ('EXCEPT not allowed after ELSE.',)
                if finally_count:
                    self.errorserrorserrors += ('EXCEPT not allowed after FINALLY.',)
                if branch.patterns and empty_except_count:
                    self.errorserrorserrors += ('EXCEPT without patterns must be last.',)
                if not branch.patterns:
                    empty_except_count += 1
                except_count += 1
            if branch.type == Token.ELSE:
                if finally_count:
                    self.errorserrorserrors += ('ELSE not allowed after FINALLY.',)
                else_count += 1
            if branch.type == Token.FINALLY:
                finally_count += 1
            branch = branch.next
        if finally_count > 1:
            self.errorserrorserrors += ('Only one FINALLY allowed.',)
        if else_count > 1:
            self.errorserrorserrors += ('Only one ELSE allowed.',)
        if empty_except_count > 1:
            self.errorserrorserrors += ('Only one EXCEPT without patterns allowed.',)
        if not (except_count or finally_count):
            self.errorserrorserrors += ('TRY structure must have EXCEPT or FINALLY branch.',)
 
    def _validate_end(self):
        if not self.endend:
            self.errorserrorserrors += ('TRY must have closing END.',)
 
 
class While(Block):
    
    _fields = ('header', 'body', 'end')
 
    def __init__(self, header, body=None, end=None, errors=()):
        self.headerheader = header
        self.bodybody = body or []
        self.endend = end
        self.errorserrorserrors = errors
 
    @property
    condition = property
    
    def condition(self):
        return self.headerheader.condition
 
    @property
    limit = property
    
    def limit(self):
        return self.headerheader.limit
 
    def validate(self, context):
        if self._body_is_empty_body_is_empty():
            self.errorserrorserrors += ('WHILE loop cannot be empty.',)
        if not self.endend:
            self.errorserrorserrors += ('WHILE loop must have closing END.',)
 
 
class ModelWriter(ModelVisitor):
 
    def __init__(self, output):
        if is_string(output) or is_pathlike(output):
            self.writerwriter = file_writer(output)
            self.close_writerclose_writer = True
        else:
            self.writerwriter = output
            self.close_writerclose_writer = False
 
    def write(self, model):
        try:
            self.visitvisit(model)
        finally:
            if self.close_writerclose_writer:
                self.writerwriter.close()
 
    def visit_Statement(self, statement):
        for token in statement.tokens:
            self.writerwriter.write(token.value)
 
 
class ModelValidator(ModelVisitor):
 
    def __init__(self):
        self._context_context = ValidationContext()
 
    def visit_Block(self, node):
        self._context_context.start_block(node)
        node.validate(self._context_context)
        ModelVisitor.generic_visit(self, node)
        self._context_context.end_block()
 
    def visit_Try(self, node):
        if node.header.type == Token.FINALLY:
            self._context_context.in_finally = True
        self.visit_Blockvisit_Block(node)
        self._context_context.in_finally = False
 
    def visit_Statement(self, node):
        node.validate(self._context_context)
        ModelVisitor.generic_visit(self, node)
 
 
class ValidationContext:
 
    def __init__(self):
        self.rootsroots = []
        self.in_finallyin_finally = False
 
    def start_block(self, node):
        self.rootsroots.append(node)
 
    def end_block(self):
        self.rootsroots.pop()
 
    @property
    in_keyword = property
    
    def in_keyword(self):
        return Keyword in [type(r) for r in self.rootsroots]
 
    @property
    in_for = property
    
    def in_for(self):
        return For in [type(r) for r in self.rootsroots]
 
    @property
    in_while = property
    
    def in_while(self):
        return While in [type(r) for r in self.rootsroots]
 
 
class FirstStatementFinder(ModelVisitor):
 
    def __init__(self):
        self.statementstatement = None
 
    @classmethod
    def find_from(cls, model):
        finder = cls()
        finder.visit(model)
        return finder.statement
 
    def visit_Statement(self, statement):
        if self.statementstatement is None:
            self.statementstatement = statement
 
    def generic_visit(self, node):
        if self.statementstatement is None:
            ModelVisitor.generic_visit(self, node)
 
 
class LastStatementFinder(ModelVisitor):
 
    def __init__(self):
        self.statementstatement = None
 
    @classmethod
    def find_from(cls, model):
        finder = cls()
        finder.visit(model)
        return finder.statement
 
    def visit_Statement(self, statement):
        self.statementstatement = statement