rougail/src/rougail/path.py

"""Manage path to find objects

Created by:
EOLE (http://eole.orion.education.fr)
Copyright (C) 2005-2018

Forked by:
Cadoles (http://www.cadoles.com)
Copyright (C) 2019-2021

distribued with GPL-2 or later license

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
"""
from .i18n import _
from .error import DictConsistencyError
from .config import Config
from .utils import normalize_family


class Path:
    """Helper class to handle the `path` attribute of a CreoleObjSpace
    instance.

    sample: path="creole.general.condition"
    """
    def __init__(self):
        self.variables = {}
        self.families = {}
        self.full_paths_families = {}
        self.full_paths_variables = {}

    # Family
    def add_family(self,
                   namespace: str,
                   name: str,
                   variableobj: str,
                   ) -> str:  # pylint: disable=C0111
        """Add a new family
        """
        if namespace == Config['variable_namespace']:
            full_name = '.'.join([namespace, name])
            self.full_paths_families[name] = full_name
        else:
            if '.' not in name:  # pragma: no cover
                msg = _(f'Variable "{name}" in namespace "{namespace}" must have dot')
                raise DictConsistencyError(msg, 39)
            full_name = name
        if full_name in self.families and \
                self.families[full_name]['variableobj'] != variableobj:  # pragma: no cover
            raise DictConsistencyError(_(f'Duplicate family name "{name}"'), 37)
        self.families[full_name] = dict(name=name,
                                        namespace=namespace,
                                        variableobj=variableobj,
                                        )
        variableobj.path = full_name

    def add_leadership(self,
                       namespace: str,
                       path: str,
                       variableobj: str,
                       ) -> str:  # pylint: disable=C0111
        """add a new leadership
        """
        self.families[path] = dict(name=path,
                                   namespace=namespace,
                                   variableobj=variableobj,
                                   )
        variableobj.path = path

    def get_family(self,
                   name: str,
                   current_namespace: str,
                   ) -> 'Family':  # pylint: disable=C0111
        """Get a family
        """
        name = '.'.join([normalize_family(subname) for subname in name.split('.')])
        if name not in self.families and name in self.full_paths_families:
            name = self.full_paths_families[name]
        if name not in self.families:
            raise DictConsistencyError(_('unknown option {}').format(name), 42)
        dico = self.families[name]
        if current_namespace not in [Config['variable_namespace'], 'services'] and \
                current_namespace != dico['namespace']:
            msg = _(f'A family located in the "{dico["namespace"]}" namespace '
                    f'shall not be used in the "{current_namespace}" namespace')
            raise DictConsistencyError(msg, 38)
        return dico['variableobj']

    # Leadership
    def set_leader(self,
                   namespace: str,
                   leader_family_name: str,
                   leadership_name: str,
                   name: str,
                   ) -> None:  # pylint: disable=C0111
        """set a variable a leadership member
        """
        # need rebuild path and move object in new path
        old_path = leader_family_name + '.' + name
        leadership_path = leader_family_name + '.' + leadership_name
        new_path = leadership_path + '.' + name
        self.variables[new_path] = self.variables.pop(old_path)
        self.variables[new_path]['leader'] = leadership_path
        self.variables[new_path]['variableobj'].path = new_path
        self.variables[new_path]['family'] = leadership_path
        if namespace == Config['variable_namespace']:
            self.full_paths_variables[name] = new_path

    def is_in_leadership(self, name):
        """Is the variable is in a leadership
        """
        return self._get_variable(name)['leader'] is not None

    def is_leader(self, path):  # pylint: disable=C0111
        """Is the variable is a leader
        """
        variable = self._get_variable(path)
        if not variable['leader']:
            return False
        leadership = self.get_family(variable['leader'], variable['variableobj'].namespace)
        return leadership.variable[0].path == path

    # Variable
    def add_variable(self,  # pylint: disable=R0913
                     namespace: str,
                     name: str,
                     family: str,
                     is_dynamic: bool,
                     variableobj,
                     ) -> str:  # pylint: disable=C0111
        """Add a new variable (with path)
        """
        if '.' not in name:
            full_path = '.'.join([family, name])
            if namespace == Config['variable_namespace']:
                self.full_paths_variables[name] = full_path
        else:
            full_path = name
        variableobj.path = full_path
        self.variables[full_path] = dict(name=name,
                                         family=family,
                                         leader=None,
                                         is_dynamic=is_dynamic,
                                         variableobj=variableobj,
                                         )

    def get_variable(self,
                     name: str,
                     ) -> 'Variable':  # pylint: disable=C0111
        """Get variable object from a path
        """
        variable, suffix = self._get_variable(name, with_suffix=True)
        if suffix:
            raise DictConsistencyError(_(f"{name} is a dynamic variable"), 36)
        return variable['variableobj']

    def get_variable_family_path(self,
                                 name: str,
                                 ) -> str:  # pylint: disable=C0111
        """Get the full path of a family
        """
        return self._get_variable(name)['family']

    def get_variable_path(self,
                          name: str,
                          current_namespace: str,
                          ) -> str:  # pylint: disable=C0111
        """get full path of a variable
        """
        dico, suffix = self._get_variable(name,
                                          with_suffix=True,
                                          )
        namespace = dico['variableobj'].namespace
        if namespace not in [Config['variable_namespace'], 'services'] and \
                current_namespace != namespace:
            msg = _(f'A variable located in the "{namespace}" namespace shall not be used '
                    f'in the "{current_namespace}" namespace')
            raise DictConsistencyError(msg, 41)
        return dico['variableobj'].path, suffix

    def path_is_defined(self,
                        path: str,
                        ) -> str:  # pylint: disable=C0111
        """The path is a valid path
        """
        if '.' not in path and path not in self.variables and path in self.full_paths_variables:
            return True
        return path in self.variables

    def variable_is_dynamic(self,
                            name: str,
                            ) -> bool:
        """This variable is in dynamic family
        """
        return self._get_variable(name)['is_dynamic']

    def _get_variable(self,
                      name: str,
                      with_suffix: bool=False,
                      ) -> str:
        name = '.'.join([normalize_family(subname) for subname in name.split('.')])
        if name not in self.variables:
            if '.' not in name and name in self.full_paths_variables:
                name = self.full_paths_variables[name]
            elif with_suffix:
                for var_name, full_path in self.full_paths_variables.items():
                    if name.startswith(var_name):
                        variable = self._get_variable(full_path)
                        if variable['is_dynamic']:
                            return variable, name[len(var_name):]
        if name not in self.variables:
            raise DictConsistencyError(_('unknown option {}').format(name), 42)
        if with_suffix:
            return self.variables[name], None
        return self.variables[name]