blocks

File

Bases: Container

Source code in src/robot/parsing/model/blocks.py

class File(Container):
    _fields = ('sections',)
    _attributes = ('source', 'languages') + Container._attributes

    def __init__(self, sections: 'Sequence[Section]' = (), source: 'Path|None' = None,
                 languages: Sequence[str] = ()):
        super().__init__()
        self.sections = list(sections)
        self.source = source
        self.languages = list(languages)

    def save(self, output: 'Path|str|TextIO|None' = None):
        """Save model to the given ``output`` or to the original source file.

        The ``output`` can be a path to a file or an already opened file
        object. If ``output`` is not given, the original source file will
        be overwritten.
        """
        output = output or self.source
        if output is None:
            raise TypeError('Saving model requires explicit output '
                            'when original source is not path.')
        ModelWriter(output).write(self)

save(output=None)

Save model to the given output or to the original source file.

The output can be a path to a file or an already opened file object. If output is not given, the original source file will be overwritten.

Source code in src/robot/parsing/model/blocks.py

def save(self, output: 'Path|str|TextIO|None' = None):
    """Save model to the given ``output`` or to the original source file.

    The ``output`` can be a path to a file or an already opened file
    object. If ``output`` is not given, the original source file will
    be overwritten.
    """
    output = output or self.source
    if output is None:
        raise TypeError('Saving model requires explicit output '
                        'when original source is not path.')
    ModelWriter(output).write(self)

If

Bases: NestedBlock

Represents IF structures in the model.

Used with IF, Inline IF, ELSE IF and ELSE nodes. The :attr:type attribute specifies the type.

Source code in src/robot/parsing/model/blocks.py

class If(NestedBlock):
    """Represents IF structures in the model.

    Used with IF, Inline IF, ELSE IF and ELSE nodes. The :attr:`type` attribute
    specifies the type.
    """
    _fields = ('header', 'body', 'orelse', 'end')
    header: 'IfHeader|ElseIfHeader|ElseHeader'

    def __init__(self, header: Statement, body: Body = (), orelse: 'If|None' = None,
                 end: 'End|None' = None, errors: Errors = ()):
        super().__init__(header, body, end, errors)
        self.orelse = orelse

    @property
    def type(self) -> str:
        return self.header.type

    @property
    def condition(self) -> 'str|None':
        return self.header.condition

    @property
    def assign(self) -> 'tuple[str, ...]':
        return self.header.assign

    def validate(self, ctx: 'ValidationContext'):
        self._validate_body()
        if self.type == Token.IF:
            self._validate_structure()
            self._validate_end()
        if self.type == Token.INLINE_IF:
            self._validate_structure()
            self._validate_inline_if()

    def _validate_body(self):
        if self._body_is_empty():
            type = self.type if self.type != Token.INLINE_IF else 'IF'
            self.errors += (f'{type} branch cannot be empty.',)

    def _validate_structure(self):
        orelse = self.orelse
        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.errors:
                    self.errors += (error,)
            else_seen = else_seen or orelse.type == Token.ELSE
            orelse = orelse.orelse

    def _validate_end(self):
        if not self.end:
            self.errors += ('IF must have closing END.',)

    def _validate_inline_if(self):
        branch = self
        assign = branch.assign
        while branch:
            if branch.body:
                item = cast(Statement, branch.body[0])
                if assign and item.type != Token.KEYWORD:
                    self.errors += ('Inline IF with assignment can only contain '
                                    'keyword calls.',)
                if getattr(item, 'assign', None):
                    self.errors += ('Inline IF branches cannot contain assignments.',)
                if item.type == Token.INLINE_IF:
                    self.errors += ('Inline IF cannot be nested.',)
            branch = branch.orelse