settingcontrollers.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 re
from itertools import chain
from os import linesep
 
from .. import robotapi, utils
from ..publish.messages import (RideImportSettingChanged,RideImportSettingRemoved, RideVariableUpdated,
                                RideItemSettingsChanged, RideImportSettingAdded)
from ..utils import overrides, variablematcher
from .basecontroller import ControllerWithParent
from .tags import Tag, ForcedTag, DefaultTag
 
 
class _SettingController(ControllerWithParent):
    def __init__(self, parent_controller, data):
        self._parent_parent_parent = parent_controller
        self._data_data = data
        self.labellabel = self._label_label(self._data_data)
        self._init(self._data_data)
 
    def _label(self, data):
        label = data.setting_name
        if label.startswith('['):
            return label[1:-1]
        return label
 
    @property
    _value = property
    
    def _value(self):
        return [v.replace('|', '\\|') for v in self.as_listas_list()[1:]]
 
    @property
    value = property
    
    def value(self):
        value = self._value_value_value
        if self._data_data.comment:
            value.pop()
        return ' | '.join(value)
 
    @property
    display_value = property
    
    def display_value(self):
        return ' | ' .join(self._value_value_value)
 
    def as_list(self):
        # print(f"\nDEBUG: _SettingController enter as_list")
        return self._data_data.as_list()
 
    @property
    comment = property
    
    def comment(self):
        return self._data_data.comment
 
    @property
    keyword_name = property
    
    def keyword_name(self):
        return ''
 
    def contains_keyword(self, name):
        istring = isinstance(name, str)
        matcher = name.match if not istring else lambda i: utils.eq(i, name)
        return self._contains_keyword_contains_keyword(matcher)
 
    def _contains_keyword(self, matcher_function):
        return any(matcher_function(item or '') for item in self.as_listas_list())
 
    def contains_variable(self, name):
        return variablematcher.value_contains_variable(self.valuevaluevalue, name)
 
    @property
    is_set = property
    
    def is_set(self):
        return self._data_data.is_set()
 
    def set_from(self, other):
        if other.is_set:
            self.set_valueset_value(other.value)
        self.set_commentset_comment(other.comment)
 
    def set_value(self, value):
        if self._changed_changed(value):
            self._set_set(value)
            self.mark_dirtymark_dirty()
            RideItemSettingsChanged(item=self._parent_parent_parent).publish()
 
    def set_comment(self, comment):
        if comment != self.commentcommentcomment:
            if not isinstance(comment, robotapi.Comment):
                comment = robotapi.Comment(comment)
            self._data_data.comment = comment
            self.mark_dirtymark_dirty()
 
    def notify_value_changed(self):
        self._parent_parent_parent.notify_settings_changed()
 
    def clear(self):
        self._data_data.reset()
        self.mark_dirtymark_dirty()
 
    def _changed(self, value):
        return value != self._data_data.value
 
    def _set(self, value):
        self._data_data.value = value
 
    def _split_from_separators(self, value):
        return utils.split_value(value)
 
 
class DocumentationController(_SettingController):
    
    _regexps = (re.compile(r'(\\+)r\\n'),
                re.compile(r'(\\+)n'),
                re.compile(r'(\\+)r'),
                re.compile(r'(\\+) '))
 
    def _init(self, doc):
        self._doc_doc = doc
 
    @property
    value = property
    
    def value(self):
        return self._doc_doc.value
 
    @overrides(_SettingController)
    def contains_keyword(self, name):
        return False
 
    def _get_editable_value(self):
        return self._unescape_newlines_and_whitespaces_unescape_newlines_and_whitespaces(self.valuevaluevaluevaluevalue)
 
    def _set_editable_value(self, value):
        self.set_valueset_value(self._escape_newlines_and_leading_hash_escape_newlines_and_leading_hash(value))
 
    editable_value = property(_get_editable_value, _set_editable_value)
 
    @property
    visible_value = property
    
    def visible_value(self):
        return utils.html_format(utils.unescape(self.valuevaluevaluevaluevalue))
 
    def _unescape_newlines_and_whitespaces(self, item):
        for regexp in self._regexps_regexps:
            if regexp.pattern.endswith(' '):
                item = regexp.sub(self._whitespace_replacer_whitespace_replacer, item)
            else:
                item = regexp.sub(self._newline_replacer_newline_replacer, item)
        return item
 
    def _whitespace_replacer(self, match):
        return self._replacer_replacer(' ', match)
 
    def _newline_replacer(self, match):
        return self._replacer_replacer(linesep, match)
 
    def _replacer(self, char, match):
        slashes = len(match.group(1))
        if slashes % 2 == 1:
            return '\\' * (slashes - 1) + char
        return match.group()
 
    def _escape_newlines_and_leading_hash(self, item):
        for newline in ('\r\n', '\n', '\r'):
            item = item.replace(newline, '\\n')
        if item.strip().startswith('#'):
            item = '\\' + item
        return item
 
 
class FixtureController(_SettingController):
 
    def _init(self, fixture):
        self._fixture_fixture = fixture
 
    @property
    keyword_name = property
    
    def keyword_name(self):
        return self._fixture_fixture.name
 
    def replace_keyword(self, new_name, old_value=None):
        self._fixture_fixture.name = new_name
        self.mark_dirtymark_dirty()
 
    def _changed(self, value):
        name, args = self._parse_parse(value)
        return self._fixture_fixture.name != name or self._fixture_fixture.args != args
 
    def _set(self, value):
        name, args = self._parse_parse(value)
        self._fixture_fixture.name = name
        self._fixture_fixture.args = args
 
    def _parse(self, value):
        value = self._split_from_separators_split_from_separators(value)
        return (value[0], value[1:]) if value else ('', [])
 
 
class TagsController(_SettingController):
 
    def _init(self, tags):
        self._tags_tags = tags
 
    def empty_tag(self):
        return Tag(None, controller=self)
 
    def _changed(self, value):
        return self._tags_tags.value != self._split_from_separators_split_from_separators(value)
 
    def set_from(self, other):
        if other.is_set and other._tags.value is not None:
            self.set_valueset_value(other.value)
        self.set_commentset_comment(other.comment)
 
    def _set(self, value):
        self._tags_tags.value = self._split_from_separators_split_from_separators(value)
 
    def add(self, tag):
        if self._tags_tags.value is None:
            self._tags_tags.value = []
        tag.set_index(len(self._tags_tags.value))
        self._tags_tags.value.append(tag.name)
 
    def remove(self, tag):
        if tag in self._tags_tags.value:
            self._tags_tags.value.remove(tag)
 
    def __iter__(self):
        forced = self._parent_parent_parent.force_tags
        if self._tags_tags.value is None:
            return chain(forced, self._parent_parent_parent.default_tags).__iter__()
        if len(self._tags_tags.value) == 0:
            return chain(forced, [Tag('', controller=self)])
        own_tags = (Tag(t, index, self)
                    for index, t in enumerate(self._tags_tags.value))
        return chain(forced, own_tags).__iter__()
 
    @property
    is_set = property
    
    def is_set(self):
        return any(self)
 
    @property
    display_value = property
    
    def display_value(self):
        return ' | ' .join(tag.name.replace('|', '\\|') for tag in self)
 
 
class DefaultTagsController(TagsController):
 
    def empty_tag(self):
        return DefaultTag(None, controller=self)
 
    def __iter__(self):
        if self._tags_tags.value is None:
            return [].__iter__()
        return (DefaultTag(t, index, self)
                for index, t in enumerate(self._tags_tags.value)).__iter__()
 
 
class ForceTagsController(TagsController):
 
    def empty_tag(self):
        return ForcedTag(None, controller=self)
 
    def __iter__(self):
        return self._recursive_gather_from_recursive_gather_from(self.parentparentparent, []).__iter__()
 
    def __eq__(self, other):
        if self is other:
            return True
        if other is None:
            return False
        if not isinstance(other, self.__class__):
            return False
        return self._tags_tags_tags == other._tags
 
    def _recursive_gather_from(self, obj, result):
        if obj is None:
            return result
        try:
            force_tags = obj._setting_table.force_tags
            # print(f"DEBUG: SettingsController _recursive_gather_from force_tags={force_tags}")
        except AttributeError:  # In the case of a .resource file, there is no Forced Tags fields
            # print(f"DEBUG: SettingsController _recursive_gather_from resource AttributeError")
            # force_tags = dict(value=None)
            return result
        # print(f"DEBUG: SettingsController _recursive_gather_from force_tags={force_tags}, obj.parent={obj.parent}")
        return self._recursive_gather_from_recursive_gather_from(
            obj.parent,
            self._gather_from_data_gather_from_data(force_tags, obj.force_tags) + result)
 
    def _gather_from_data(self, tags, parent):
        if tags.value is None:
            return []
        # print(f"DEBUG: SettingsController _gather_from_data entry tags={tags.value}")
        return [ForcedTag(t, index, parent)
                for index, t in enumerate(tags.value)]
 
 
class TimeoutController(_SettingController):
 
    def _init(self, timeout):
        self._timeout_timeout = timeout
 
    def _changed(self, value):
        val, msg = self._parse_parse(value)
        return self._timeout_timeout.value != val or self._timeout_timeout.message != msg
 
    def _set(self, value):
        value, message = self._parse_parse(value)
        self._timeout_timeout.value = value
        self._timeout_timeout.message = message
 
    def _parse(self, value):
        parts = value.split('|', 1)
        val = parts[0].strip() if parts else ''
        msg = parts[1].strip() if len(parts) == 2 else ''
        return val, msg
 
 
class TemplateController(_SettingController):
 
    def _init(self, template):
        self._template_template = template
 
    def _set(self, value):
        _SettingController._set(self, value)
        self._parent_parent_parent.notify_steps_changed()
 
    def clear(self):
        _SettingController.clear(self)
        self._parent_parent_parent.notify_steps_changed()
 
    @property
    keyword_name = property
    
    def keyword_name(self):
        return self._template_template.value
 
    def replace_keyword(self, new_name, old_name=None):
        self._template_template.value = new_name
        self.mark_dirtymark_dirty()
 
 
class ArgumentsController(_SettingController):
 
    def _init(self, args):
        self._args_args = args
 
    def _changed(self, value):
        return self._args_args.value != self._split_from_separators_split_from_separators(value)
 
    def _set(self, value):
        self._args_args.value = self._split_from_separators_split_from_separators(value)
        self._parent_parent_parent.notify_settings_changed()
 
    def clear(self):
        _SettingController.clear(self)
        self._parent_parent_parent.notify_settings_changed()
 
 
class ReturnValueController(_SettingController):
 
    def _init(self, return_):
        self._return_return = return_
 
    def _label(self, data):
        return 'Return Value'
 
    def _changed(self, value):
        return self._return_return.value != self._split_from_separators_split_from_separators(value)
 
    def _set(self, value):
        self._return_return.value = self._split_from_separators_split_from_separators(value)
 
 
class MetadataController(_SettingController):
 
    def _init(self, meta):
        self._meta_meta = meta
 
    @property
    name = property
    
    def name(self):
        return self._meta_meta.name
 
    @property
    value = property
    
    def value(self):
        return self._meta_meta.value
 
    def set_value(self, name, value):
        self._meta_meta.name = name
        self._meta_meta.value = value
        self._parent_parent_parent.mark_dirty()
 
 
class VariableController(_SettingController):
 
    def _init(self, var):
        self._var_var = var
 
    def _label(self, data):
        return ''
 
    def __ne__(self, other):
        return not (self == other)
 
    @property
    name = property
    
    def name(self):
        return self._var_var.name
 
    @property
    value = property
    
    def value(self):
        return self._var_var.value
 
    @property
    comment = property
    
    def comment(self):
        return self._var_var.comment
 
    @property
    data = property
    
    def data(self):
        return self._data_data
 
    @property
    index = property
    
    def index(self):
        return self.parentparentparent.index(self)
 
    def set_value(self, name, value):
        if isinstance(value, str):
            value = [value]
        self._var_var.name = name
        self._var_var.value = value
        self._parent_parent_parent.mark_dirty()
 
    def has_data(self):
        return self._data_data.has_data()
 
    def delete(self):
        self._parent_parent_parent.remove_var(self)
 
    def notify_value_changed(self):
        RideVariableUpdated(item=self).publish()
 
    def notify_variable_added(self):
        self.parentparentparent.notify_variable_added(self)
 
    def validate_name(self, new_name):
        if variablematcher.is_scalar_variable(self.namenamename):
            return self.parentparentparent.validate_scalar_variable_name(new_name, self)
        if variablematcher.is_dict_variable(self.namenamename):
            return self.parentparentparent.validate_dict_variable_name(new_name, self)
        return self.parentparentparent.validate_list_variable_name(new_name, self)
 
    def move_up(self):
        return self._parent_parent_parent.move_up(self.indexindexindex)
 
    def move_down(self):
        return self._parent_parent_parent.move_down(self.indexindexindex)
 
    def __eq__(self, other):
        if self is other:
            return True
        if other.__class__ != self.__class__:
            return False
        return self._var_var == other._var
 
    def __hash__(self):
        return hash(self._var_var) + 1
 
 
def ImportController(parent, import_):
    if import_.type == 'Resource':
        return ResourceImportController(parent, import_)
    elif import_.type == 'Library':
        return LibraryImportController(parent, import_)
    return VariablesImportController(parent, import_)
 
 
class _ImportController(_SettingController):
 
    def _init(self, import_):
        self._import_import = import_
        self.typetype = self._import_import.type
 
    def _label(self, data):
        return data.type
 
    @property
    name = property
    
    def name(self):
        return self._import_import.name
 
    @property
    alias = property
    
    def alias(self):
        return self._import_import.alias or ''
 
    @property
    args = property
    
    def args(self):
        return self._import_import.args or []
 
    @property
    display_value = property
    
    def display_value(self):
        value = self.argsargsargs + (['WITH NAME', self.aliasaliasalias] if self.aliasaliasalias else [])
        return ' | '.join(value)
 
    @property
    dirty = property
    
    def dirty(self):
        return self._parent_parent_parent.dirty
 
    def has_error(self):
        return False
 
    def get_imported_controller(self):
        return None
 
    def set_value(self, name, args=None, alias=''):
        self._import_import.name = name
        self._import_import.args = utils.split_value(args or [])
        self._import_import.alias = alias
        self._parent_parent_parent.mark_dirty()
        self.publish_editedpublish_edited()
        self.import_loaded_or_modifiedimport_loaded_or_modified()
        return self
 
    def import_loaded_or_modified(self):
        self._parent_parent_parent.notify_imports_modified()
        if not self.is_resource:
            return
        self._parent_parent_parent.resource_import_modified(self.namenamename)
 
    def remove(self):
        self.parentparentparent.remove_import_data(self._import_import)
 
    def publish_added(self):
        RideImportSettingAdded(
            datafile=self.datafile_controllerdatafile_controllerdatafile_controller,
            import_controller=self, type=self.typetype.lower()).publish()
 
    def publish_edited(self):
        RideImportSettingChanged(
            datafile=self.datafile_controllerdatafile_controllerdatafile_controller,
            import_controller=self, type=self.typetype.lower()).publish()
 
    def publish_removed(self):
        RideImportSettingRemoved(datafile=self.datafile_controllerdatafile_controllerdatafile_controller,
                                 import_controller=self,
                                 type=self.typetype.lower()).publish()
 
 
class ResourceImportController(_ImportController):
    is_resource = True
    
    _resolved_import = False
    
    _previous_imported_controller = None
 
    def set_value(self, name, args=None, alias=''):
        self._previous_imported_controller_previous_imported_controller = self.get_imported_controllerget_imported_controllerget_imported_controller()
        self.unresolveunresolve()
        _ImportController.set_value(self, name, args, alias)
 
    def get_imported_controller(self):
        if not self._resolved_import_resolved_import_resolved_import:
            self._imported_resource_controller_imported_resource_controller = \
                self.parentparentparent.resource_file_controller_factory.find_with_import(
                    self._import_import)
            if self._imported_resource_controller_imported_resource_controller:
                self._imported_resource_controller_imported_resource_controller.add_known_import(self)
            self._resolved_import_resolved_import_resolved_import = True
        return self._imported_resource_controller_imported_resource_controller
 
    @overrides(_ImportController)
    def has_error(self):
        # un-resolve before checking import errors
        self.unresolveunresolve()
        return self.get_imported_controllerget_imported_controllerget_imported_controller() is None
 
    @overrides(_ImportController)
    def publish_added(self):
        # Resolve the import <-> ResourceFileController link
        self.get_imported_controllerget_imported_controllerget_imported_controller()
        _ImportController.publish_added(self)
 
    @overrides(_ImportController)
    def publish_removed(self):
        self._previous_imported_controller_previous_imported_controller = self.get_imported_controllerget_imported_controllerget_imported_controller()
        # Unresolve the import <-> ResourceFileController link
        self.unresolveunresolve()
        self._prevent_resolve_prevent_resolve()
        _ImportController.publish_removed(self)
 
    def _prevent_resolve(self):
        self._resolved_import_resolved_import_resolved_import = True
        self._imported_resource_controller_imported_resource_controller = None
 
    def get_previous_imported_controller(self):
        return self._previous_imported_controller_previous_imported_controller
 
    def unresolve(self):
        if self._resolved_import_resolved_import_resolved_import and self._imported_resource_controller_imported_resource_controller:
            self._imported_resource_controller_imported_resource_controller.remove_known_import(self)
        self._resolved_import_resolved_import_resolved_import = False
 
    def contains_filename(self, filename):
        return self.namenamename.endswith(filename)
 
    def change_name(self, old_name, new_name):
        if self.contains_filenamecontains_filename(old_name):
            self.set_valueset_valueset_valueset_value(self.namenamename[:-len(old_name)] + new_name)
        else:
            # If original result has changed and this import relies on
            # variables, can't know if import is still resolved
            self.unresolveunresolve()
 
    def change_format(self, format):
        if self._has_format_has_format():
            self.set_valueset_valueset_valueset_value(utils.replace_extension(self.namenamename, format))
        else:
            self.unresolveunresolve()
 
    def _has_format(self):
        parts = self.namenamename.rsplit('.', 1)
        if len(parts) == 1:
            return False
        return parts[-1].lower() in ['html', 'txt', 'tsv', 'robot', 'resource']
 
 
class LibraryImportController(_ImportController):
    is_resource = False
 
    @overrides(_ImportController)
    def has_error(self):
        return not self.parentparentparent.parent.is_library_import_ok(self._data_data)
 
 
class VariablesImportController(_ImportController):
    is_resource = False
 
    @overrides(_ImportController)
    def has_error(self):
        return not self.parentparentparent.parent.is_variables_import_ok(self._data_data)