filecontrollers.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 os
import shutil
import stat
import sys
from itertools import chain
try:
    import subprocess32 as subprocess
except ImportError:
    import subprocess
from .dataloader import ExcludedDirectory, TestData
from ..publish import (RideDataFileRemoved, RideInitFileRemoved, RideDataChangedToDirty, RideDataDirtyCleared,
                       RideSuiteAdded, RideItemSettingsChanged)
from ..publish.messages import RideDataFileSet, RideOpenResource
from ..robotapi import TestDataDirectory, TestCaseFile, ResourceFile
from .. import utils
 
from .basecontroller import WithUndoRedoStacks, _BaseController, WithNamespace, ControllerWithParent
from .robotdata import NewTestCaseFile, NewTestDataDirectory
from ..utils import overrides
from .settingcontrollers import (DocumentationController, FixtureController, TimeoutController, TemplateController,
                                 DefaultTagsController, ForceTagsController)
from .tablecontrollers import (VariableTableController, TestCaseTableController, KeywordTableController,
                               ImportSettingsController, MetadataListController)
from .macrocontrollers import TestCaseController, UserKeywordController
 
 
def _get_controller(project, data, parent):
    if isinstance(data, TestCaseFile):
        return TestCaseFileController(data, project, parent)
    if isinstance(data, ExcludedDirectory):
        return ExcludedDirectoryController(data, project, parent)
    if isinstance(data, ResourceFile):
        from ..controller.project import Project
        from ..namespace import Namespace
        import tempfile
        if not data.parent:
            data.parent = Project(Namespace(data._settings), data._settings)
            content= bytes(f"*** Settings ***\nResource    {data.source}\n\n*** Test Cases ***\nEmpty\n  No Operation\n",
                           encoding='utf-8')
            stub = tempfile.NamedTemporaryFile(delete=False)
            with stub:
                stub.write(content)
            data.parent.load_data(stub.name)
        return TestCaseFileController(data, project, data.parent)  # DEBUG Here we create a dummy Project
    return TestDataDirectoryController(data, project, parent)
 
 
def DataController(data, project, parent=None):
    return _get_controller(project, data, parent)
 
 
class _FileSystemElement():
 
    def __init__(self, filename, directory):
        self.filenamefilename = filename
        self.directorydirectory = directory
        self._stat_stat = self._get_stat_get_stat(filename)
 
    def _get_stat(self, path):
        if path and os.path.isfile(path):
            stat = os.stat(path)
            return stat.st_mtime, stat.st_size
        return 0, 0
 
    def refresh_stat(self):
        self._stat_stat = self._get_stat_get_stat(self.filenamefilename)
 
    def has_been_modified_on_disk(self):
        return self._get_stat_get_stat(self.filenamefilename) != self._stat_stat
 
    def has_been_removed_from_disk(self):
        return self._stat_stat != (0, 0) and not self.existsexists()
 
    def relative_path_to(self, other):
        other_path = os.path.join(other.directory, other.filename)
        return os.path.relpath(other_path, start=self.directorydirectory).replace('\\', '/')
 
    def is_readonly(self):
        return not os.access(self.filenamefilename, os.W_OK)
 
    def exists(self):
        return self.filenamefilename and os.path.isfile(self.filenamefilename)
 
    @property
    basename = property
    
    def basename(self):
        return os.path.splitext(os.path.basename(self.filenamefilename))[0]
 
    @property
    
    source = property
    
    def source(self):
        # Todo: remove when backwards compatibility with plugin API can break
        return self.filenamefilename or self.directorydirectory
 
 
class _DataController(_BaseController, WithUndoRedoStacks, WithNamespace):
 
    def __init__(self, data, project=None, parent=None):
        self._project_project = project
        if project:
            self._set_namespace_from_set_namespace_from(project)
            self._resource_file_controller_factory_resource_file_controller_factory =\
                project.resource_file_controller_factory
        else:
            self._resource_file_controller_factory_resource_file_controller_factory = None
        self.parentparent = parent
        self.set_datafileset_datafile(data)
        self.dirtydirty = False
        self.childrenchildren = self._children_children(data)
        # Filename needs to be set when creating a new datafile
        if hasattr(self.datadata, 'initfile'):
            self.filenamefilename = self.datadata.initfile
        else:
            self.filenamefilename = self.datadata.source
 
    def set_datafile(self, datafile):
        self.datadata = datafile
        self._variables_table_controller_variables_table_controller = None
        self._testcase_table_controller_testcase_table_controller = None
        self._keywords_table_controller_keywords_table_controller = None
        self._imports_imports = None
        RideDataFileSet(item=self).publish()
 
    def _children(self, data):
        return []
 
    @property
    name = property
    
    def name(self):
        return self.datadata.name
 
    @property
    settings = property
    
    def settings(self):
        return self._settings_settings()
 
    def _settings(self):
        ss = self.datadata.setting_table
        return [DocumentationController(self, ss.doc),
                FixtureController(self, ss.suite_setup),
                FixtureController(self, ss.suite_teardown),
                FixtureController(self, ss.test_setup),
                FixtureController(self, ss.test_teardown),
                self.force_tagsforce_tagsforce_tags]
 
    @property
    _setting_table = property
    
    def _setting_table(self):
        return self.datadata.setting_table
 
    @property
    force_tags = property
    
    def force_tags(self):
        return ForceTagsController(self, self._setting_table_setting_table_setting_table.force_tags)
 
    @property
    variables = property
    
    def variables(self):
        if self._variables_table_controller_variables_table_controller is None:
            self._variables_table_controller_variables_table_controller = VariableTableController(self, self.datadata.variable_table)
        return self._variables_table_controller_variables_table_controller
 
    @property
    tests = property
    
    def tests(self):
        if self._testcase_table_controller_testcase_table_controller is None:
            self._testcase_table_controller_testcase_table_controller = TestCaseTableController(self, self.datadata.testcase_table)
        return self._testcase_table_controller_testcase_table_controller
 
    @property
    datafile = property
    
    def datafile(self):
        return self.datadata
 
    @property
    datafiles = property
    
    def datafiles(self):
        return chain([self], (df for df in self._project_project.datafiles
                              if df != self))
 
    @property
    datafile_controller = property
    
    def datafile_controller(self):
        return self
 
    @property
    keywords = property
    
    def keywords(self):
        if self._keywords_table_controller_keywords_table_controller is None:
            self._keywords_table_controller_keywords_table_controller = KeywordTableController(self, self.datadata.keyword_table)
        return self._keywords_table_controller_keywords_table_controller
 
    @property
    imports = property
    
    def imports(self):
        if not self._imports_imports:
            self._imports_imports = ImportSettingsController(self, self.datadata.setting_table,
                                    self._resource_file_controller_factory_resource_file_controller_factory)
        return self._imports_imports
 
    @property
    metadata = property
    
    def metadata(self):
        return MetadataListController(self, self.datadata.setting_table)
 
    def is_user_keyword(self, value):
        return WithNamespace.is_user_keyword(self, self.datafiledatafiledatafile, value)
 
    def is_library_keyword(self, value):
        return WithNamespace.is_library_keyword(self, self.datafiledatafiledatafile, value)
 
    def keyword_info(self, keyword_name):
        return WithNamespace.keyword_info(self, self.datadata, keyword_name)
 
    def mark_dirty(self):
        if not self.dirtydirty:
            self.dirtydirty = True
            RideDataChangedToDirty(datafile=self).publish()
 
    def unmark_dirty(self):
        self.refresh_stat()
        if self.dirtydirty:
            self.dirtydirty = False
            # print(f"DEBUG: filecontrollers unmark_dirty PUBLISH RideDataDirtyCleared")
            RideDataDirtyCleared(datafile=self).publish()
 
    def create_keyword(self, name, argstr=''):
        return self.keywordskeywordskeywords.new(name, argstr)
 
    def add_test_or_keyword(self, item):
        if isinstance(item, TestCaseController):
            self.teststeststests.add(item)
            item.set_parent(self.teststeststests)
        elif isinstance(item, UserKeywordController):
            self.keywordskeywordskeywords.add(item)
            item.set_parent(self.keywordskeywordskeywords)
        else:
            self.variablesvariablesvariables.add_variable(item.name, item.value, item.comment)
 
    def sort_tests(self):
        if self.teststeststests:
            index_difference = self.teststeststests.sort()
            self.mark_dirtymark_dirty()
            RideDataFileSet(item=self).publish()
            return index_difference
        return None
 
    def sort_keywords(self):
        if self.keywordskeywordskeywords:
            index_difference = self.keywordskeywordskeywords.sort()
            self.mark_dirtymark_dirty()
            RideDataFileSet(item=self).publish()
            return index_difference
        return None
 
    def sort_variables(self):
        if self.variablesvariablesvariables:
            index_difference = self.variablesvariablesvariables.sort()
            self.mark_dirtymark_dirty()
            RideDataFileSet(item=self).publish()
            return index_difference
        return None
 
    def restore_test_order(self, index_difference):
        if self.teststeststests and index_difference:
            self.teststeststests.restore_test_order(index_difference)
            self.mark_dirtymark_dirty()
            RideDataFileSet(item=self).publish()
 
    def restore_keyword_order(self, index_difference):
        if self.keywordskeywordskeywords and index_difference:
            self.keywordskeywordskeywords.restore_keyword_order(index_difference)
            self.mark_dirtymark_dirty()
            RideDataFileSet(item=self).publish()
 
    def restore_variable_order(self, index_difference):
        if self.variablesvariablesvariables and index_difference:
            self.variablesvariablesvariables.restore_variable_order(index_difference)
            self.mark_dirtymark_dirty()
            RideDataFileSet(item=self).publish()
 
    def get_keyword_names(self):
        if self.keywordskeywordskeywords:
            return [kw.name for kw in self.keywordskeywordskeywords._items]
        return None
 
    def has_format(self):
        return True
 
    def get_format(self):
        if not self.filenamefilename:
            return None
        return os.path.splitext(self.filenamefilename)[1].replace('.', '')
 
    def set_format(self, format):
        self.datadata.source = utils.replace_extension(self.filenamefilename, format)
        self.filenamefilename = self.datadata.source
 
    def is_same_format(self, format):
        if format and self.has_formathas_format():
            return format.lower() == self.get_formatget_format().lower()
        return False
 
    def set_basename(self, basename):
        from .ctrlcommands import SaveFile
 
        old_file = self.filenamefilename
        self.datadata.source = os.path.join(self.directory, '%s.%s' % (basename, self.get_formatget_format()))
        self.filenamefilename = self.datadata.source
        self.executeexecute(SaveFile())
        if old_file != self.filenamefilename:
            self.remove_from_filesystemremove_from_filesystem(old_file)
 
    def remove_readonly(self, path=None):
            path = path or self.filenamefilename
            os.chmod(path, stat.S_IWRITE)
 
    def open_filemanager(self, path=None):
        # tested on Win7 x64
        path = path or self.filenamefilename
        if os.path.exists(path):
            if sys.platform == 'win32':
                #  There was encoding errors if directory had unicode chars
                # TODO test on all OS directory names with accented chars, for example 'ccedilla'
                os.startfile(r"%s" % os.path.dirname(path), 'explore')
            elif sys.platform.startswith('linux'):
                # how to detect which explorer is used?
                # nautilus, dolphin, konqueror
                # TODO check if explorer exists
                # TODO get prefered explorer from preferences
                try:
                    subprocess.Popen(["nautilus", "{}".format(
                        os.path.dirname(path))])
                except OSError or FileNotFoundError:
                    try:
                        subprocess.Popen(
                            ["dolphin", "{}".format(os.path.dirname(path))])
                    except OSError or FileNotFoundError:
                        try:
                            subprocess.Popen(
                               ["konqueror", "{}".format(
                                   os.path.dirname(path))])
                        except OSError or FileNotFoundError:
                            print("Could not launch explorer. Tried nautilus, "
                                  "dolphin and konqueror.")
            else:
                try:
                    subprocess.Popen(["finder", "{}".format(
                        os.path.dirname(path))])
                except OSError or FileNotFoundError:
                    subprocess.Popen(["open", "{}".format(
                        os.path.dirname(path))])
 
    def remove_from_filesystem(self, path=None):
        path = path or self.filenamefilename
        if os.path.exists(path):
            os.remove(path)
 
    def remove_folder_from_filesystem(self, path=None):
        shutil.rmtree(path or self.datadata.directory)
 
    def save_with_new_format(self, format):
        self._project_project.change_format(self, format)
 
    def save_with_new_format_recursive(self, format):
        self._project_project.change_format_recursive(self, format)
 
    def validate_keyword_name(self, name):
        return self.keywordskeywordskeywords.validate_name(name)
 
    def is_directory_suite(self):
        return False
 
    def resource_import_modified(self, path):
        return self._project_project.resource_import_modified(path, self.directory)
 
    def notify_settings_changed(self):
        RideItemSettingsChanged(item=self).publish()
 
    def notify_steps_changed(self):
        for test in self.teststeststests:
            test.notify_steps_changed()
 
    def iter_datafiles(self):
        yield self
        for child in self.childrenchildren:
            for datafile in child.iter_datafiles():
                yield datafile
 
    def save(self):
        self._project_project.save(self)
 
    def get_local_variables(self):
        return {}
 
    def is_inside_top_suite(self, res):
        return False
 
 
class TestDataDirectoryController(_DataController, _FileSystemElement, _BaseController):
 
    def __init__(self, data, project=None, parent=None):
        dir_ = data.directory
        dir_ = os.path.abspath(dir_) if isinstance(dir_, str) else dir_
        _FileSystemElement.__init__(self, self._filename_filename(data), dir_)
        _DataController.__init__(self, data, project, parent)
        self._dir_controllers_dir_controllers = {}
 
    def _filename(self, data):
        return data.initfile
 
    @property
    default_dir = property
    
    def default_dir(self):
        return self.datadata.source
 
    @property
    display_name = property
    
    def display_name(self):
        return self.datadata.name
 
    @property
    longname = property
    
    def longname(self):
        if self.parentparent:
            return self.parentparent.longname + '.' + self.display_namedisplay_namedisplay_namedisplay_namedisplay_name
        return self.display_namedisplay_namedisplay_namedisplay_namedisplay_name
 
    @property
    suites = property
    
    def suites(self):
        return [child for child in self.childrenchildren if
                    isinstance(child, TestDataDirectoryController) or
                    isinstance(child, TestCaseFileController)]
 
    def add_child(self, child):
        self.childrenchildren.append(child)
 
    def contains_tests(self):
        for suite in self.suitessuitessuites:
            if suite.contains_tests():
                return True
        return False
 
    def find_controller_by_longname(self, longname, testname = None):
        return self.find_controller_by_namesfind_controller_by_names(longname.split("."), testname)
 
    def find_controller_by_names(self, names, testname):
        namestring = '.'.join(names)
        if not namestring.startswith(self.namenamename):
            return None
        if namestring == self.namenamename:
            return self
        for suite in self.suitessuitessuites:
            res = suite.find_controller_by_names(namestring[len(self.namenamename)+1:].split('.'), testname)
            if res:
                return res
 
    def is_excluded(self):
        return self._project_project.is_excluded(self.sourcesourcesource) if self._project_project else False
 
    def _children(self, data):
        children = [DataController(child, self._project_project, self) for child in data.children]
        if self._can_add_directory_children_can_add_directory_children(data):
            self._add_directory_children_add_directory_children(children, data.source, data.initfile)
        return children
 
    def _can_add_directory_children(self, data):
        return data.source and os.path.isdir(data.source) and self._namespace_namespace
 
    def _add_directory_children(self, children, path, initfile):
        if not children:
            return
        for filename in self._get_unknown_files_in_directory_get_unknown_files_in_directory(children, path, initfile):
            if not self._is_robot_ignored_name_is_robot_ignored_name(filename):
                self._add_directory_child_add_directory_child(children, filename)
 
    def _is_robot_ignored_name(self, filename):
        base = os.path.basename(filename)
        robotformat = (".txt", ".robot", ".resource", ".rst", " .rest", ".tsv", ".htm", ".html")
        nonrobot_file = os.path.isfile(filename) and not base.endswith(robotformat)
        hidden = base.startswith('.')
        private = base.startswith('_')
        return hidden or private or nonrobot_file
 
    def _add_directory_child(self, children, filename):
        if os.path.isdir(filename):
            children.append(self._directory_controller_directory_controller(filename))
        else:
            r = self._namespace_namespace.get_resource(filename, report_status=False)
            if self._is_valid_resource_is_valid_resource(r):
                children.append(self._resource_controller_resource_controller(r))
 
    def _directory_controller(self, path):
        dc = TestDataDirectoryController(TestDataDirectory(source=path),
                                         project=self._project_project,
                                         parent=self)
        self._add_directory_children_add_directory_children(dc.children, dc.source, None)
        return dc
 
    def _is_valid_resource(self, resource):
        return resource and (resource.setting_table or resource.variable_table or
                             resource.keyword_table or os.stat(resource.source)[6] == 0)
 
    def _resource_controller(self, resource):
        resource_control = self._resource_file_controller_factory_resource_file_controller_factory.create(resource)
        resource_control.parent = self
        return resource_control
 
    def _get_unknown_files_in_directory(self, children, path, initfile):
        already_in_use = [c.filename for c in children] + [initfile]
        already_in_use += [c.directory for c in children]
        return [f for f in self._get_filenames_in_directory_get_filenames_in_directory(path) if f not in already_in_use]
 
    def _get_filenames_in_directory(self, path):
        return [os.path.join(path, f) for f in os.listdir(path)]
 
    def add_child(self, controller):
        assert controller not in self.childrenchildren
        self.childrenchildren.append(controller)
 
    def has_format(self):
        return self.datadata.initfile is not None
 
    def set_format(self, format):
        self.datadata.initfile = os.path.join(self.datadata.source, '__init__.%s'
                                          % format.lower())
        self.filenamefilenamefilenamefilename = self.datadata.initfile
 
    def new_test_case_file(self, path):
        ctrl = self._new_data_controller_new_data_controller(NewTestCaseFile(path))
        ctrl.mark_dirty()
        return ctrl
 
    def new_test_data_directory(self, path):
        return self._new_data_controller_new_data_controller(NewTestDataDirectory(path))
 
    def _new_data_controller(self, datafile):
        self.datadata.children.append(datafile)
        datafile.parent = self.datadata
        self.childrenchildren.append(DataController(datafile, self._project_project, self))
        return self.childrenchildren[-1]
 
    def notify_suite_added(self, suite):
        RideSuiteAdded(parent=self, suite=suite).publish()
 
    def is_directory_suite(self):
        return True
 
    def reload(self):
        self.__init____init____init____init__(TestDataDirectory(source=self.directorydirectory, parent=self.datadata.parent).populate(),
                      self._project_project, parent=self.parentparent)
 
    def remove(self):
        path = self.filenamefilenamefilenamefilename
        self.datadata.initfile = None
        self._stat_stat_stat = self._get_stat_get_stat(None)
        self.reloadreload()
        RideInitFileRemoved(path=path, datafile=self).publish()
 
    def _remove_resources(self):
        for resource in self._find_resources_recursively_find_resources_recursively(self):
            self._project_project.remove_resource(resource)
            RideDataFileRemoved(path=resource.filename, datafile=resource).publish()
 
    def remove_from_model(self):
        self._project_project.remove_datafile(self)
        self._remove_resources_remove_resources()
        RideDataFileRemoved(path=self.filenamefilenamefilenamefilename, datafile=self).publish()
 
    def remove_child(self, controller):
        if controller in self.childrenchildren:
            self.childrenchildren.remove(controller)
        else:
            for child in self.childrenchildren:
                child.remove_child(controller)
 
    def is_inside_top_suite(self, ctrl):
        return ctrl.filename.startswith(self.directorydirectory)
 
    def _is_inside_test_data_directory(self, directory):
        return any(True for s in [self] + self.childrenchildren
                   if s.is_directory_suite() and s.directory == directory)
 
    def remove_static_imports_to_this(self):
        for resource_import in self.get_where_usedget_where_used():
            resource_import[1].remove()
 
    def get_where_used(self):
        for imp in self._get_recursive_imports_get_recursive_imports():
            yield imp
 
    def _all_imports(self):
        for df in self.datafilesdatafilesdatafiles:
            for imp in df.imports:
                yield imp
 
    def _get_recursive_imports(self):
        all_imports = self._all_imports_all_imports()
        ctrls = self._find_controllers_recursively_find_controllers_recursively(self)
        for res in self._find_resources_recursively_find_resources_recursively(self):
            for imp in all_imports:
                if imp.get_imported_controller() == res and imp.parent.parent not in ctrls:
                    yield res, imp
 
    def _find_resources_recursively(self, controller):
        resources = []
        if controller.children:
            for child in controller.children:
                resources += self._find_resources_recursively_find_resources_recursively(child)
        elif isinstance(controller, ResourceFileController):
            resources.append(controller)
        return resources
 
    def _find_controllers_recursively(self, controller):
        resources = []
        if controller.children:
            for child in controller.children:
                resources += self._find_controllers_recursively_find_controllers_recursively(child)
        resources.append(controller)
        return resources
 
    def insert_to_test_data_directory(self, res):
        res_dir = os.path.dirname(res.filename)
        if res_dir in self._dir_controllers_dir_controllers:
            self._dir_controllers_dir_controllers[res_dir].add_child(res)
        else:
            target = self._find_closest_directory_find_closest_directory(res)
            if target is self:
                self._create_target_dir_controller_create_target_dir_controller(res, res_dir, target)
            else:
                target.insert_to_test_data_directory(res)
 
    def _find_closest_directory(self, res):
        target = self
        for s in self.iter_datafilesiter_datafiles():
            if not isinstance(s, TestDataDirectoryController):
                continue
            if res.filename.startswith(s.directory):
                target = s
        return target
 
    def _create_target_dir_controller(self, res, res_dir, target):
        for dirname in res_dir[len(self.directorydirectory):].split(os.sep):
            if not dirname:
                continue
            target_dir = os.path.join(target.directory, dirname)
            dir_ctrl = TestDataDirectoryController(TestDataDirectory(source=target_dir),
                                                   self._project_project, self)
            target._dir_controllers[target.directory] = dir_ctrl
            target.add_child(dir_ctrl)
            if target_dir == res_dir:
                dir_ctrl.add_child(res)
                return
            target = dir_ctrl
        if res not in self.childrenchildren:
            self.add_childadd_childadd_child(res)
 
    def new_resource(self, path):
        ctrl = self._project_project.new_resource(path, parent=self)
        ctrl.mark_dirty()
        return ctrl
 
    def exclude(self):
        if self._project_project.is_datafile_dirty(self):
            raise DirtyRobotDataException()
        self._project_project._settings.excludes.update_excludes([self.directorydirectory])
        index = self.parentparent.children.index(self)
        result = ExcludedDirectoryController(self.datadata, self._project_project, self.parentparent)
        self.parentparent.children[index] = result
        return result
 
    def retrieve_test_controllers(self):
        controllers: list[TestCaseController] = []
        for child in self.childrenchildren:
            if isinstance(child,TestCaseFileController) or isinstance(child,TestDataDirectoryController):
                controllers += child.retrieve_test_controllers()
        return controllers
 
 
 
class DirtyRobotDataException(Exception):
    pass
 
 
class TestCaseFileController(_FileSystemElement, _DataController):
 
    def __init__(self, data, project=None, parent=None):
        _FileSystemElement.__init__(self, data.source if data else None, data.directory)
        _DataController.__init__(self, data, project, parent)
 
    def _settings(self):
        ss = self._setting_table_setting_table_setting_table
        sett = _DataController._settings(self)
        sett.insert(-1, TemplateController(self, ss.test_template))
        sett.insert(-1, TimeoutController(self, ss.test_timeout))
        return sett + [self.default_tagsdefault_tagsdefault_tags]
 
    @property
    longname = property
    
    def longname(self):
        if self.parentparent:
            return self.parentparent.longname + '.' + self.namenamename
        return self.namenamename
 
    @property
    suites = property
    
    def suites(self):
        return ()
 
    def contains_tests(self):
        return bool(self.teststeststests)
 
    def find_controller_by_longname(self, longname, node_testname = None):
        return self.find_controller_by_namesfind_controller_by_names(longname.split("."), node_testname)
 
    def find_controller_by_names(self, names, node_testname = None):
        names = '.'.join(names)
        if not names.startswith(self.namenamename):
            return None
        if len(self.namenamename) < len(names) and not names.startswith(self.namenamename+'.'):
            return None
        if len(names) == 1:
            return self
        for test in self.teststeststests:
            if test.name == node_testname:
                return test
        return None
 
    @property
    default_tags = property
    
    def default_tags(self):
        return DefaultTagsController(self, self._setting_table_setting_table_setting_table.default_tags)
 
    def is_modifiable(self):
        return not self.existsexists() or not self.is_readonlyis_readonly()
 
    def create_test(self, name):
        return self.teststeststests.new(name)
 
    def validate_test_name(self, name):
        return self.teststeststests.validate_name(name)
 
    def remove_child(self, controller):
        if controller is self:
            self.removeremove()
 
    def remove(self):
        self._project_project.remove_datafile(self)
        RideDataFileRemoved(path=self.filenamefilenamefilename, datafile=self).publish()
 
    def reload(self):
        self.__init____init____init____init__(TestCaseFile(parent=self.datadata.parent, source=self.filenamefilenamefilename).populate(),
                      project=self._project_project,
                      parent=self.parentparent)
 
    def get_template(self):
        return self.datadata.setting_table.test_template
 
    def retrieve_test_controllers(self) :
        controllers = []
        for test_ctrl in iter(self.teststeststests):
            controllers.append(test_ctrl)
        return controllers
 
 
class ResourceFileControllerFactory():
 
    def __init__(self, namespace, project):
        self._resources_resources = []
        self._namespace_namespace = namespace
        self._project_project = project
        self._all_resource_imports_resolved_all_resource_imports_resolved = False
 
    @property
    resources = property
    
    def resources(self):
        return self._resources_resources
 
    def find(self, data):
        return self._find_with_source_find_with_source(data.source)
 
    def _find_with_source(self, source):
        for other in self.resourcesresourcesresources:
            if other.filename == source:
                return other
        return None
 
    def find_with_import(self, import_):
        resource_model = self._namespace_namespace.find_resource_with_import(import_)
        if not resource_model:
            return None
        res = self.findfind(resource_model)
        if not res:
            res = self.createcreate(resource_model)
            self._project_project.insert_into_suite_structure(res)
        assert(res is not None)
        return res
 
    def create(self, data, parent=None):
        rfc = ResourceFileController(data, self._project_project, parent, self)
        self.resourcesresourcesresources.append(rfc)
        self.set_all_resource_imports_unresolvedset_all_resource_imports_unresolved()
        return rfc
 
    def set_all_resource_imports_resolved(self):
        self._all_resource_imports_resolved_all_resource_imports_resolved = True
 
    def set_all_resource_imports_unresolved(self):
        self._all_resource_imports_resolved_all_resource_imports_resolved = False
 
    def is_all_resource_file_imports_resolved(self):
        return self._all_resource_imports_resolved_all_resource_imports_resolved
 
    def remove(self, controller):
        self._resources_resources.remove(controller)
        self.set_all_resource_imports_unresolvedset_all_resource_imports_unresolved()
 
 
class ResourceFileController(_FileSystemElement, _DataController):
 
    def __init__(self, data, project=None, parent=None, resource_file_controller_factory=None):
        if resource_file_controller_factory:
            self._resource_file_controller_factory_resource_file_controller_factory_resource_file_controller_factory = resource_file_controller_factory
        else:
            self._resource_file_controller_factory_resource_file_controller_factory_resource_file_controller_factory = ResourceFileControllerFactory(self._namespace_namespace, project)
        self._known_imports_known_imports = set()
        _FileSystemElement.__init__(self, data.source if data else None, data.directory)
        _DataController.__init__(self, data, project,
                                 parent or self._find_parent_for_find_parent_for(project, data.source))
        if self.parentparent and self not in self.parentparent.children:
            self.parentparent.add_child(self)
        self._unresolve_all_if_none_existing_unresolve_all_if_none_existing()
 
    def _unresolve_all_if_none_existing(self):
        if not self.existsexists() and self._resource_file_controller_factory_resource_file_controller_factory_resource_file_controller_factory:
            self._resource_file_controller_factory_resource_file_controller_factory_resource_file_controller_factory.set_all_resource_imports_unresolved()
            # Some import may have referred to this none existing resource
 
    def _find_parent_for(self, project, source):
        if not project:
            return None
        dir = os.path.dirname(source)
        for ctrl in project.datafiles:
            if ctrl.is_directory_suite() and self._to_os_style_to_os_style(ctrl.directory) == dir:
                return ctrl
        return None
 
    def _to_os_style(self, path):
        return path.replace('/', os.sep)
 
    @property
    display_name = property
    
    def display_name(self):
        _, tail = os.path.split(self.datadata.source)
        return tail
 
    def is_modifiable(self):
        return not self.existsexists() or not self.is_readonlyis_readonly()
 
    def set_format(self, format):
        self._modify_file_name_modify_file_name(lambda: _DataController.set_format(self, format),
                               lambda imp: imp.change_format(format))
 
    def set_basename(self, basename):
        self._modify_file_name_modify_file_name(lambda: _DataController.set_basename(self, basename),
                               lambda imp: imp.unresolve())
 
    def set_basename_and_modify_imports(self, basename):
        old = self.filenamefilenamefilename
        self._modify_file_name_modify_file_name(lambda: _DataController.set_basename(self, basename),
                               lambda imp: imp.change_name(os.path.basename(old),
                                                           os.path.basename(self.filenamefilenamefilename)))
 
    def remove_static_imports_to_this(self):
        name = os.path.basename(self.filenamefilenamefilename)
        # have to resolve imports before deleting
        # see: http://code.google.com/p/robotframework-ride/issues/detail?id=1119
        imports = [import_ for import_ in self.get_where_usedget_where_used()]
        for resource_import in imports:
            if resource_import.name.endswith(name):
                resource_import.remove()
 
    def _modify_file_name(self, modification, notification):
        old = self.filenamefilenamefilename
        modification()
        resource_imports = [resource_import_ for resource_import_ in self.get_where_usedget_where_used()]
        for resource_import in resource_imports:
            notification(resource_import)
        self._namespace_namespace.resource_filename_changed(old, self.filenamefilenamefilename)
 
    def _settings(self):
        return [DocumentationController(self, self.datadata.setting_table.doc)]
 
    def validate_name(self, name):
        for uk in self.datadata.keyword_table.keywords:
            if uk != name and utils.eq(uk.name, name):
                return 'User keyword with this name already exists.'
        return None
 
    def reload(self):
        self.__init____init____init____init__(ResourceFile(source=self.filenamefilenamefilename).populate(), self._project_project,
                      parent=self.parentparent)
 
    def remove(self):
        self._project_project.remove_resource(self)
        RideDataFileRemoved(path=self.filenamefilenamefilename, datafile=self).publish()
 
    def remove_known_import(self, _import):
        self._known_imports_known_imports.remove(_import)
 
    def add_known_import(self, _import):
        self._known_imports_known_imports.add(_import)
 
    def notify_opened(self):
        RideOpenResource(path=self.filenamefilenamefilename, datafile=self).publish()
        for _import in [imp for imp in self.importsimportsimports if imp.is_resource]:
            _import.import_loaded_or_modified()
 
    def is_used(self):
        if self._known_imports_known_imports:
            return True
        if not self._resource_file_controller_factory_resource_file_controller_factory_resource_file_controller_factory:
            return False
        if self._resource_file_controller_factory_resource_file_controller_factory_resource_file_controller_factory.is_all_resource_file_imports_resolved():
            return False
        return any(self._resolve_known_imports_resolve_known_imports())
 
    def get_where_used(self):
        if self._resource_file_controller_factory_resource_file_controller_factory_resource_file_controller_factory.is_all_resource_file_imports_resolved():
            source = self._known_imports_known_imports
        else:
            source = self._resolve_known_imports_resolve_known_imports()
 
        for usage in source:
            yield usage
 
 
    def _resolve_known_imports(self):
        for imp in self._all_imports_all_imports():
            if imp.get_imported_controller() is self:
                yield imp
        self._resource_file_controller_factory_resource_file_controller_factory_resource_file_controller_factory.set_all_resource_imports_resolved()
 
    def _all_imports(self):
        for df in self.datafilesdatafilesdatafiles:
            for imp in df.imports:
                yield imp
 
    def remove_child(self, controller):
        pass
 
 
class ExcludedDirectoryController(_FileSystemElement, ControllerWithParent, WithNamespace):
 
    def __init__(self, data, project, parent):
        self.datadata = data
        self._project_project = project
        if self._project_project:
            self._set_namespace_from_set_namespace_from(self._project_project)
            self._resource_file_controller_factory_resource_file_controller_factory =\
            self._project_project.resource_file_controller_factory
        else:
            self._resource_file_controller_factory_resource_file_controller_factory = None
        self._parent_parent_parent = parent
        self.childrenchildren = []
        self.keywordskeywords = []
        self.variablesvariables = tuple()
        self.teststests = tuple()
        self.importsimports = tuple()
        _FileSystemElement.__init__(self, '', data.directory)
 
    @property
    settings = property
    
    def settings(self):
        return self._settings_settings()
 
    def _settings(self):
        ss = self.datadata.setting_table
        return [DocumentationController(self, ss.doc),
                FixtureController(self, ss.suite_setup),
                FixtureController(self, ss.suite_teardown),
                FixtureController(self, ss.test_setup),
                FixtureController(self, ss.test_teardown),
                self.force_tagsforce_tagsforce_tags]
 
    @property
    _setting_table = property
    
    def _setting_table(self):
        return self.datadata.setting_table
 
    @property
    force_tags = property
    
    def force_tags(self):
        return ForceTagsController(self, self._setting_table_setting_table_setting_table.force_tags)
 
    @property
    dirty = property
    
    def dirty(self):
        return False
 
    def keyword_info(self, keyword_name):
        return WithNamespace.keyword_info(self, self.datadata, keyword_name)
 
    @overrides(_BaseController)
    def is_excluded(self):
        return True
 
    def remove_from_excludes(self):
        self._project_project._settings.excludes.remove_path(self.sourcesourcesource)
        index = self.parentparentparent.children.index(self)
        td = TestData(self.datadata.source, self.parentparentparent.data, self._project_project._settings)
        result = TestDataDirectoryController(td, self._project_project, self.parentparentparent)
        self.parentparentparent.children[index] = result
        return result
 
    def iter_datafiles(self):
        return [self]
 
    @property
    name = property
    
    def name(self):
        return self.datadata.name
 
    def is_directory_suite(self):
        return True
 
    def add_child(self, child):
        self.childrenchildren.append(child)