control.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 robot.utils import setter
 
from .body import Body, BodyItem, Branches
from .keyword import Keywords
 
 
@Body.register
class For(BodyItem):
    type = BodyItem.FOR
    body_class = Body
    repr_args = ('variables', 'flavor', 'values')
    __slots__ = ['variables', 'flavor', 'values']
 
    def __init__(self, variables=(), flavor='IN', values=(), parent=None):
        self.variablesvariables = variables
        self.flavorflavor = flavor
        self.valuesvalues = values
        self.parentparent = parent
        self.bodybodybody = None
 
    @setter
    def body(self, body):
        return self.body_classbody_class(self, body)
 
    @property
    
    keywords = property
    
    def keywords(self):
        return Keywords(self, self.bodybodybody)
 
    @keywords.setter
    
    def keywords(self, keywords):
        Keywords.raise_deprecation_error()
 
    def visit(self, visitor):
        visitor.visit_for(self)
 
    def __str__(self):
        variables = '    '.join(self.variablesvariables)
        values = '    '.join(self.valuesvalues)
        return 'FOR    %s    %s    %s' % (variables, self.flavorflavor, values)
 
 
@Body.register
class While(BodyItem):
    type = BodyItem.WHILE
    body_class = Body
    repr_args = ('condition', 'limit')
    __slots__ = ['condition', 'limit']
 
    def __init__(self, condition=None, limit=None, parent=None):
        self.conditioncondition = condition
        self.limitlimit = limit
        self.parentparent = parent
        self.bodybodybody = None
 
    @setter
    def body(self, body):
        return self.body_classbody_class(self, body)
 
    def visit(self, visitor):
        visitor.visit_while(self)
 
    def __str__(self):
        return f'WHILE    {self.condition}' + (f'    {self.limit}' if self.limitlimit else '')
 
 
class IfBranch(BodyItem):
    body_class = Body
    repr_args = ('type', 'condition')
    __slots__ = ['type', 'condition']
 
    def __init__(self, type=BodyItem.IF, condition=None, parent=None):
        self.typetypetype = type
        self.conditioncondition = condition
        self.parentparent = parent
        self.bodybodybody = None
 
    @setter
    def body(self, body):
        return self.body_classbody_class(self, body)
 
    @property
    
    id = property
    
    def id(self):
        if not self.parentparent:
            return 'k1'
        if not self.parentparent.parent:
            return 'k%d' % (self.parentparent.body.index(self) + 1)
        return self._get_id_get_id(self.parentparent.parent)
 
    def __str__(self):
        if self.typetypetype == self.IFIF:
            return 'IF    %s' % self.conditioncondition
        if self.typetypetype == self.ELSE_IFELSE_IF:
            return 'ELSE IF    %s' % self.conditioncondition
        return 'ELSE'
 
    def visit(self, visitor):
        visitor.visit_if_branch(self)
 
 
@Body.register
 
class If(BodyItem):
    type = BodyItem.IF_ELSE_ROOT
    branch_class = IfBranch
    branches_class = Branches
    __slots__ = ['parent']
 
    def __init__(self, parent=None):
        self.parentparent = parent
        self.bodybodybody = None
 
    @setter
    def body(self, branches):
        return self.branches_classbranches_class(self.branch_classbranch_class, self, branches)
 
    @property
    
    id = property
    
    def id(self):
        return None
 
    def visit(self, visitor):
        visitor.visit_if(self)
 
 
class TryBranch(BodyItem):
    body_class = Body
    repr_args = ('type', 'patterns', 'pattern_type', 'variable')
    __slots__ = ['type', 'patterns', 'pattern_type', 'variable']
 
    def __init__(self, type=BodyItem.TRY, patterns=(), pattern_type=None,
                 variable=None, parent=None):
        if (patterns or pattern_type or variable) and type != BodyItem.EXCEPT:
            raise TypeError(f"'{type}' branches do not accept patterns or variables.")
        self.typetypetype = type
        self.patternspatterns = patterns
        self.pattern_typepattern_type = pattern_type
        self.variablevariable = variable
        self.parentparent = parent
        self.bodybodybody = None
 
    @setter
    def body(self, body):
        return self.body_classbody_class(self, body)
 
    @property
    
    id = property
    
    def id(self):
        if not self.parentparent:
            return 'k1'
        if not self.parentparent.parent:
            return 'k%d' % (self.parentparent.body.index(self) + 1)
        return self._get_id_get_id(self.parentparent.parent)
 
    def __str__(self):
        if self.typetypetype != BodyItem.EXCEPT:
            return self.typetypetype
        parts = ['EXCEPT'] + list(self.patternspatterns)
        if self.pattern_typepattern_type:
            parts.append(f'type={self.pattern_type}')
        if self.variablevariable:
            parts.extend(['AS', self.variablevariable])
        return '    '.join(parts)
 
    def __repr__(self):
        repr_args = self.repr_argsrepr_argsrepr_args if self.typetypetype == BodyItem.EXCEPT else ['type']
        return self._repr_repr(repr_args)
 
    def visit(self, visitor):
        visitor.visit_try_branch(self)
 
 
@Body.register
 
class Try(BodyItem):
    type = BodyItem.TRY_EXCEPT_ROOT
    branch_class = TryBranch
    branches_class = Branches
    __slots__ = []
 
    def __init__(self, parent=None):
        self.parentparent = parent
        self.bodybodybody = None
 
    @setter
    def body(self, branches):
        return self.branches_classbranches_class(self.branch_classbranch_class, self, branches)
 
    @property
    try_branch = property
    
    def try_branch(self):
        if self.bodybodybody and self.bodybodybody[0].type == BodyItem.TRY:
            return self.bodybodybody[0]
        raise TypeError("No 'TRY' branch or 'TRY' branch is not first.")
 
    @property
    except_branches = property
    
    def except_branches(self):
        return [branch for branch in self.bodybodybody if branch.type == BodyItem.EXCEPT]
 
    @property
    else_branch = property
    
    def else_branch(self):
        for branch in self.bodybodybody:
            if branch.type == BodyItem.ELSE:
                return branch
        return None
 
    @property
    finally_branch = property
    
    def finally_branch(self):
        if self.bodybodybody and self.bodybodybody[-1].type == BodyItem.FINALLY:
            return self.bodybodybody[-1]
        return None
 
    @property
    
    id = property
    
    def id(self):
        return None
 
    def visit(self, visitor):
        visitor.visit_try(self)
 
 
@Body.register
class Return(BodyItem):
    type = BodyItem.RETURN
    repr_args = ('values',)
    __slots__ = ['values']
 
    def __init__(self, values=(), parent=None):
        self.valuesvalues = values
        self.parentparent = parent
 
    def visit(self, visitor):
        visitor.visit_return(self)
 
 
@Body.register
class Continue(BodyItem):
    type = BodyItem.CONTINUE
    __slots__ = []
 
    def __init__(self, parent=None):
        self.parentparent = parent
 
    def visit(self, visitor):
        visitor.visit_continue(self)
 
 
@Body.register
class Break(BodyItem):
    type = BodyItem.BREAK
    __slots__ = []
 
    def __init__(self, parent=None):
        self.parentparent = parent
 
    def visit(self, visitor):
        visitor.visit_break(self)