statements.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
import re
 
from robot.conf import Language
from robot.running.arguments import UserKeywordArgumentParser
from robot.utils import is_list_like, normalize_whitespace, seq2str, split_from_equals
from robot.variables import is_scalar_assign, is_dict_variable, search_variable
 
from ..lexer import Token
 
 
FOUR_SPACES = '    '
EOL = '\n'
 
 
class Statement(ast.AST):
    type = None
    handles_types = ()
    
    _fields = ('type', 'tokens')
    
    _attributes = ('lineno', 'col_offset', 'end_lineno', 'end_col_offset', 'errors')
    
    _statement_handlers = {}
 
    def __init__(self, tokens, errors=()):
        self.tokenstokens = tuple(tokens)
        self.errorserrors = errors
 
    @property
    lineno = property
    
    def lineno(self):
        return self.tokenstokens[0].lineno if self.tokenstokens else -1
 
    @property
    col_offset = property
    
    def col_offset(self):
        return self.tokenstokens[0].col_offset if self.tokenstokens else -1
 
    @property
    end_lineno = property
    
    def end_lineno(self):
        return self.tokenstokens[-1].lineno if self.tokenstokens else -1
 
    @property
    end_col_offset = property
    
    def end_col_offset(self):
        return self.tokenstokens[-1].end_col_offset if self.tokenstokens else -1
 
    @classmethod
    def register(cls, subcls):
        types = subcls.handles_types or (subcls.type,)
        for typ in types:
            cls._statement_handlers_statement_handlers[typ] = subcls
        return subcls
 
    @classmethod
    def from_tokens(cls, tokens):
        handlers = cls._statement_handlers_statement_handlers
        for token in tokens:
            if token.type in handlers:
                return handlers[token.type](tokens)
        if any(token.type == Token.ASSIGN for token in tokens):
            return KeywordCall(tokens)
        return EmptyLine(tokens)
 
    @classmethod
    
    def from_params(cls, *args, **kwargs):
        raise NotImplementedError
 
    @property
    data_tokens = property
    
    def data_tokens(self):
        return [t for t in self.tokenstokens if t.type not in Token.NON_DATA_TOKENS]
 
    
    def get_token(self, *types):
        for token in self.tokenstokens:
            if token.type in types:
                return token
        return None
 
    
    def get_tokens(self, *types):
        return [t for t in self.tokenstokens if t.type in types]
 
    
    def get_value(self, type, default=None):
        token = self.get_tokenget_token(type)
        return token.value if token else default
 
    
    def get_values(self, *types):
        return tuple(t.value for t in self.tokenstokens if t.type in types)
 
    @property
    lines = property
    
    def lines(self):
        line = []
        for token in self.tokenstokens:
            line.append(token)
            if token.type == Token.EOL:
                yield line
                line = []
        if line:
            yield line
 
    def validate(self, context):
        pass
 
    def __iter__(self):
        return iter(self.tokens)
 
    def __len__(self):
        return len(self.tokenstokens)
 
    def __getitem__(self, item):
        return self.tokenstokens[item]
 
    def __repr__(self):
        errors = '' if not self.errorserrors else ', errors=%s' % list(self.errorserrors)
        return '%s(tokens=%s%s)' % (type(self).__name__, list(self.tokenstokens), errors)
 
 
class DocumentationOrMetadata(Statement):
 
    def _join_value(self, tokens):
        lines = self._get_lines_get_lines(tokens)
        return ''.join(self._yield_lines_with_newlines_yield_lines_with_newlines(lines))
 
    def _get_lines(self, tokens):
        lines = []
        line = None
        lineno = -1
        for t in tokens:
            if t.lineno != lineno:
                line = []
                lines.append(line)
            line.append(t.value)
            lineno = t.lineno
        return [' '.join(line) for line in lines]
 
    def _yield_lines_with_newlines(self, lines):
        last_index = len(lines) - 1
        for index, line in enumerate(lines):
            yield line
            if index < last_index and not self._escaped_or_has_newline_escaped_or_has_newline(line):
                yield '\n'
 
    def _escaped_or_has_newline(self, line):
        match = re.search(r'(\\+)n?$', line)
        return match and len(match.group(1)) % 2 == 1
 
 
class SingleValue(Statement):
 
    @property
    value = property
    
    def value(self):
        values = self.get_valuesget_values(Token.NAME, Token.ARGUMENT)
        if values and values[0].upper() != 'NONE':
            return values[0]
        return None
 
 
class MultiValue(Statement):
 
    @property
    values = property
    
    def values(self):
        return self.get_valuesget_values(Token.ARGUMENT)
 
 
class Fixture(Statement):
 
    @property
    name = property
    
    def name(self):
        return self.get_valueget_value(Token.NAME)
 
    @property
    args = property
    
    def args(self):
        return self.get_valuesget_values(Token.ARGUMENT)
 
 
@Statement.register
class SectionHeader(Statement):
    handles_types = (Token.SETTING_HEADER, Token.VARIABLE_HEADER,
                     Token.TESTCASE_HEADER, Token.TASK_HEADER,
                     Token.KEYWORD_HEADER, Token.COMMENT_HEADER)
 
    @classmethod
    def from_params(cls, type, name=None, eol=EOL):
        if not name:
            names = ('Settings', 'Variables', 'Test Cases', 'Tasks',
                     'Keywords', 'Comments')
            name = dict(zip(cls.handles_typeshandles_typeshandles_types, names))[type]
        if not name.startswith('*'):
            name = '*** %s ***' % name
        return cls([
            Token(type, name),
            Token('EOL', '\n')
        ])
 
    @property
    type = property
    
    def type(self):
        token = self.get_tokenget_token(*self.handles_typeshandles_typeshandles_types)
        return token.type
 
    @property
    name = property
    
    def name(self):
        token = self.get_tokenget_token(*self.handles_typeshandles_typeshandles_types)
        return normalize_whitespace(token.value).strip('* ')
 
 
@Statement.register
class LibraryImport(Statement):
    type = Token.LIBRARY
 
    @classmethod
    def from_params(cls, name, args=(), alias=None, separator=FOUR_SPACES, eol=EOL):
        tokens = [Token(Token.LIBRARY, 'Library'),
                  Token(Token.SEPARATOR, separator),
                  Token(Token.NAME, name)]
        for arg in args:
            tokens.extend([Token(Token.SEPARATOR, separator),
                           Token(Token.ARGUMENT, arg)])
        if alias is not None:
            tokens.extend([Token(Token.SEPARATOR, separator),
                           Token(Token.WITH_NAME),
                           Token(Token.SEPARATOR, separator),
                           Token(Token.NAME, alias)])
        tokens.append(Token(Token.EOL, eol))
        return cls(tokens)
 
    @property
    name = property
    
    def name(self):
        return self.get_valueget_value(Token.NAME)
 
    @property
    args = property
    
    def args(self):
        return self.get_valuesget_values(Token.ARGUMENT)
 
    @property
    alias = property
    
    def alias(self):
        with_name = self.get_tokenget_token(Token.WITH_NAME)
        return self.get_tokensget_tokens(Token.NAME)[-1].value if with_name else None
 
 
@Statement.register
class ResourceImport(Statement):
    type = Token.RESOURCE
 
    @classmethod
    def from_params(cls, name, separator=FOUR_SPACES, eol=EOL):
        return cls([
            Token(Token.RESOURCE, 'Resource'),
            Token(Token.SEPARATOR, separator),
            Token(Token.NAME, name),
            Token(Token.EOL, eol)
        ])
 
    @property
    name = property
    
    def name(self):
        return self.get_valueget_value(Token.NAME)
 
 
@Statement.register
class VariablesImport(Statement):
    type = Token.VARIABLES
 
    @classmethod
    def from_params(cls, name, args=(), separator=FOUR_SPACES, eol=EOL):
        tokens = [Token(Token.VARIABLES, 'Variables'),
                  Token(Token.SEPARATOR, separator),
                  Token(Token.NAME, name)]
        for arg in args:
            tokens.extend([Token(Token.SEPARATOR, separator),
                           Token(Token.ARGUMENT, arg)])
        tokens.append(Token(Token.EOL, eol))
        return cls(tokens)
 
    @property
    name = property
    
    def name(self):
        return self.get_valueget_value(Token.NAME)
 
    @property
    args = property
    
    def args(self):
        return self.get_valuesget_values(Token.ARGUMENT)
 
 
@Statement.register
class Documentation(DocumentationOrMetadata):
    type = Token.DOCUMENTATION
 
    @classmethod
    def from_params(cls, value, indent=FOUR_SPACES, separator=FOUR_SPACES,
                    eol=EOL, settings_section=True):
        if settings_section:
            tokens = [Token(Token.DOCUMENTATION, 'Documentation'),
                      Token(Token.SEPARATOR, separator)]
        else:
            tokens = [Token(Token.SEPARATOR, indent),
                      Token(Token.DOCUMENTATION, '[Documentation]'),
                      Token(Token.SEPARATOR, separator)]
        multiline_separator = ' ' * (len(tokens[-2].value) + len(separator) - 3)
        doc_lines = value.splitlines()
        if doc_lines:
            tokens.extend([Token(Token.ARGUMENT, doc_lines[0]),
                           Token(Token.EOL, eol)])
        for line in doc_lines[1:]:
            if not settings_section:
                tokens.append(Token(Token.SEPARATOR, indent))
            tokens.append(Token(Token.CONTINUATION))
            if line:
                tokens.extend([Token(Token.SEPARATOR, multiline_separator),
                               Token(Token.ARGUMENT, line)])
            tokens.append(Token(Token.EOL, eol))
        return cls(tokens)
 
    @property
    value = property
    
    def value(self):
        tokens = self.get_tokensget_tokens(Token.ARGUMENT)
        return self._join_value_join_value(tokens)
 
 
@Statement.register
class Metadata(DocumentationOrMetadata):
    type = Token.METADATA
 
    @classmethod
    def from_params(cls, name, value, separator=FOUR_SPACES, eol=EOL):
        tokens = [Token(Token.METADATA, 'Metadata'),
                  Token(Token.SEPARATOR, separator),
                  Token(Token.NAME, name)]
        metadata_lines = value.splitlines()
        if metadata_lines:
            tokens.extend([Token(Token.SEPARATOR, separator),
                           Token(Token.ARGUMENT, metadata_lines[0]),
                           Token(Token.EOL, eol)])
        for line in metadata_lines[1:]:
            tokens.extend([Token(Token.CONTINUATION),
                           Token(Token.SEPARATOR, separator),
                           Token(Token.ARGUMENT, line),
                           Token(Token.EOL, eol)])
        return cls(tokens)
 
    @property
    name = property
    
    def name(self):
        return self.get_valueget_value(Token.NAME)
 
    @property
    value = property
    
    def value(self):
        tokens = self.get_tokensget_tokens(Token.ARGUMENT)
        return self._join_value_join_value(tokens)
 
 
@Statement.register
class ForceTags(MultiValue):
    type = Token.FORCE_TAGS
 
    @classmethod
    def from_params(cls, values, separator=FOUR_SPACES, eol=EOL):
        tokens = [Token(Token.FORCE_TAGS, 'Force Tags')]
        for tag in values:
            tokens.extend([Token(Token.SEPARATOR, separator),
                           Token(Token.ARGUMENT, tag)])
        tokens.append(Token(Token.EOL, eol))
        return cls(tokens)
 
 
@Statement.register
class DefaultTags(MultiValue):
    type = Token.DEFAULT_TAGS
 
    @classmethod
    def from_params(cls, values, separator=FOUR_SPACES, eol=EOL):
        tokens = [Token(Token.DEFAULT_TAGS, 'Default Tags')]
        for tag in values:
            tokens.extend([Token(Token.SEPARATOR, separator),
                           Token(Token.ARGUMENT, tag)])
        tokens.append(Token(Token.EOL, eol))
        return cls(tokens)
 
 
@Statement.register
class KeywordTags(MultiValue):
    type = Token.KEYWORD_TAGS
 
    @classmethod
    def from_params(cls, values, separator=FOUR_SPACES, eol=EOL):
        tokens = [Token(Token.KEYWORD_TAGS, 'Keyword Tags')]
        for tag in values:
            tokens.extend([Token(Token.SEPARATOR, separator),
                           Token(Token.ARGUMENT, tag)])
        tokens.append(Token(Token.EOL, eol))
        return cls(tokens)
 
 
@Statement.register
class SuiteSetup(Fixture):
    type = Token.SUITE_SETUP
 
    @classmethod
    def from_params(cls, name, args=(), separator=FOUR_SPACES, eol=EOL):
        tokens = [Token(Token.SUITE_SETUP, 'Suite Setup'),
                  Token(Token.SEPARATOR, separator),
                  Token(Token.NAME, name)]
        for arg in args:
            tokens.extend([Token(Token.SEPARATOR, separator),
                           Token(Token.ARGUMENT, arg)])
        tokens.append(Token(Token.EOL, eol))
        return cls(tokens)
 
 
@Statement.register
class SuiteTeardown(Fixture):
    type = Token.SUITE_TEARDOWN
 
    @classmethod
    def from_params(cls, name, args=(), separator=FOUR_SPACES, eol=EOL):
        tokens = [Token(Token.SUITE_TEARDOWN, 'Suite Teardown'),
                  Token(Token.SEPARATOR, separator),
                  Token(Token.NAME, name)]
        for arg in args:
            tokens.extend([Token(Token.SEPARATOR, separator),
                           Token(Token.ARGUMENT, arg)])
        tokens.append(Token(Token.EOL, eol))
        return cls(tokens)
 
 
@Statement.register
class TestSetup(Fixture):
    type = Token.TEST_SETUP
 
    @classmethod
    def from_params(cls, name, args=(), separator=FOUR_SPACES, eol=EOL):
        tokens = [Token(Token.TEST_SETUP, 'Test Setup'),
                  Token(Token.SEPARATOR, separator),
                  Token(Token.NAME, name)]
        for arg in args:
            tokens.extend([Token(Token.SEPARATOR, separator),
                           Token(Token.ARGUMENT, arg)])
        tokens.append(Token(Token.EOL, eol))
        return cls(tokens)
 
 
@Statement.register
class TestTeardown(Fixture):
    type = Token.TEST_TEARDOWN
 
    @classmethod
    def from_params(cls, name, args=(), separator=FOUR_SPACES, eol=EOL):
        tokens = [Token(Token.TEST_TEARDOWN, 'Test Teardown'),
                  Token(Token.SEPARATOR, separator),
                  Token(Token.NAME, name)]
        for arg in args:
            tokens.extend([Token(Token.SEPARATOR, separator),
                           Token(Token.ARGUMENT, arg)])
        tokens.append(Token(Token.EOL, eol))
        return cls(tokens)
 
 
@Statement.register
class TestTemplate(SingleValue):
    type = Token.TEST_TEMPLATE
 
    @classmethod
    def from_params(cls, value, separator=FOUR_SPACES, eol=EOL):
        return cls([
            Token(Token.TEST_TEMPLATE, 'Test Template'),
            Token(Token.SEPARATOR, separator),
            Token(Token.NAME, value),
            Token(Token.EOL, eol)
        ])
 
 
@Statement.register
class TestTimeout(SingleValue):
    type = Token.TEST_TIMEOUT
 
    @classmethod
    def from_params(cls, value, separator=FOUR_SPACES, eol=EOL):
        return cls([
            Token(Token.TEST_TIMEOUT, 'Test Timeout'),
            Token(Token.SEPARATOR, separator),
            Token(Token.ARGUMENT, value),
            Token(Token.EOL, eol)
        ])
 
 
@Statement.register
class Variable(Statement):
    type = Token.VARIABLE
 
    @classmethod
    
    def from_params(cls, name, value, separator=FOUR_SPACES, eol=EOL):
        values = value if is_list_like(value) else [value]
        tokens = [Token(Token.VARIABLE, name)]
        for value in values:
            tokens.extend([Token(Token.SEPARATOR, separator),
                           Token(Token.ARGUMENT, value)])
        tokens.append(Token(Token.EOL, eol))
        return cls(tokens)
 
    @property
    name = property
    
    def name(self):
        name = self.get_valueget_value(Token.VARIABLE)
        if name.endswith('='):
            return name[:-1].rstrip()
        return name
 
    @property
    value = property
    
    def value(self):
        return self.get_valuesget_values(Token.ARGUMENT)
 
    def validate(self, context):
        name = self.get_valueget_value(Token.VARIABLE)
        match = search_variable(name, ignore_errors=True)
        if not match.is_assign(allow_assign_mark=True):
            self.errorserrors += ("Invalid variable name '%s'." % name,)
        if match.is_dict_assign(allow_assign_mark=True):
            self._validate_dict_items_validate_dict_items()
 
    def _validate_dict_items(self):
        for item in self.get_valuesget_values(Token.ARGUMENT):
            if not self._is_valid_dict_item_is_valid_dict_item(item):
                self.errorserrors += (
                    "Invalid dictionary variable item '%s'. "
                    "Items must use 'name=value' syntax or be dictionary "
                    "variables themselves." % item,
                )
 
    def _is_valid_dict_item(self, item):
        name, value = split_from_equals(item)
        return value is not None or is_dict_variable(item)
 
 
@Statement.register
class TestCaseName(Statement):
    type = Token.TESTCASE_NAME
 
    @classmethod
    def from_params(cls, name, eol=EOL):
        tokens = [Token(Token.TESTCASE_NAME, name)]
        if eol:
            tokens.append(Token(Token.EOL, eol))
        return cls(tokens)
 
    @property
    name = property
    
    def name(self):
        return self.get_valueget_value(Token.TESTCASE_NAME)
 
 
@Statement.register
class KeywordName(Statement):
    type = Token.KEYWORD_NAME
 
    @classmethod
    def from_params(cls, name, eol=EOL):
        tokens = [Token(Token.KEYWORD_NAME, name)]
        if eol:
            tokens.append(Token(Token.EOL, eol))
        return cls(tokens)
 
    @property
    name = property
    
    def name(self):
        return self.get_valueget_value(Token.KEYWORD_NAME)
 
 
@Statement.register
class Setup(Fixture):
    type = Token.SETUP
 
    @classmethod
    def from_params(cls, name, args=(), indent=FOUR_SPACES, separator=FOUR_SPACES,
                    eol=EOL):
        tokens = [Token(Token.SEPARATOR, indent),
                  Token(Token.SETUP, '[Setup]'),
                  Token(Token.SEPARATOR, separator),
                  Token(Token.NAME, name)]
        for arg in args:
            tokens.extend([Token(Token.SEPARATOR, separator),
                           Token(Token.ARGUMENT, arg)])
        tokens.append(Token(Token.EOL, eol))
        return cls(tokens)
 
 
@Statement.register
class Teardown(Fixture):
    type = Token.TEARDOWN
 
    @classmethod
    def from_params(cls, name, args=(), indent=FOUR_SPACES, separator=FOUR_SPACES,
                    eol=EOL):
        tokens = [Token(Token.SEPARATOR, indent),
                  Token(Token.TEARDOWN, '[Teardown]'),
                  Token(Token.SEPARATOR, separator),
                  Token(Token.NAME, name)]
        for arg in args:
            tokens.extend([Token(Token.SEPARATOR, separator),
                           Token(Token.ARGUMENT, arg)])
        tokens.append(Token(Token.EOL, eol))
        return cls(tokens)
 
 
@Statement.register
class Tags(MultiValue):
    type = Token.TAGS
 
    @classmethod
    def from_params(cls, values, indent=FOUR_SPACES, separator=FOUR_SPACES, eol=EOL):
        tokens = [Token(Token.SEPARATOR, indent),
                  Token(Token.TAGS, '[Tags]')]
        for tag in values:
            tokens.extend([Token(Token.SEPARATOR, separator),
                           Token(Token.ARGUMENT, tag)])
        tokens.append(Token(Token.EOL, eol))
        return cls(tokens)
 
 
@Statement.register
class Template(SingleValue):
    type = Token.TEMPLATE
 
    @classmethod
    def from_params(cls, value, indent=FOUR_SPACES, separator=FOUR_SPACES, eol=EOL):
        return cls([
            Token(Token.SEPARATOR, indent),
            Token(Token.TEMPLATE, '[Template]'),
            Token(Token.SEPARATOR, separator),
            Token(Token.NAME, value),
            Token(Token.EOL, eol)
        ])
 
 
@Statement.register
class Timeout(SingleValue):
    type = Token.TIMEOUT
 
    @classmethod
    def from_params(cls, value, indent=FOUR_SPACES, separator=FOUR_SPACES, eol=EOL):
        return cls([
            Token(Token.SEPARATOR, indent),
            Token(Token.TIMEOUT, '[Timeout]'),
            Token(Token.SEPARATOR, separator),
            Token(Token.ARGUMENT, value),
            Token(Token.EOL, eol)
        ])
 
 
@Statement.register
class Arguments(MultiValue):
    type = Token.ARGUMENTS
 
    @classmethod
    def from_params(cls, args, indent=FOUR_SPACES, separator=FOUR_SPACES, eol=EOL):
        tokens = [Token(Token.SEPARATOR, indent),
                  Token(Token.ARGUMENTS, '[Arguments]')]
        for arg in args:
            tokens.extend([Token(Token.SEPARATOR, separator),
                           Token(Token.ARGUMENT, arg)])
        tokens.append(Token(Token.EOL, eol))
        return cls(tokens)
 
    def validate(self, context):
        errors = []
        UserKeywordArgumentParser(error_reporter=errors.append).parse(self.valuesvaluesvalues)
        self.errorserrorserrors = tuple(errors)
 
 
@Statement.register
class Return(MultiValue):
    type = Token.RETURN
 
    @classmethod
    def from_params(cls, args, indent=FOUR_SPACES, separator=FOUR_SPACES, eol=EOL):
        tokens = [Token(Token.SEPARATOR, indent),
                  Token(Token.RETURN, '[Return]')]
        for arg in args:
            tokens.extend([Token(Token.SEPARATOR, separator),
                           Token(Token.ARGUMENT, arg)])
        tokens.append(Token(Token.EOL, eol))
        return cls(tokens)
 
 
@Statement.register
class KeywordCall(Statement):
    type = Token.KEYWORD
 
    @classmethod
    def from_params(cls, name, assign=(), args=(), indent=FOUR_SPACES,
                    separator=FOUR_SPACES, eol=EOL):
        tokens = [Token(Token.SEPARATOR, indent)]
        for assignment in assign:
            tokens.extend([Token(Token.ASSIGN, assignment),
                           Token(Token.SEPARATOR, separator)])
        tokens.append(Token(Token.KEYWORD, name))
        for arg in args:
            tokens.extend([Token(Token.SEPARATOR, separator),
                           Token(Token.ARGUMENT, arg)])
        tokens.append(Token(Token.EOL, eol))
        return cls(tokens)
 
    @property
    keyword = property
    
    def keyword(self):
        return self.get_valueget_value(Token.KEYWORD)
 
    @property
    args = property
    
    def args(self):
        return self.get_valuesget_values(Token.ARGUMENT)
 
    @property
    assign = property
    
    def assign(self):
        return self.get_valuesget_values(Token.ASSIGN)
 
 
@Statement.register
class TemplateArguments(Statement):
    type = Token.ARGUMENT
 
    @classmethod
    def from_params(cls, args, indent=FOUR_SPACES, separator=FOUR_SPACES, eol=EOL):
        tokens = []
        for index, arg in enumerate(args):
            tokens.extend([Token(Token.SEPARATOR, separator if index else indent),
                           Token(Token.ARGUMENT, arg)])
        tokens.append(Token(Token.EOL, eol))
        return cls(tokens)
 
    @property
    args = property
    
    def args(self):
        return self.get_valuesget_values(self.typetypetype)
 
 
@Statement.register
class ForHeader(Statement):
    type = Token.FOR
 
    @classmethod
    def from_params(cls, variables, values, flavor='IN', indent=FOUR_SPACES,
                    separator=FOUR_SPACES, eol=EOL):
        tokens = [Token(Token.SEPARATOR, indent),
                  Token(Token.FOR),
                  Token(Token.SEPARATOR, separator)]
        for variable in variables:
            tokens.extend([Token(Token.VARIABLE, variable),
                           Token(Token.SEPARATOR, separator)])
        tokens.append(Token(Token.FOR_SEPARATOR, flavor))
        for value in values:
            tokens.extend([Token(Token.SEPARATOR, separator),
                           Token(Token.ARGUMENT, value)])
        tokens.append(Token(Token.EOL, eol))
        return cls(tokens)
 
    @property
    variables = property
    
    def variables(self):
        return self.get_valuesget_values(Token.VARIABLE)
 
    @property
    values = property
    
    def values(self):
        return self.get_valuesget_values(Token.ARGUMENT)
 
    @property
    flavor = property
    
    def flavor(self):
        separator = self.get_tokenget_token(Token.FOR_SEPARATOR)
        return normalize_whitespace(separator.value) if separator else None
 
    def validate(self, context):
        if not self.variablesvariablesvariables:
            self._add_error_add_error('no loop variables')
        if not self.flavorflavorflavor:
            self._add_error_add_error("no 'IN' or other valid separator")
        else:
            for var in self.variablesvariablesvariables:
                if not is_scalar_assign(var):
                    self._add_error_add_error("invalid loop variable '%s'" % var)
            if not self.valuesvaluesvalues:
                self._add_error_add_error('no loop values')
 
    def _add_error(self, error):
        self.errorserrors += ('FOR loop has %s.' % error,)
 
 
class IfElseHeader(Statement):
 
    @property
    condition = property
    
    def condition(self):
        return None
 
    @property
    assign = property
    
    def assign(self):
        return None
 
 
@Statement.register
class IfHeader(IfElseHeader):
    type = Token.IF
 
    @classmethod
    def from_params(cls, condition, indent=FOUR_SPACES, separator=FOUR_SPACES, eol=EOL):
        tokens = [Token(Token.SEPARATOR, indent),
                  Token(cls.typetypetype),
                  Token(Token.SEPARATOR, separator),
                  Token(Token.ARGUMENT, condition)]
        if cls.typetypetype != Token.INLINE_IF:
            tokens.append(Token(Token.EOL, eol))
        return cls(tokens)
 
    @property
    condition = property
    
    def condition(self):
        values = self.get_valuesget_values(Token.ARGUMENT)
        if len(values) != 1:
            return ', '.join(values) if values else None
        return values[0]
 
    def validate(self, context):
        conditions = len(self.get_tokensget_tokens(Token.ARGUMENT))
        if conditions == 0:
            self.errorserrors += ('%s must have a condition.' % self.typetypetype,)
        if conditions > 1:
            self.errorserrors += ('%s cannot have more than one condition.' % self.typetypetype,)
 
 
@Statement.register
class InlineIfHeader(IfHeader):
    type = Token.INLINE_IF
 
    @property
    assign = property
    
    def assign(self):
        return self.get_valuesget_values(Token.ASSIGN)
 
 
@Statement.register
class ElseIfHeader(IfHeader):
    type = Token.ELSE_IF
 
 
@Statement.register
class ElseHeader(IfElseHeader):
    type = Token.ELSE
 
    @classmethod
    def from_params(cls, indent=FOUR_SPACES, eol=EOL):
        return cls([
            Token(Token.SEPARATOR, indent),
            Token(Token.ELSE),
            Token(Token.EOL, eol)
        ])
 
    def validate(self, context):
        if self.get_tokensget_tokens(Token.ARGUMENT):
            values = self.get_valuesget_values(Token.ARGUMENT)
            self.errorserrors += (f'ELSE does not accept arguments, got {seq2str(values)}.',)
 
 
class NoArgumentHeader(Statement):
 
    @classmethod
    def from_params(cls, indent=FOUR_SPACES, eol=EOL):
        return cls([
            Token(Token.SEPARATOR, indent),
            Token(cls.typetype),
            Token(Token.EOL, eol)
        ])
 
    def validate(self, context):
        if self.get_tokensget_tokens(Token.ARGUMENT):
            self.errorserrors += (f'{self.type} does not accept arguments, got '
                            f'{seq2str(self.values)}.',)
 
    @property
    values = property
    
    def values(self):
        return self.get_valuesget_values(Token.ARGUMENT)
 
 
@Statement.register
class TryHeader(NoArgumentHeader):
    type = Token.TRY
 
 
@Statement.register
class ExceptHeader(Statement):
    type = Token.EXCEPT
 
    @classmethod
    def from_params(cls, patterns=(), type=None, variable=None, indent=FOUR_SPACES,
                    separator=FOUR_SPACES, eol=EOL):
        tokens = [Token(Token.SEPARATOR, indent),
                  Token(Token.EXCEPT)]
        for pattern in patterns:
            tokens.extend([Token(Token.SEPARATOR, separator),
                           Token(Token.ARGUMENT, pattern)]),
        if type:
            tokens.extend([Token(Token.SEPARATOR, separator),
                           Token(Token.OPTION, f'type={type}')])
        if variable:
            tokens.extend([Token(Token.SEPARATOR, separator),
                           Token(Token.AS),
                           Token(Token.SEPARATOR, separator),
                           Token(Token.VARIABLE, variable)])
        tokens.append(Token(Token.EOL, eol))
        return cls(tokens)
 
    @property
    patterns = property
    
    def patterns(self):
        return self.get_valuesget_values(Token.ARGUMENT)
 
    @property
    pattern_type = property
    
    def pattern_type(self):
        value = self.get_valueget_value(Token.OPTION)
        return value[len('type='):] if value else None
 
    @property
    variable = property
    
    def variable(self):
        return self.get_valueget_value(Token.VARIABLE)
 
    def validate(self, context):
        as_token = self.get_tokenget_token(Token.AS)
        if as_token:
            variables = self.get_tokensget_tokens(Token.VARIABLE)
            if not variables:
                self.errorserrors += ("EXCEPT's AS requires variable.",)
            elif len(variables) > 1:
                self.errorserrors += ("EXCEPT's AS accepts only one variable.",)
            elif not is_scalar_assign(variables[0].value):
                self.errorserrors += (f"EXCEPT's AS variable '{variables[0].value}' is invalid.",)
 
 
@Statement.register
class FinallyHeader(NoArgumentHeader):
    type = Token.FINALLY
 
 
@Statement.register
class End(NoArgumentHeader):
    type = Token.END
 
 
@Statement.register
class WhileHeader(Statement):
    type = Token.WHILE
 
    @classmethod
    def from_params(cls, condition, limit=None, indent=FOUR_SPACES,
                    separator=FOUR_SPACES, eol=EOL):
        tokens = [Token(Token.SEPARATOR, indent),
                  Token(cls.typetypetype),
                  Token(Token.SEPARATOR, separator),
                  Token(Token.ARGUMENT, condition)]
        if limit:
            tokens.extend([Token(Token.SEPARATOR, indent),
                           Token(Token.OPTION, f'limit={limit}')])
        tokens.append(Token(Token.EOL, eol))
        return cls(tokens)
 
    @property
    condition = property
    
    def condition(self):
        return ', '.join(self.get_valuesget_values(Token.ARGUMENT))
 
    @property
    limit = property
    
    def limit(self):
        value = self.get_valueget_value(Token.OPTION)
        return value[len('limit='):] if value else None
 
    def validate(self, context):
        values = self.get_valuesget_values(Token.ARGUMENT)
        if len(values) == 0:
            self.errorserrors += ('WHILE must have a condition.',)
        if len(values) == 2:
            self.errorserrors += (f"Second WHILE loop argument must be 'limit', "
                            f"got '{values[1]}'.",)
        if len(values) > 2:
            self.errorserrors += ('WHILE cannot have more than one condition.',)
 
 
@Statement.register
class ReturnStatement(Statement):
    type = Token.RETURN_STATEMENT
 
    @property
    values = property
    
    def values(self):
        return self.get_valuesget_values(Token.ARGUMENT)
 
    @classmethod
    def from_params(cls, values=(), indent=FOUR_SPACES, separator=FOUR_SPACES, eol=EOL):
        tokens = [Token(Token.SEPARATOR, indent),
                  Token(Token.RETURN_STATEMENT)]
        for value in values:
            tokens.extend([Token(Token.SEPARATOR, separator),
                           Token(Token.ARGUMENT, value)])
        tokens.append(Token(Token.EOL, eol))
        return cls(tokens)
 
    def validate(self, context):
        if not context.in_keyword:
            self.errorserrors += ('RETURN can only be used inside a user keyword.', )
        if context.in_keyword and context.in_finally:
            self.errorserrors += ('RETURN cannot be used in FINALLY branch.', )
 
 
class LoopControl(NoArgumentHeader):
 
    def validate(self, context):
        super(LoopControl, self).validate(context)
        if not (context.in_for or context.in_while):
            self.errorserrors += (f'{self.type} can only be used inside a loop.', )
        if context.in_finally:
            self.errorserrors += (f'{self.type} cannot be used in FINALLY branch.', )
 
 
@Statement.register
class Continue(LoopControl):
    type = Token.CONTINUE
 
 
@Statement.register
class Break(LoopControl):
    type = Token.BREAK
 
 
@Statement.register
class Comment(Statement):
    type = Token.COMMENT
 
    @classmethod
    def from_params(cls, comment, indent=FOUR_SPACES, eol=EOL):
        return cls([
            Token(Token.SEPARATOR, indent),
            Token(Token.COMMENT, comment),
            Token(Token.EOL, eol)
        ])
 
 
@Statement.register
class Config(Statement):
    type = Token.CONFIG
 
    @classmethod
    def from_params(cls, config, eol=EOL):
        return cls([
            Token(Token.CONFIG, config),
            Token(Token.EOL, eol)
        ])
 
    @property
    language = property
    
    def language(self):
        value = self.get_valueget_value(Token.CONFIG)
        return Language.from_name(value[len('language:'):]) if value else None
 
 
@Statement.register
class Error(Statement):
    type = Token.ERROR
    handles_types = (Token.ERROR, Token.FATAL_ERROR)
    
    _errors = ()
 
    @property
    
    errors = property
    
    def errors(self):
        tokens = self.get_tokensget_tokens(Token.ERROR, Token.FATAL_ERROR)
        return tuple(t.error for t in tokens) + self._errors_errors_errors
 
    @errors.setter
    
    def errors(self, errors):
        self._errors_errors_errors = tuple(errors)
 
 
class EmptyLine(Statement):
    type = Token.EOL
 
    @classmethod
    def from_params(cls, eol=EOL):
        return cls([Token(Token.EOL, eol)])