settings.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 robotide.lib.robot.utils import is_string, py2to3, unicode
 
from .comments import Comment
 
 
@py2to3
class Setting():
 
    def __init__(self, setting_name, parent=None, comment=None):
        self.setting_namesetting_name = setting_name
        self.parentparent = parent
        self._set_initial_value_set_initial_value()
        self._set_comment_set_comment(comment)
        self._populated_populated = False
 
    def _set_initial_value(self):
        self.valuevalue = []
 
    def _set_comment(self, comment):
        self.commentcomment = Comment(comment)
 
    def reset(self):
        self.__init____init__(self.setting_namesetting_name, self.parentparent)
 
    @property
    source = property
    
    def source(self):
        return self.parentparent.source if self.parentparent is not None else None
 
    @property
    directory = property
    
    def directory(self):
        return self.parentparent.directory if self.parentparent is not None else None
 
    
    def populate(self, value, comment=None):
        if not self._populated_populated:
            self._populate_populate(value)
            self._set_comment_set_comment(comment)
            self._populated_populated = True
        else:
            self._set_initial_value_set_initial_value()
            self._set_comment_set_comment(None)
            self.report_invalid_syntaxreport_invalid_syntax("Setting '%s' used multiple times."
                                       % self.setting_namesetting_name, 'ERROR')
 
    def _populate(self, value):
        self.valuevalue = value
 
    def is_set(self):
        return bool(self.valuevalue)
 
    def is_for_loop(self):
        return False
 
    def report_invalid_syntax(self, message, level='ERROR'):
        self.parentparent.report_invalid_syntax(message, level)
 
    def _string_value(self, value):
        return value if is_string(value) else ' '.join(value)
 
    def _concat_string_with_value(self, string, value):
        if string:
            return string + ' ' + self._string_value_string_value(value)
        return self._string_value_string_value(value)
 
    def as_list(self):
        return self._data_as_list_data_as_list() + self.commentcomment.as_list()
 
    def _data_as_list(self):
        ret = [self.setting_namesetting_name]
        if self.valuevalue:
            ret.extend(self.valuevalue)
        return ret
 
    def __nonzero__(self):
        return self.is_setis_set()
 
    def __iter__(self):
        return iter(self.valuevalue or ())
 
    def __unicode__(self):
        return unicode(self.valuevalue or '')
 
 
class StringValueJoiner():
 
    def __init__(self, separator):
        self._separator_separator = separator
 
    def join_string_with_value(self, string, value):
        if string:
            return string + self._separator_separator + self.string_valuestring_value(value)
        return self.string_valuestring_value(value)
 
    def string_value(self, value):
        if is_string(value):
            return value
        return self._separator_separator.join(value)
 
 
class Documentation(Setting):
 
    def _set_initial_value(self):
        self.valuevaluevalue = ''
 
    def _populate(self, value):
        self.valuevaluevalue = self._concat_string_with_value_concat_string_with_value(self.valuevaluevalue, value)
 
    def _string_value(self, value):
        return value if is_string(value) else ''.join(value)
 
    def _data_as_list(self):
        return [self.setting_namesetting_name, self.valuevaluevalue]
 
 
class Template(Setting):
 
    def _set_initial_value(self):
        self.valuevaluevalue = None
 
    def _populate(self, value):
        self.valuevaluevalue = self._concat_string_with_value_concat_string_with_value(self.valuevaluevalue, value)
 
    def is_set(self):
        return self.valuevaluevalue is not None
 
    def is_active(self):
        return self.valuevaluevalue and self.valuevaluevalue.upper() != 'NONE'
 
    def _data_as_list(self):
        ret = [self.setting_namesetting_name]
        if self.valuevaluevalue:
            ret.append(self.valuevaluevalue)
        return ret
 
 
class Fixture(Setting):
 
    # `keyword`, `is_comment` and `assign` make the API compatible with Step.
 
    @property
    keyword = property
    
    def keyword(self):
        return self.namename or ''
 
    def is_comment(self):
        return False
 
    def _set_initial_value(self):
        self.namename = None
        self.argsargs = []
        self.assignassign = ()
 
    def _populate(self, value):
        if not self.namename:
            self.namename = value[0] if value else ''
            value = value[1:]
        self.argsargs.extend(value)
 
    def is_set(self):
        return self.namename is not None
 
    def is_active(self):
        return self.namename and self.namename.upper() != 'NONE'
 
    def _data_as_list(self):
        ret = [self.setting_namesetting_name]
        if self.namename or self.argsargs:
            ret.append(self.namename or '')
        if self.argsargs:
            ret.extend(self.argsargs)
        return ret
 
 
class Timeout(Setting):
 
    def _set_initial_value(self):
        self.valuevaluevalue = None
        self.messagemessage = ''
 
    def _populate(self, value):
        if not self.valuevaluevalue:
            self.valuevaluevalue = value[0] if value else ''
            value = value[1:]
        self.messagemessage = self._concat_string_with_value_concat_string_with_value(self.messagemessage, value)
        # TODO: Remove custom timeout message support in RF 3.2.
        if value and self.parentparent:
            self.parentparent.report_invalid_syntax(
                'Using custom timeout messages is deprecated since Robot '
                'Framework 3.0.1 and will be removed in future versions. '
                "Message that was used is '%s'." % self.messagemessage, level='WARN')
 
    def is_set(self):
        return self.valuevaluevalue is not None
 
    def _data_as_list(self):
        ret = [self.setting_namesetting_name]
        if self.valuevaluevalue or self.messagemessage:
            ret.append(self.valuevaluevalue or '')
        if self.messagemessage:
            ret.append(self.messagemessage)
        return ret
 
 
class Tags(Setting):
 
    def _set_initial_value(self):
        self.valuevaluevalue = None
 
    def _populate(self, value):
        self.valuevaluevalue = (self.valuevaluevalue or []) + value
 
    def is_set(self):
        return self.valuevaluevalue is not None
 
    def __add__(self, other):
        if not isinstance(other, Tags):
            raise TypeError('Tags can only be added with tags')
        tags = Tags('Tags')
        tags.value = (self.valuevaluevalue or []) + (other.value or [])
        return tags
 
 
class Arguments(Setting):
    pass
 
 
class Return(Setting):
    pass
 
 
class Metadata(Setting):
    setting_name = 'Metadata'
 
    def __init__(self, parent, name, value, comment=None, joined=False):
        self.parentparentparent = parent
        self.namename = name
        joiner = StringValueJoiner('' if joined else ' ')
        self.valuevaluevalue = joiner.join_string_with_value('', value)
        self._set_comment_set_comment(comment)
 
    def reset(self):
        pass
 
    def is_set(self):
        return True
 
    def _data_as_list(self):
        return [self.setting_namesetting_namesetting_name, self.namename, self.valuevaluevalue]
 
 
class _Import(Setting):
 
    def __init__(self, parent, name, args=None, alias=None, comment=None):
        self.parentparentparent = parent
        self.namename = name
        self.argsargs = args or []
        self.aliasalias = alias
        self._set_comment_set_comment(comment)
 
    def reset(self):
        pass
 
    @property
    type = property
    
    def type(self):
        return type(self).__name__
 
    def is_set(self):
        return True
 
    def _data_as_list(self):
        return [self.typetypetype, self.namename] + self.argsargs
 
    def report_invalid_syntax(self, message, level='ERROR', parent=None):
        parent = parent or getattr(self, 'parent', None)
        if parent:
            parent.report_invalid_syntax(message, level)
        else:
            from robotide.lib.robot.api import logger
            logger.write(message, level)
 
 
class Library(_Import):
 
    def __init__(self, parent, name, args=None, alias=None, comment=None):
        if args and not alias:
            args, alias = self._split_possible_alias_split_possible_alias(args)
        _Import.__init__(self, parent, name, args, alias, comment)
 
    def _split_possible_alias(self, args):
        if len(args) > 1 and args[-2] == 'WITH NAME':
            return args[:-2], args[-1]
        return args, None
 
    def _data_as_list(self):
        data = ['Library', self.namename] + self.argsargs
        if self.aliasalias:
            data += ['WITH NAME', self.aliasalias]
        return data
 
 
class Resource(_Import):
 
    def __init__(self, parent, name, invalid_args=None, comment=None):
        if invalid_args:
            name += ' ' + ' '.join(invalid_args)
        _Import.__init__(self, parent, name, comment=comment)
 
 
class Variables(_Import):
 
    def __init__(self, parent, name, args=None, comment=None):
        _Import.__init__(self, parent, name, args, comment=comment)
 
 
class _DataList():
 
    def __init__(self, parent):
        self._parent_parent = parent
        self.datadata = []
 
    def add(self, meta):
        self._add_add(meta)
 
    def _add(self, meta):
        self.datadata.append(meta)
 
    def _parse_name_and_value(self, value):
        name = value[0] if value else ''
        return name, value[1:]
 
    def __getitem__(self, index):
        return self.datadata[index]
 
    def __setitem__(self, index, item):
        self.datadata[index] = item
 
    def __len__(self):
        return len(self.datadata)
 
    def __iter__(self):
        return iter(self.datadata)
 
 
class ImportList(_DataList):
 
    def populate_library(self, data, comment):
        self._populate_populate(Library, data, comment)
 
    def populate_resource(self, data, comment):
        self._populate_populate(Resource, data, comment)
 
    def populate_variables(self, data, comment):
        self._populate_populate(Variables, data, comment)
 
    def _populate(self, item_class, data, comment):
        name, value = self._parse_name_and_value_parse_name_and_value(data)
        self._add_add(item_class(self._parent_parent, name, value, comment=comment))
 
 
class MetadataList(_DataList):
 
    def populate(self, name, value, comment):
        self._add_add(Metadata(self._parent_parent, name, value, comment, joined=True))