rougail/creole/objspace.py

"""
Creole flattener. Takes a bunch of Creole XML dispatched in differents folders
as an input and outputs a human readable flatened XML

Sample usage::

    >>> from creole.objspace import CreoleObjSpace
    >>> eolobj = CreoleObjSpace('/usr/share/creole/creole.dtd')
    >>> eolobj.create_or_populate_from_xml('creole', ['/usr/share/eole/creole/dicos'])
    >>> eolobj.space_visitor()
    >>> eolobj.save('/tmp/creole_flatened_output.xml')

The CreoleObjSpace

- loads the XML into an internal CreoleObjSpace representation
- visits/annotates the objects
- dumps the object space as XML output into a single XML target

The visit/annotation stage is a complex step that corresponds to the Creole
procedures.

For example: a variable is redefined and shall be moved to another family
means that a variable1 = Variable() object in the object space who lives in the family1 parent
has to be moved in family2. The visit procedure changes the varable1's object space's parent.
"""
from collections import OrderedDict
from lxml.etree import Element, SubElement  # pylint: disable=E0611
from json import dump


from .i18n import _
from .xmlreflector import XMLReflector, HIGH_COMPATIBILITY
from .annotator import ERASED_ATTRIBUTES, ActionAnnotator, ContainerAnnotator, SpaceAnnotator
from .utils import normalize_family
from .error import CreoleOperationError, SpaceObjShallNotBeUpdated, CreoleDictConsistencyError

# CreoleObjSpace's elements like 'family' or 'slave', that shall be forced to the Redefinable type
FORCE_REDEFINABLES = ('family', 'slave', 'container', 'disknod', 'variables', 'family_action')
# CreoleObjSpace's elements that shall be forced to the UnRedefinable type
FORCE_UNREDEFINABLES = ('value', 'input', 'profile', 'ewtapp', 'tag', 'saltaction')
# CreoleObjSpace's elements that shall be set to the UnRedefinable type
UNREDEFINABLE = ('multi', 'type')

PROPERTIES = ('hidden', 'frozen', 'auto_freeze', 'auto_save', 'force_default_on_freeze',
              'force_store_value', 'disabled', 'mandatory')
CONVERT_PROPERTIES = {'auto_save': ['force_store_value'], 'auto_freeze': ['force_store_value', 'auto_freeze']}

RENAME_ATTIBUTES = {'description': 'doc'}

#TYPE_TARGET_CONDITION = ('variable', 'family')

# _____________________________________________________________________________
# special types definitions for the Object Space's internal representation
class RootCreoleObject(object):
    ""


class CreoleObjSpace(object):
    """DOM XML reflexion free internal representation of a Creole Dictionary
    """
    choice = type('Choice', (RootCreoleObject,), OrderedDict())
    property_ = type('Property', (RootCreoleObject,), OrderedDict())
    # Creole ObjectSpace's Leadership variable class type
    Leadership = type('Leadership', (RootCreoleObject,), OrderedDict())
    """
    This Atom type stands for singleton, that is
    an Object Space's atom object is present only once in the
    object space's tree
    """
    Atom = type('Atom', (RootCreoleObject,), OrderedDict())
    "A variable that can't be redefined"
    Redefinable = type('Redefinable', (RootCreoleObject,), OrderedDict())
    "A variable can be redefined"
    UnRedefinable = type('UnRedefinable', (RootCreoleObject,), OrderedDict())


    def __init__(self, dtdfilename):  # pylint: disable=R0912
        self.index = 0
        class ObjSpace(object):  # pylint: disable=R0903
            """
            Base object space
            """
        self.space = ObjSpace()
        self.xmlreflector = XMLReflector()
        self.xmlreflector.parse_dtd(dtdfilename)
        self.redefine_variables = None
        self.probe_variables = []

        # elt container's attrs list
        self.container_elt_attr_list = [] #
        # ['variable', 'separator', 'family']
        self.forced_text_elts = set()
        # ['disknod', 'follower', 'target', 'service', 'package', 'ip', 'value', 'tcpwrapper',
        #  'interface', 'input', 'port']
        self.forced_text_elts_as_name = set(['choice', 'property'])
        self.forced_choice_option = {}
        self.paths = Path()
        self.list_conditions = {}

        self.booleans_attributs = []

        for elt in self.xmlreflector.dtd.iterelements():
            attrs = {}
            clstype = self.UnRedefinable
            atomic = True
            forced_text_elt = False
            if elt.type == 'mixed':
                forced_text_elt = True
            if elt.name == 'container':
                self.container_elt_attr_list = [elt.content.left.name]
                self.parse_dtd_right_left_elt(elt.content)
            for attr in elt.iterattributes():
                atomic = False
                if attr.default_value:
                    if attr.default_value == 'True':
                        default_value = True
                    elif attr.default_value == 'False':
                        default_value = False
                    else:
                        default_value = attr.default_value
                    attrs[attr.name] = default_value
                if not attr.name.endswith('_type'):
                    values = list(attr.itervalues())
                    if values != []:
                        self.forced_choice_option.setdefault(elt.name, {})[attr.name] = values

                if attr.name == 'redefine':
                    clstype = self.Redefinable
                if attr.name == 'name' and forced_text_elt is True:
                    self.forced_text_elts.add(elt.name)
                    forced_text_elt = False

                if set(attr.itervalues()) == set(['True', 'False']):
                    self.booleans_attributs.append(attr.name)

            if forced_text_elt is True:
                self.forced_text_elts_as_name.add(elt.name)

            if elt.name in FORCE_REDEFINABLES:
                clstype = self.Redefinable
            elif elt.name in FORCE_UNREDEFINABLES:
                clstype = self.UnRedefinable
            elif atomic:
                clstype = self.Atom

            # Creole ObjectSpace class types, it enables us to create objects like:
            # Service_restriction(), Ip(), Interface(), Host(), Fstab(), Package(), Disknod(),
            # File(), Variables(), Family(), Variable(), Separators(), Separator(), Value(),
            # Constraints()... and so on. Creole ObjectSpace is an object's reflexion of
            # the XML elements
            setattr(self, elt.name, type(elt.name.capitalize(), (clstype,), attrs))

    def parse_dtd_right_left_elt(self, elt):
        if elt.right.type == 'or':
            self.container_elt_attr_list.append(elt.right.left.name)
            self.parse_dtd_right_left_elt(elt.right)
        else:
            self.container_elt_attr_list.append(elt.right.name)

    def _convert_boolean(self, value):  # pylint: disable=R0201
        """Boolean coercion. The Creole XML may contain srings like `True` or `False`
        """
        if isinstance(value, bool):
            return value
        if value == 'True':
            return True
        elif value == 'False':
            return False
        else:
            raise TypeError(_('{} is not True or False').format(value))  # pragma: no cover

    def _is_already_exists(self, name, space, child, namespace):
        if isinstance(space, self.family):  # pylint: disable=E1101
            if namespace != 'creole':
                name = space.path + '.' + name
            return self.paths.path_is_defined(name)
        if child.tag in ['family', 'family_action']:
            norm_name = normalize_family(name)
        else:
            norm_name = name
        return norm_name in getattr(space, child.tag, {})

    def _translate_in_space(self, name, family, variable, namespace):
        if not isinstance(family, self.family):  # pylint: disable=E1101
            if variable.tag in ['family', 'family_action']:
                norm_name = normalize_family(name)
            else:
                norm_name = name
            return getattr(family, variable.tag)[norm_name]
        if namespace == 'creole':
            path = name
        else:
            path = family.path + '.' + name
        old_family_name = self.paths.get_variable_family_name(path)
        if normalize_family(family.name) == old_family_name:
            return getattr(family, variable.tag)[name]
        old_family = self.space.variables['creole'].family[old_family_name]  # pylint: disable=E1101
        variable_obj = old_family.variable[name]
        del old_family.variable[name]
        if 'variable' not in vars(family):
            family.variable = OrderedDict()
        family.variable[name] = variable_obj
        self.paths.append('variable', name, namespace, family.name, variable_obj)
        return variable_obj

    def remove_check(self, name):  # pylint: disable=C0111
        if hasattr(self.space, 'constraints') and hasattr(self.space.constraints, 'check'):
            remove_checks = []
            for idx, check in enumerate(self.space.constraints.check):  # pylint: disable=E1101
                if hasattr(check, 'target') and check.target == name:
                    remove_checks.append(idx)

            remove_checks = list(set(remove_checks))
            remove_checks.sort(reverse=True)
            for idx in remove_checks:
                self.space.constraints.check.pop(idx)  # pylint: disable=E1101
    def remove_condition(self, name):  # pylint: disable=C0111
        for idx, condition in enumerate(self.space.constraints.condition):  # pylint: disable=E1101
            remove_targets = []
            if hasattr(condition, 'target'):
                for target_idx, target in enumerate(condition.target):
                    if target.name == name:
                        remove_targets.append(target_idx)
            remove_targets = list(set(remove_targets))
            remove_targets.sort(reverse=True)
            for idx in remove_targets:
                del condition.target[idx]

    def create_or_update_space_object(self, subspace, space, child, namespace):
        """Creates or retrieves the space object that corresponds
        to the `child` XML object

        Two attributes of the `child` XML object are important:

        - with the `redefine` boolean flag attribute we know whether
          the corresponding space object shall be created or updated

            - `True` means that the corresponding space object shall be updated
            - `False` means that the corresponding space object shall be created

        - with the `exists` boolean flag attribute we know whether
          the corresponding space object shall be created
          (or nothing -- that is the space object isn't modified)

            - `True` means that the corresponding space object shall be created
            - `False` means that the corresponding space object is not updated

        In the special case `redefine` is True and `exists` is False,
        we create the corresponding space object if it doesn't exist
        and we update it if it exists.

        :return: the corresponding space object of the `child` XML object
        """
        if child.tag in self.forced_text_elts_as_name:
            name = child.text
        else:
            name = subspace['name']
        if self._is_already_exists(name, space, child, namespace):
            if child.tag in FORCE_REDEFINABLES:
                redefine = self._convert_boolean(subspace.get('redefine', True))
            else:
                redefine = self._convert_boolean(subspace.get('redefine', False))
            exists = self._convert_boolean(subspace.get('exists', True))
            if redefine is True:
                return self._translate_in_space(name, space, child, namespace)
            elif exists is False:
                raise SpaceObjShallNotBeUpdated()
            else:
                raise CreoleDictConsistencyError(_('Already present in another XML file, {} '
                                                   'cannot be re-created').format(name))
        else:
            redefine = self._convert_boolean(subspace.get('redefine', False))
            exists = self._convert_boolean(subspace.get('exists', False))
            if redefine is False or exists is True:
                return getattr(self, child.tag)()
            else:
                raise CreoleDictConsistencyError(_('Redefined object: '
                                                   '{} does not exist yet').format(name))

    def generate_creoleobj(self, child, space, namespace):
        """
        instanciates or creates Creole Object Subspace objects
        """
        if issubclass(getattr(self, child.tag), self.Redefinable):
            creoleobj = self.create_or_update_space_object(child.attrib, space, child, namespace)
        else:
            # instanciates an object from the CreoleObjSpace's builtins types
            # example : child.tag = constraints -> a self.Constraints() object is created
            creoleobj = getattr(self, child.tag)()
            # this Atom instance has to be a singleton here
            # we do not re-create it, we reuse it
            if isinstance(creoleobj, self.Atom) and child.tag in vars(space):
                creoleobj = getattr(space, child.tag)
        self.create_tree_structure(space, child, creoleobj)
        return creoleobj

    def create_tree_structure(self, space, child, creoleobj):  # pylint: disable=R0201
        """
        Builds the tree structure of the object space here
        we set containers attributes in order to be populated later on
        for example::

            space = Family()
            space.variable = OrderedDict()
            another example:
            space = Variable()
            space.value = list()
        """
        if child.tag not in vars(space):
            if isinstance(creoleobj, self.Redefinable):
                setattr(space, child.tag, OrderedDict())
            elif isinstance(creoleobj, self.UnRedefinable):
                setattr(space, child.tag, [])
            elif isinstance(creoleobj, self.Atom):
                pass
            else: # pragma: no cover
                raise CreoleOperationError(_("Creole object {} "
                                             "has a wrong type").format(type(creoleobj)))

    def _add_to_tree_structure(self, creoleobj, space, child):  # pylint: disable=R0201
        if isinstance(creoleobj, self.Redefinable):
            name = creoleobj.name
            if child.tag == 'family' or child.tag == 'family_action':
                name = normalize_family(name)
            getattr(space, child.tag)[name] = creoleobj
        elif isinstance(creoleobj, self.UnRedefinable):
            getattr(space, child.tag).append(creoleobj)
        else:
            setattr(space, child.tag, creoleobj)

    def _set_text_to_obj(self, child, creoleobj):
        if child.text is None:
            text = None
        else:
            text = child.text.strip()
        if text:
            if child.tag in self.forced_text_elts_as_name:
                creoleobj.name = text
            else:
                creoleobj.text = text

    def _set_xml_attributes_to_obj(self, child, creoleobj):
        redefine = self._convert_boolean(child.attrib.get('redefine', False))
        has_value = hasattr(creoleobj, 'value')
        if HIGH_COMPATIBILITY and has_value:
            has_value = len(child) != 1 or child[0].text != None
        if (redefine is True and child.tag == 'variable' and has_value
                and len(child) != 0):
            del creoleobj.value
        for attr, val in child.attrib.items():
            if redefine and attr in UNREDEFINABLE:
                # UNREDEFINABLE concerns only 'variable' node so we can fix name
                # to child.attrib['name']
                name = child.attrib['name']
                raise CreoleDictConsistencyError(_("cannot redefine attribute {} for variable {}").format(attr, name))
            if isinstance(getattr(creoleobj, attr, None), bool):
                if val == 'False':
                    val = False
                elif val == 'True':
                    val = True
                else: # pragma: no cover
                    raise CreoleOperationError(_('value for {} must be True or False, '
                                                 'not {}').format(attr, val))
            if not (attr == 'name' and getattr(creoleobj, 'name', None) != None):
                setattr(creoleobj, attr, val)

    def _creoleobj_tree_visitor(self, child, creoleobj, namespace):
        """Creole object tree manipulations
        """
        if child.tag == 'variable' and child.attrib.get('remove_check', False):
            self.remove_check(creoleobj.name)
        if child.tag == 'variable' and child.attrib.get('remove_condition', False):
            self.remove_condition(creoleobj.name)
        if child.tag in ['auto', 'fill', 'check']:
            variable_name = child.attrib['target']
            # XXX not working with variable not in creole and in leader/followers
            if variable_name in self.redefine_variables:
                creoleobj.redefine = True
            else:
                creoleobj.redefine = False
        if not hasattr(creoleobj, 'index'):
            creoleobj.index = self.index
        if child.tag in ['auto', 'fill', 'condition', 'check', 'action']:
            creoleobj.namespace = namespace

    def xml_parse_document(self, document, space, namespace, is_in_family=False):
        """Parses a Creole XML file
        populates the CreoleObjSpace
        """
        family_names = []
        for child in document:
            # this index enables us to reorder the 'fill' and 'auto' objects
            self.index += 1
            # doesn't proceed the XML commentaries
            if not isinstance(child.tag, str):
                continue
            if child.tag == 'family':
                is_in_family = True
                if child.attrib['name'] in family_names:
                    raise CreoleDictConsistencyError(_('Family {} is set several times').format(child.attrib['name']))
                family_names.append(child.attrib['name'])
            if child.tag == 'variables':
                child.attrib['name'] = namespace
            if HIGH_COMPATIBILITY and child.tag == 'value' and child.text == None:
                continue
            # creole objects creation
            try:
                creoleobj = self.generate_creoleobj(child, space, namespace)
            except SpaceObjShallNotBeUpdated:
                continue
            self._set_text_to_obj(child, creoleobj)
            self._set_xml_attributes_to_obj(child, creoleobj)
            self._creoleobj_tree_visitor(child, creoleobj, namespace)
            self._fill_creoleobj_path_attribute(space, child, namespace, document, creoleobj)
            self._add_to_tree_structure(creoleobj, space, child)
            if list(child) != []:
                self.xml_parse_document(child, creoleobj, namespace, is_in_family)

    def _fill_creoleobj_path_attribute(self, space, child, namespace, document, creoleobj):  # pylint: disable=R0913
        """Fill self.paths attributes
        """
        if not isinstance(space, self.help):  # pylint: disable=E1101
            if child.tag == 'variable':
                family_name = normalize_family(document.attrib['name'])
                self.paths.append('variable', child.attrib['name'], namespace, family_name,
                                  creoleobj)
                if child.attrib.get('redefine', 'False') == 'True':
                    if namespace == 'creole':
                        self.redefine_variables.append(child.attrib['name'])
                    else:
                        self.redefine_variables.append(namespace + '.' + family_name + '.' +
                                                       child.attrib['name'])

            if child.tag == 'family':
                family_name = normalize_family(child.attrib['name'])
                if namespace != 'creole':
                    family_name = namespace + '.' + family_name
                self.paths.append('family', family_name, namespace, creoleobj=creoleobj)
                creoleobj.path = self.paths.get_family_path(family_name, namespace)

    def create_or_populate_from_xml(self, namespace, xmlfolders, from_zephir=None):
        """Parses a bunch of XML files
        populates the CreoleObjSpace
        """
        documents = self.xmlreflector.load_xml_from_folders(xmlfolders, from_zephir)
        for xmlfile, document in documents:
            try:
                self.redefine_variables = []
                self.xml_parse_document(document, self.space, namespace)
            except Exception as err:
                #print(_('error in XML file {}').format(xmlfile))
                raise err

    def populate_from_zephir(self, namespace, xmlfile):
        self.redefine_variables = []
        document = self.xmlreflector.parse_xmlfile(xmlfile, from_zephir=True, zephir2=True)
        self.xml_parse_document(document, self.space, namespace)

    def space_visitor(self, eosfunc_file):  # pylint: disable=C0111
        ActionAnnotator(self)
        ContainerAnnotator(self)
        SpaceAnnotator(self, eosfunc_file)

    def save(self, filename, force_no_save=False):
        """Save an XML output on disk

        :param filename: the full XML filename
        """
        xml = Element('creole')
        self._xml_export(xml, self.space)
        if not force_no_save:
            self.xmlreflector.save_xmlfile(filename, xml)
        return xml

    def save_probes(self, filename, force_no_save=False):
        """Save an XML output on disk

        :param filename: the full XML filename
        """
        ret = {}
        for variable in self.probe_variables:
            args = []
            kwargs = {}
            if hasattr(variable, 'param'):
                for param in variable.param:
                    list_param = list(vars(param).keys())
                    if 'index' in list_param:
                        list_param.remove('index')
                    if list_param == ['text']:
                        args.append(param.text)
                    elif list_param == ['text', 'name']:
                        kwargs[param.name] = param.text
                    else:
                        print(vars(param))
                        raise Exception('hu?')
            ret[variable.target] = {'function': variable.name,
                                    'args': args,
                                    'kwargs': kwargs}
        if not force_no_save:
            with open(filename, 'w') as fhj:
                dump(ret, fhj)
        return ret

    def _get_attributes(self, space):  # pylint: disable=R0201
        for attr in dir(space):
            if not attr.startswith('_'):
                yield attr

    def _sub_xml_export(self, name, node, node_name, space, current_space):
        if isinstance(space, dict):
            space = list(space.values())
        if isinstance(space, list):
            for subspace in space:
                if isinstance(subspace, self.Leadership):
                    _name = 'leader'
                    subspace.doc = subspace.variable[0].description
                    #subspace.doc = 'Leadership {}'.format(subspace.name)
                else:
                    _name = name
                if name in ['containers', 'variables', 'actions']:
                    _name = 'family'
                    if HIGH_COMPATIBILITY and not hasattr(subspace, 'doc'):
                        subspace.doc = ''
                if _name == 'value' and (not hasattr(subspace, 'name') or subspace.name is None):
                    continue
                child_node = SubElement(node, _name)
                self._xml_export(child_node, subspace, _name)
        elif isinstance(space, self.Atom):
            if name == 'containers':
                child_node = SubElement(node, 'family')
                child_node.attrib['name'] = name
            else:
                child_node = SubElement(node, name)
            for subname in self._get_attributes(space):
                subspace = getattr(space, subname)
                self._sub_xml_export(subname, child_node, name, subspace, space)
        elif isinstance(space, self.Redefinable):
            child_node = SubElement(node, 'family')
            child_node.attrib['name'] = name
            for subname in self._get_attributes(space):
                subspace = getattr(space, subname)
                self._sub_xml_export(subname, child_node, name, subspace, space)
        else:
            # FIXME plutot dans annotator ...
            if name in PROPERTIES and node.tag in ['variable', 'family', 'leader']:
                if space is True:
                    for prop in CONVERT_PROPERTIES.get(name, [name]):
                        SubElement(node, 'property').text = prop

            elif name not in ERASED_ATTRIBUTES:
                if name == 'name' and node_name in self.forced_text_elts_as_name and not hasattr(current_space, 'param'):
                    if isinstance(space, str):
                        node.text = space
                    else:
                        node.text = str(space)
                elif name == 'text' and node_name in self.forced_text_elts:
                    node.text = space
                elif node.tag == 'family' and name == 'name':
                    if 'doc' not in node.attrib.keys():
                        node.attrib['doc'] = space
                    node.attrib['name'] = normalize_family(space, check_name=False)
                elif node.tag in ['variable', 'family', 'leader'] and name == 'mode':
                    if space is not None:
                        SubElement(node, 'property').text = space
                else:
                    if name in RENAME_ATTIBUTES:
                        name = RENAME_ATTIBUTES[name]
                    if space is not None:
                        node.attrib[name] = str(space)

    def _xml_export(self, node, space, node_name='creole'):
        for name in self._get_attributes(space):
            subspace = getattr(space, name)
            self._sub_xml_export(name, node, node_name, subspace, space)


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

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

    def append(self, pathtype, name, namespace, family=None, creoleobj=None):  # pylint: disable=C0111
        if pathtype == 'family':
            self.families[name] = dict(name=name, namespace=namespace, creoleobj=creoleobj)
        elif pathtype == 'variable':
            if namespace == 'creole':
                varname = name
            else:
                if '.' in name:
                    varname = name
                else:
                    varname = '.'.join([namespace, family, name])
            self.variables[varname] = dict(name=name, family=family, namespace=namespace,
                                           leader=None, creoleobj=creoleobj)
        else:  # pragma: no cover
            raise Exception('unknown pathtype {}'.format(pathtype))

    def get_family_path(self, name, current_namespace):  # pylint: disable=C0111
        if current_namespace is None:  # pragma: no cover
            raise CreoleOperationError('current_namespace must not be None')
        dico = self.families[normalize_family(name, check_name=False)]
        if dico['namespace'] != 'creole' and current_namespace != dico['namespace']:
            raise CreoleDictConsistencyError(_('A family located in the {} namespace '
                                               'shall not be used in the {} namespace').format(
                                                   dico['namespace'], current_namespace))
        path = dico['name']
        if dico['namespace'] is not None and '.' not in dico['name']:
            path = '.'.join([dico['namespace'], path])
        return path

    def get_family_namespace(self, name):  # pylint: disable=C0111
        dico = self.families[name]
        if dico['namespace'] is None:
            return dico['name']
        return dico['namespace']

    def get_family_obj(self, name):  # pylint: disable=C0111
        if name not in self.families:
            raise CreoleDictConsistencyError(_('unknown family {}').format(name))
        dico = self.families[name]
        return dico['creoleobj']

    def get_variable_name(self, name):  # pylint: disable=C0111
        dico = self._get_variable(name)
        return dico['name']

    def get_variable_obj(self, name):  # pylint: disable=C0111
        dico = self._get_variable(name)
        return dico['creoleobj']

    def get_variable_family_name(self, name):  # pylint: disable=C0111
        dico = self._get_variable(name)
        return dico['family']

    def get_variable_family_path(self, name):  # pylint: disable=C0111
        dico = self._get_variable(name)
        list_path = [dico['namespace'], dico['family']]
        if dico['leader'] is not None:
            list_path.append(dico['leader'])
        return '.'.join(list_path)

    def get_variable_namespace(self, name):  # pylint: disable=C0111
        return self._get_variable(name)['namespace']

    def get_variable_path(self, name, current_namespace, allow_source=False):  # pylint: disable=C0111
        if current_namespace is None:  # pragma: no cover
            raise CreoleOperationError('current_namespace must not be None')
        dico = self._get_variable(name)
        if not allow_source:
            if dico['namespace'] != 'creole' and current_namespace != dico['namespace']:
                raise CreoleDictConsistencyError(_('A variable located in the {} namespace '
                                                   'shall not be used in the {} namespace').format(
                                                       dico['namespace'], current_namespace))
        if '.' in dico['name']:
            return dico['name']
        list_path = [dico['namespace'], dico['family']]
        if dico['leader'] is not None:
            list_path.append(dico['leader'])
        list_path.append(dico['name'])
        return '.'.join(list_path)

    def path_is_defined(self, name):  # pylint: disable=C0111
        return name in self.variables

    def set_leader(self, name, leader):  # pylint: disable=C0111
        dico = self._get_variable(name)
        namespace = dico['namespace']
        if dico['leader'] != None:
            raise CreoleDictConsistencyError(_('Already defined leader {} for variable'
                                               ' {}'.format(dico['leader'], name)))
        dico['leader'] = leader
        if namespace != 'creole':
            new_path = self.get_variable_path(name, namespace)
            self.append('variable', new_path, namespace, family=dico['family'], creoleobj=dico['creoleobj'])
            self.variables[new_path]['leader'] = leader
            del self.variables[name]

    def _get_variable(self, name):
        if name not in self.variables:
            if name.startswith('creole.'):
                name = name.split('.')[-1]
            if name not in self.variables:
                raise CreoleDictConsistencyError(_('unknown option {}').format(name))
        return self.variables[name]

    def get_leader(self, name):  # pylint: disable=C0111
        dico = self._get_variable(name)
        return dico['leader']