add default value to True in boolean

debian/changelog

@@ -0,0 +1,5 @@
+rougail (0.1) unstable; urgency=low
+
+  * first version
+
+ -- Cadoles <contact@cadoles.com>  Tue, 31 Mar 2020 10:40:42 +0200

src/rougail/annotator.py

@@ -1,5 +1,6 @@
 # coding: utf-8
 from copy import copy
+from typing import List
 
 from collections import OrderedDict
 from os.path import join, basename
@@ -20,25 +21,9 @@ class Mode(object):
     def __init__(self, name, level):
         self.name = name
         self.level = level
-
-    def __cmp__(self, other):
-        return cmp(self.level, other.level)
-
-    def __eq__(self, other):
-        return self.level == other.level
-
-    def __ne__(self, other):
-        return self.level != other.level
-
     def __gt__(self, other):
         return other.level < self.level
 
-    def __ge__(self, other):
-        return not self.level < other.level
-
-    def __le__(self, other):
-        return not other.level < self.level
-
 
 def mode_factory():
     mode_obj = {}
@@ -49,6 +34,7 @@ def mode_factory():
 
 modes = mode_factory()
 
+
 # a CreoleObjSpace's attribute has some annotations
 # that shall not be present in the exported (flatened) XML
 ERASED_ATTRIBUTES = ('redefine', 'exists', 'fallback', 'optional', 'remove_check', 'namespace',
@@ -71,63 +57,84 @@ KEY_TYPE = {'variable': 'symlink',
             'URLOption': 'web_address',
             'FilenameOption': 'filename'}
 
-TYPE_PARAM_CHECK = ('string', 'python', 'eole', 'variable')
-TYPE_PARAM_CONDITION = ('string', 'python', 'number', 'eole', 'variable')
-TYPE_PARAM_FILL = ('string', 'eole', 'number', 'context', 'variable')
-
-ERASED_FAMILY_ACTION_ATTRIBUTES = ('index', 'action')
+TYPE_PARAM_CHECK = ('string', 'python', 'variable')
+TYPE_PARAM_CONDITION = ('string', 'python', 'number', 'variable')
+TYPE_PARAM_FILL = ('string', 'number', 'variable')
+CONVERSION = {'number': int}
 
 FREEZE_AUTOFREEZE_VARIABLE = 'module_instancie'
 
+VARIABLE_NAMESPACE = 'rougail'
+
 
 class ServiceAnnotator:
     """Manage service's object
+    for example::
+        <services>
+            <service name="test">
+                <service_access service='ntp'>
+                    <port protocol='udp' service_accesslist='ntp_udp'>123</port>
+                </service_access>
+            </service>
+        </services>
     """
     def __init__(self, objectspace):
         self.space = objectspace.space
         self.paths = objectspace.paths
         self.objectspace = objectspace
-        """for example::
-                <service_access service='ntp'>
-                    <port protocol='udp' service_accesslist='ntp_udp'>123</port>
-                    <tcpwrapper>ntpd</tcpwrapper>
-                </service_access>
-        """
         self.grouplist_conditions = {}
         self.convert_services()
 
-    def convert_services(self):
-        if hasattr(self.space, 'services'):
-            if hasattr(self.space.services, 'service'):
-                subelts = dict()
-                for idx, service in enumerate(self.space.services.service.values()):
+    def gen_family(self,
+                   name,
+                   ):
             family = self.objectspace.family()
-                    family.name = 'service{}'.format(idx)
-                    family.doc = service.name
-                    family.family = OrderedDict()
-                    self.convert_service_to_family(family.name, family.family, service)
-                    setattr(self.space.services, family.name, family)
-                del self.space.services.service
-            else:
-                del self.space.services
+            family.name = name
+            family.doc = name
+            family.mode = None
+            return family
 
-    def convert_service_to_family(self, service_name, service_family, service):
+    def convert_services(self):
+        if not hasattr(self.space, 'services'):
+            return
+        if not hasattr(self.space.services, 'service'):
+            del self.space.services
+            return
+        self.space.services.hidden = True
+        families = {}
+        for idx, service_name in enumerate(self.space.services.service.keys()):
+            service = self.space.services.service[service_name]
+            new_service = self.objectspace.service()
             for elttype, values in vars(service).items():
-            if elttype in ['name', 'index']:
+                if elttype == 'name' or elttype in ERASED_ATTRIBUTES:
+                    setattr(new_service, elttype, values)
                     continue
-            family = self.objectspace.family()
-            family.name = elttype + 's'
+                eltname = elttype + 's'
+                family = self.gen_family(eltname)
                 if isinstance(values, dict):
                     values = list(values.values())
-            family.family = self.convert_subelement_service(elttype,
+                family.family = self.make_group_from_elts(service_name,
+                                                          elttype,
                                                           values,
-                                                            'services.{}.{}'.format(service_name, family.name))
-            family.mode = None
-            service_family[family.name] = family
+                                                          f'services.{service_name}.{eltname}',
+                                                          )
+                setattr(new_service, elttype, family)
+            families[service_name] = new_service
+        self.space.services.service = families
 
-    def convert_subelement_service(self, name, elts, path):
+    def make_group_from_elts(self,
+                             service_name,
+                             name,
+                             elts,
+                             path,
+                             ):
+        """Splits each objects into a group (and `OptionDescription`, in tiramisu terms)
+        and build elements and its attributes (the `Options` in tiramisu terms)
+        """
         families = []
-        new_elts = self._reorder_elts(name, elts, True)
+        new_elts = self._reorder_elts(name,
+                                      elts,
+                                      )
         for index, elt_info in enumerate(new_elts):
             elt = elt_info['elt']
             elt_name = elt_info['elt_name']
@@ -135,9 +142,19 @@ class ServiceAnnotator:
             # try to launch _update_xxxx() function
             update_elt = '_update_' + elt_name
             if hasattr(self, update_elt):
-                getattr(self, update_elt)(elt, index, path)
-            variables = []
-            subpath = '{}.{}{}'.format(path, name, index)
+                getattr(self, update_elt)(elt,
+                                          index,
+                                          path,
+                                          service_name,
+                                          )
+
+            if hasattr(elt, 'source'):
+                c_name = elt.source
+            else:
+                c_name = elt.name
+            family = self.gen_family(c_name)
+            family.variable = []
+            subpath = '{}.{}'.format(path, c_name)
             listname = '{}list'.format(name)
             activate_path = '.'.join([subpath, 'activate'])
             if elt in self.grouplist_conditions:
@@ -149,228 +166,117 @@ class ServiceAnnotator:
                 if key.startswith('_') or key.endswith('_type') or key in ERASED_ATTRIBUTES:
                     continue
                 value = getattr(elt, key)
-                if isinstance(value, list):
-                    continue
-                if key == 'service':
-                    value = value.name
                 if key == listname:
                     self.objectspace.list_conditions.setdefault(listname,
                                                                 {}).setdefault(
                                                                     value,
                                                                     []).append(activate_path)
                     continue
+                family.variable.append(self._generate_element(elt_name,
+                                                              key,
+                                                              value,
+                                                              elt,
+                                                              f'{subpath}.{key}'
+                                                              ))
+            # FIXME ne devrait pas etre True par défaut
+            # devrait etre un calcule
+            family.variable.append(self._generate_element(elt_name,
+                                                         'activate',
+                                                          True,
+                                                          elt,
+                                                          activate_path,
+                                                          ))
+            families.append(family)
+        return families
+
+    def _generate_element(self,
+                          elt_name,
+                          key,
+                          value,
+                          elt,
+                          path,
+                          ):
+        variable = self.objectspace.variable()
+        variable.name = key
+        variable.mode = None
         if key == 'name':
             true_key = elt_name
         else:
             true_key = key
-                if true_key in self.objectspace.booleans_attributs:
+        dtd_key_type = true_key + '_type'
+        if key == 'activate':
+            type_ = 'boolean'
+        elif hasattr(elt, dtd_key_type):
+            type_ = KEY_TYPE[getattr(elt, dtd_key_type)]
+        elif key in self.objectspace.booleans_attributs:
             type_ = 'boolean'
         else:
             type_ = 'string'
-                dtd_key_type = true_key + '_type'
-
-                if hasattr(elt, dtd_key_type):
-                    type_ = KEY_TYPE[getattr(elt, dtd_key_type)]
-                multi = isinstance(value, list)
-                variables.append(self._generate_element(elt_name,
-                                                        key,
-                                                        value,
-                                                        type_,
-                                                        subpath,
-                                                        multi))
-            # FIXME ne devrait pas etre True par défaut
-            variables.append(self._generate_element(name, 'activate', True, 'boolean', subpath))
-            family = self.objectspace.family()
-            family.name = '{}{}'.format(name, index)
-            family.variable = variables
-            family.mode = None
-            self.paths.append('family', subpath, 'services', creoleobj=family)
-            families.append(family)
-        return families
-
-    def _generate_element(self, eltname, name, value, type_, subpath, multi=False):
-        var_data = {'name': name, 'doc': '', 'value': value,
-                    'auto_freeze': False, 'mode': None, 'multi': multi}
-        values = None
-        if type_ == 'string':
-            values = self.objectspace.forced_choice_option.get(eltname, {}).get(name)
-            if values is not None:
-                type_ = 'choice'
-        var_data['type'] = type_
-
-        variable = self.objectspace.variable()
-        variable.mandatory = True
-        for key, value in var_data.items():
-            if key == 'value':
-                if value is None:
-                    continue
+        variable.type = type_
         if type_ == 'symlink':
-                    key = 'opt'
+            variable.opt = value
         else:
-                    # Value is a list of objects
-                    if not multi:
+            variable.doc = key
             val = self.objectspace.value()
             val.name = value
-                        value = [val]
-                    else:
-                        value_list = []
-                        for valiter in value:
-                            val = self.objectspace.value()
-                            val.name = valiter.name
-                            value_list.append(val)
-                        value = value_list
-            if key == 'doc' and type_ == 'symlink':
-                continue
-            setattr(variable, key, value)
-        if values is not None:
-            choices = []
-            for value in values:
-                choice = self.objectspace.choice()
-                choice.name = value
-                choices.append(choice)
-            variable.choice = choices
-        path = '{}.{}'.format(subpath, name)
-        self.paths.append('variable', path, 'services', 'service', variable)
+            variable.value = [val]
+        self.paths.add_variable('services',
+                                path,
+                                'service',
+                                False,
+                                variable,
+                                )
         return variable
 
-    def _update_file(self, file_, index, service_path):
-        if file_.file_type == "UnicodeOption":
+    def _reorder_elts(self,
+                      name,
+                      elts,
+                      ):
+        """Reorders by index the elts
+        """
+        new_elts = {}
+        # reorder elts by index
+        for idx, elt in enumerate(elts):
+            new_elts.setdefault(idx, []).append(elt)
+        idxes = list(new_elts.keys())
+        idxes.sort()
+        result_elts = []
+        for idx in idxes:
+            for elt in new_elts[idx]:
+                result_elts.append({'elt_name': name, 'elt': elt})
+        return result_elts
+
+    def _update_override(self,
+                         file_,
+                         index,
+                         service_path,
+                         service_name,
+                         ):
+        file_.name = f'/systemd/system/{service_name}.service.d/rougail.conf'
+        # retrieve default value from File object
+        for attr in ['owner', 'group', 'mode']:
+            setattr(file_, attr, getattr(self.objectspace.file, attr))
+        if not hasattr(file_, 'source'):
+            file_.source = f'{service_name}.service'
+        self._update_file(file_,
+                          index,
+                          service_path,
+                          service_name,
+                          )
+
+    def _update_file(self,
+                     file_,
+                     index,
+                     service_path,
+                     service_name,
+                     ):
+        if not hasattr(file_, 'file_type') or file_.file_type == "UnicodeOption":
             if not hasattr(file_, 'source'):
                 file_.source = basename(file_.name)
         elif not hasattr(file_, 'source'):
             raise CreoleDictConsistencyError(_('attribute source mandatory for file with variable name '
                                                'for {}').format(file_.name))
 
-    def _reorder_elts(self, name, elts, duplicate_list):
-        """Reorders by index the elts
-        """
-        dict_elts = OrderedDict()
-        # reorder elts by index
-        new_elts = {}
-        not_indexed = []
-        for elt in elts:
-            idx = elt.index
-            new_elts.setdefault(idx, []).append(elt)
-        idxes = list(new_elts.keys())
-        idxes.sort()
-        elts = not_indexed
-        for idx in idxes:
-            elts.extend(new_elts[idx])
-        for idx, elt in enumerate(elts):
-            elt_added = False
-            for key in dir(elt):
-                if key.startswith('_') or key.endswith('_type') or key in ERASED_ATTRIBUTES:
-                    continue
-                value = getattr(elt, key)
-            if not elt_added:
-                eltname = elt.name
-                dict_elts.setdefault(eltname, []).append({'elt_name': name, 'elt': elt})
-
-        result_elts = []
-        for elt in dict_elts.values():
-            result_elts.extend(elt)
-        return result_elts
-
-    def make_group_from_elts(self, name, elts, path, duplicate_list):
-        """Splits each objects into a group (and `OptionDescription`, in tiramisu terms)
-        and build elements and its attributes (the `Options` in tiramisu terms)
-        """
-        families = []
-        new_elts = self._reorder_elts(name, elts, duplicate_list)
-        for index, elt_info in enumerate(new_elts):
-            elt = elt_info['elt']
-            elt_name = elt_info['elt_name']
-
-            # try to launch _update_xxxx() function
-            update_elt = '_update_' + elt_name
-            if hasattr(self, update_elt):
-                getattr(self, update_elt)(elt, index, path)
-            variables = []
-            subpath = '{}.{}{}'.format(path, name, index)
-            listname = '{}list'.format(name)
-            activate_path = '.'.join([subpath, 'activate'])
-            if elt in self.grouplist_conditions:
-                # FIXME transformer le activate qui disparait en boolean
-                self.objectspace.list_conditions.setdefault(listname,
-                                                            {}).setdefault(self.grouplist_conditions[elt],
-                                                                           []).append(activate_path)
-            for key in dir(elt):
-                if key.startswith('_') or key.endswith('_type') or key in ERASED_ATTRIBUTES:
-                    continue
-                value = getattr(elt, key)
-                if isinstance(value, list) and duplicate_list:
-                    # FIXME plusieurs fichier si calculé !
-                    continue
-                if key == listname:
-                    self.objectspace.list_conditions.setdefault(listname,
-                                                                {}).setdefault(
-                                                                    value,
-                                                                    []).append(activate_path)
-                    continue
-                if key in self.objectspace.booleans_attributs:
-                    type_ = 'boolean'
-                else:
-                    type_ = 'string'
-                dtd_key_type = key + '_type'
-                if hasattr(elt, dtd_key_type):
-                    type_ = KEY_TYPE[getattr(elt, dtd_key_type)]
-                multi = isinstance(value, list)
-                variables.append(self._generate_element(elt_name,
-                                                        key,
-                                                        value,
-                                                        type_,
-                                                        subpath,
-                                                        multi))
-            # FIXME ne devrait pas etre True par défaut
-            variables.append(self._generate_element(name, 'activate', True, 'boolean', subpath))
-            family = self.objectspace.family()
-            family.name = '{}{}'.format(name, index)
-            family.variable = variables
-            family.mode = None
-            self.paths.append('family', subpath, 'services', creoleobj=family)
-            families.append(family)
-        return families
-
-
-class ActionAnnotator(ServiceAnnotator):
-    def __init__(self, objectspace):
-        self.space = objectspace.space
-        self.paths = objectspace.paths
-        self.objectspace = objectspace
-        self.grouplist_conditions = {}
-        self.convert_family_action()
-
-    def convert_family_action(self):
-        if hasattr(self.space, 'family_action'):
-            actions = self.objectspace.family()
-            actions.name = 'actions'
-            actions.mode = None
-            actions.family = []
-            self.space.actions = actions
-            namespaces = []
-            for name, actions in self.space.family_action.items():
-                subpath = 'actions.{}'.format(normalize_family(name))
-                for action in actions.action:
-                    namespace = action.namespace
-                    if namespace in namespaces:
-                        raise CreoleDictConsistencyError(_('only one action allow for {}'
-                                                           '').format(namespace))
-                    namespaces.append(namespace)
-                    action.name = action.namespace
-                new_actions = self.make_group_from_elts('action', actions.action, subpath, False)
-                family = self.objectspace.family()
-                family.name = actions.name
-                family.family = new_actions
-                family.mode = None
-                variables = []
-                for key, value in vars(actions).items():
-                    if key not in ERASED_FAMILY_ACTION_ATTRIBUTES:
-                        variables.append(self._generate_element('action', key, value, 'string',
-                                                                subpath))
-                family.variable = variables
-                self.space.actions.family.append(family)
-            del self.space.family_action
-
 
 class SpaceAnnotator(object):
     """Transformations applied on a CreoleObjSpace instance
@@ -381,25 +287,21 @@ class SpaceAnnotator(object):
         self.objectspace = objectspace
         self.valid_enums = {}
         self.force_value = {}
-        self.has_calc = []
-        self.force_no_value = []
         self.force_not_mandatory = []
         if eosfunc_file:
             self.eosfunc = imp.load_source('eosfunc', eosfunc_file)
         else:
             self.eosfunc = None
         if HIGH_COMPATIBILITY:
-            self.default_has_no_value = []
-            self.has_frozen_if_in_condition = []
-        self.default_variable_options()
-        self.variable_submulti()
+            self.has_hidden_if_in_condition = []
+        self.convert_variable()
         self.convert_auto_freeze()
         self.convert_groups()
         self.filter_check()
         self.filter_condition()
         self.convert_valid_enums()
         self.convert_check()
-        self.convert_autofill()
+        self.convert_fill()
         self.remove_empty_families()
         self.change_variable_mode()
         self.change_family_mode()
@@ -409,6 +311,7 @@ class SpaceAnnotator(object):
         self.convert_helps()
         if hasattr(self.space, 'constraints'):
             del self.space.constraints.index
+            del self.space.constraints.namespace
             if vars(self.space.constraints):
                 raise Exception('constraints again?')
             del self.space.constraints
@@ -416,14 +319,19 @@ class SpaceAnnotator(object):
     def absolute_path_for_symlink_in_services(self):
         if not hasattr(self.space, 'services'):
             return
-        families = vars(self.space.services).values()
-        for family in families:
-            if hasattr(family, 'family'):
-                for fam in family.family.values():
-                    for fam1 in fam.family:
-                        for variable in fam1.variable:
+        for family_name, family in vars(self.space.services).items():
+            if not isinstance(family, dict):
+                continue
+            for fam in family.values():
+                for fam1_name, fam1 in vars(fam).items():
+                    if fam1_name == 'name' or fam1_name in ERASED_ATTRIBUTES:
+                        continue
+                    for fam2 in fam1.family:
+                        for variable in fam2.variable:
                             if variable.type == 'symlink' and '.' not in variable.name:
-                                variable.opt = self.paths.get_variable_path(variable.opt, 'creole')
+                                variable.opt = self.paths.get_variable_path(variable.opt,
+                                                                            VARIABLE_NAMESPACE,
+                                                                            )
 
     def convert_helps(self):
         # FIXME l'aide doit etre dans la variable!
@@ -440,61 +348,116 @@ class SpaceAnnotator(object):
                 variable.help = hlp.text
         del self.space.help
 
-    def convert_groups(self):  # pylint: disable=C0111
-        if hasattr(self.space, 'constraints'):
-            if hasattr(self.space.constraints, 'group'):
-                for group in self.space.constraints.group:
-                    leader_fullname = group.master
-                    follower_names = list(group.slave.keys())
-                    leader_family_name = self.paths.get_variable_family_name(leader_fullname)
-                    namespace = self.paths.get_variable_namespace(leader_fullname)
-                    leader_name = self.paths.get_variable_name(leader_fullname)
-                    leader_family = self.space.variables[namespace].family[leader_family_name]
-                    leader_path = namespace + '.' + leader_family_name
-                    is_leader = False
-                    for variable in list(leader_family.variable.values()):
-                        if isinstance(variable, self.objectspace.Leadership):
-                            # append follower to an existed leadership
-                            if variable.name == leader_name:
-                                leader_space = variable
-                                is_leader = True
-                        else:
-                            if is_leader:
-                                if variable.name == follower_names[0]:
-                                    # followers are multi
-                                    if not variable.multi:
-                                        raise CreoleDictConsistencyError(_('the variable {} in a group must be multi or submulti').format(variable.name))
-                                    follower_names.remove(variable.name)
-                                    leader_family.variable.pop(variable.name)
-                                    leader_space.variable.append(variable)  # pylint: disable=E1101
-                                    if namespace == 'creole':
-                                        variable_fullpath = variable.name
-                                    else:
-                                        variable_fullpath = leader_path + '.' + variable.name
-                                    self.paths.set_leader(variable_fullpath, leader_name)
-                                    if follower_names == []:
-                                        break
-                                else:
-                                    raise CreoleDictConsistencyError(_('cannot found this follower {}').format(follower_names[0]))
-                            if is_leader is False and variable.name == leader_name:
-                                leader_space = self.objectspace.Leadership()
+    def manage_leader(self,
+                      leader_space: 'Leadership',
+                      leader_family_name: str,
+                      leader_name: str,
+                      namespace: str,
+                      variable: 'Variable',
+                      group: 'Group',
+                      leader_fullname: str,
+                      ) -> None:
+        # manage leader's variable
+        if variable.multi is not True:
+            raise CreoleDictConsistencyError(_('the variable {} in a group must be multi').format(variable.name))
         leader_space.variable = []
         leader_space.name = leader_name
         leader_space.hidden = variable.hidden
+        if variable.hidden:
+            leader_is_hidden = True
+            variable.frozen = True
+            variable.force_default_on_freeze = True
+        else:
+            leader_is_hidden = False
+        variable.hidden = None
         if hasattr(group, 'description'):
             leader_space.doc = group.description
         else:
             leader_space.doc = variable.description
-                                variable.hidden = None
-                                self.paths.append('family', leader_path + '.' + leader_name, namespace, creoleobj=leader_space)
-                                # manage leader's variable
-                                if variable.multi is not True:
-                                    raise CreoleDictConsistencyError(_('the variable {} in a group must be multi').format(variable.name))
+        leader_path = namespace + '.' + leader_family_name + '.' + leader_name
+        self.paths.add_family(namespace,
+                              leader_path,
+                              leader_space,
+                              )
+        leader_family = self.space.variables[namespace].family[leader_family_name]
         leader_family.variable[leader_name] = leader_space
-                                leader_space.variable.append(variable)  # pylint: disable=E1101
-                                self.paths.set_leader(leader_fullname, leader_name)
+        leader_space.variable.append(variable)
+        self.paths.set_leader(namespace,
+                              leader_family_name,
+                              leader_name,
+                              leader_name,
+                              )
         leader_space.path = leader_fullname
-                                is_leader = True
+        return leader_is_hidden
+
+    def manage_follower(self,
+                        namespace: str,
+                        leader_family_name: str,
+                        variable: 'Variable',
+                        leader_name: str,
+                        follower_names: List[str],
+                        leader_space: 'Leadership',
+                        leader_is_hidden: bool,
+                        ) -> None:
+        if variable.name != follower_names[0]:
+            raise CreoleDictConsistencyError(_('cannot found this follower {}').format(follower_names[0]))
+        follower_names.remove(variable.name)
+        if leader_is_hidden:
+            variable.frozen = True
+            variable.force_default_on_freeze = True
+        # followers are multi
+        if not variable.multi:
+            raise CreoleDictConsistencyError(_('the variable {} in a group must be multi or submulti').format(variable.name))
+        leader_space.variable.append(variable)  # pylint: disable=E1101
+        self.paths.set_leader(namespace,
+                              leader_family_name,
+                              variable.name,
+                              leader_name,
+                              )
+
+    def convert_groups(self):  # pylint: disable=C0111
+        if hasattr(self.space, 'constraints') and hasattr(self.space.constraints, 'group'):
+            for group in self.space.constraints.group:
+                leader_fullname = group.leader
+                follower_names = list(group.follower.keys())
+                leader_family_name = self.paths.get_variable_family_name(leader_fullname)
+                namespace = self.paths.get_variable_namespace(leader_fullname)
+                leader_name = self.paths.get_variable_name(leader_fullname)
+                ori_leader_family = self.space.variables[namespace].family[leader_family_name]
+                has_a_leader = False
+                for variable in list(ori_leader_family.variable.values()):
+                    if isinstance(variable, self.objectspace.Leadership):
+                        # append follower to an existed leadership
+                        if variable.name == leader_name:
+                            leader_space = variable
+                            has_a_leader = True
+                    else:
+                        if has_a_leader:
+                            # it's a follower
+                            self.manage_follower(namespace,
+                                                 leader_family_name,
+                                                 variable,
+                                                 leader_name,
+                                                 follower_names,
+                                                 leader_space,
+                                                 leader_is_hidden,
+                                                 )
+                            ori_leader_family.variable.pop(variable.name)
+                            if follower_names == []:
+                                # no more follower
+                                break
+                        elif variable.name == leader_name:
+                            # it's a leader
+                            leader_space = self.objectspace.Leadership()
+                            leader_is_hidden = self.manage_leader(leader_space,
+                                                                  leader_family_name,
+                                                                  leader_name,
+                                                                  namespace,
+                                                                  variable,
+                                                                  group,
+                                                                  leader_fullname,
+                                                                  )
+                            has_a_leader = True
                 else:
                     raise CreoleDictConsistencyError(_('cannot found followers {}').format(follower_names))
             del self.space.constraints.group
@@ -544,34 +507,24 @@ class SpaceAnnotator(object):
                         varpath = self.paths.get_variable_path(family.dynamic, namespace)
                         family.dynamic = varpath
 
-    def _annotate_variable(self, variable, family_mode, path, is_follower=False):
-        if (HIGH_COMPATIBILITY and variable.type == 'choice' and variable.mode != modes_level[-1] and variable.mandatory is True and path in self.default_has_no_value):
-            variable.mode = modes_level[0]
-        if variable.type == 'choice' and is_follower and family_mode == modes_level[0] and variable.mandatory is True:
-            variable.mode = modes_level[0]
+    def annotate_variable(self, variable, family_mode, path, is_follower=False):
         # if the variable is mandatory and doesn't have any value
         # then the variable's mode is set to 'basic'
         has_value = hasattr(variable, 'value')
-        if (path not in self.has_calc and variable.mandatory is True and
-                (not has_value or is_follower) and variable.type != 'choice'):
+        if variable.mandatory is True and (not has_value or is_follower):
             variable.mode = modes_level[0]
-        if has_value:
-            if not HIGH_COMPATIBILITY or (not path.startswith('creole.services.') \
-                    and path not in self.force_no_value and path not in self.force_not_mandatory):
+        if variable.mode != None and modes[variable.mode] < modes[family_mode] and (not is_follower or variable.mode != modes_level[0]):
+            variable.mode = family_mode
+        if has_value and path not in self.force_not_mandatory:
             variable.mandatory = True
         if variable.hidden is True:
             variable.frozen = True
             if not variable.auto_save is True and 'force_default_on_freeze' not in vars(variable):
                 variable.force_default_on_freeze = True
-        if variable.name == 'frozen' and not variable.auto_save is True:
-            variable.force_default_on_freeze = True
-        if variable.mode != None and not is_follower and modes[variable.mode] < modes[family_mode]:
-            variable.mode = family_mode
-        if variable.mode != None and variable.mode != modes_level[0] and modes[variable.mode] < modes[family_mode]:
-            variable.mode = family_mode
 
-    def default_variable_options(self):
-        if hasattr(self.space, 'variables'):
+    def convert_variable(self):
+        if not hasattr(self.space, 'variables'):
+            return
         for families in self.space.variables.values():
             if hasattr(families, 'family'):
                 for family in families.family.values():
@@ -581,14 +534,6 @@ class SpaceAnnotator(object):
                                 variable.type = 'string'
                             if variable.type != 'symlink' and not hasattr(variable, 'description'):
                                 variable.description = variable.name
-
-    def variable_submulti(self):
-        if hasattr(self.space, 'variables'):
-            for families in self.space.variables.values():
-                if hasattr(families, 'family'):
-                    for family in families.family.values():
-                        if hasattr(family, 'variable'):
-                            for variable in family.variable.values():
                             if variable.submulti:
                                 variable.multi = 'submulti'
 
@@ -601,7 +546,7 @@ class SpaceAnnotator(object):
                             for variable in family.variable.values():
                                 if variable.auto_freeze:
                                     new_condition = self.objectspace.condition()
-                                    new_condition.name = 'auto_frozen_if_in'
+                                    new_condition.name = 'auto_hidden_if_not_in'
                                     new_condition.namespace = variables.name
                                     new_condition.source = FREEZE_AUTOFREEZE_VARIABLE
                                     new_param = self.objectspace.param()
@@ -609,7 +554,7 @@ class SpaceAnnotator(object):
                                     new_condition.param = [new_param]
                                     new_target = self.objectspace.target()
                                     new_target.type = 'variable'
-                                    if variables.name == 'creole':
+                                    if variables.name == VARIABLE_NAMESPACE:
                                         path = variable.name
                                     else:
                                         path = variable.namespace + '.' + family.name + '.' + variable.name
@@ -620,13 +565,18 @@ class SpaceAnnotator(object):
                                     self.space.constraints.condition.append(new_condition)
 
     def _set_valid_enum(self, variable, values, type_):
-        if isinstance(values, list):
         variable.mandatory = True
         variable.choice = []
         choices = []
         for value in values:
             choice = self.objectspace.choice()
+            try:
+                if type_ in CONVERSION:
+                    choice.name = CONVERSION[type_](value)
+                else:
                     choice.name = str(value)
+            except:
+                raise CreoleDictConsistencyError(_(f'unable to change type of a valid_enum entry "{value}" is not a valid "{type_}" for "{variable.name}"'))
             choices.append(choice.name)
             choice.type = type_
             variable.choice.append(choice)
@@ -635,16 +585,17 @@ class SpaceAnnotator(object):
         if hasattr(variable, 'value'):
             for value in variable.value:
                 value.type = type_
-                    if value.name not in choices:
+                if type_ in CONVERSION:
+                    cvalue = CONVERSION[type_](value.name)
+                else:
+                    cvalue = value.name
+                if cvalue not in choices:
                     raise CreoleDictConsistencyError(_('value "{}" of variable "{}" is not in list of all expected values ({})').format(value.name, variable.name, choices))
         else:
             new_value = self.objectspace.value()
             new_value.name = values[0]
             new_value.type = type_
             variable.value = [new_value]
-        else:
-            # probe choice
-            variable.choice = values
         variable.type = 'choice'
 
     def _convert_valid_enum(self, variable, path):
@@ -708,7 +659,7 @@ class SpaceAnnotator(object):
                                     else:
                                         is_follower = False
                                     path = '{}.{}.{}'.format(family.path, variable.name, follower.name)
-                                    self._annotate_variable(follower, family_mode, path, is_follower)
+                                    self.annotate_variable(follower, family_mode, path, is_follower)
                                     # leader's mode is minimum level
                                     if modes[variable.variable[0].mode] > modes[follower.mode]:
                                         follower.mode = variable.variable[0].mode
@@ -721,83 +672,64 @@ class SpaceAnnotator(object):
                                 if variable.auto_freeze is True and variable.mode != modes_level[-1]:
                                     variable.mode = modes_level[0]
                                 path = '{}.{}'.format(family.path, variable.name)
-                                self._annotate_variable(variable, family_mode, path)
+                                self.annotate_variable(variable, family_mode, path)
 
-    def get_variable(self, name):  # pylint: disable=C0111
-        return self.paths.get_variable_obj(name)
-
-    def convert_autofill(self):  # pylint: disable=C0111
-        if hasattr(self.space, 'constraints'):
-            self.convert_duplicate_autofill(self.space.constraints)
-            if 'auto' in vars(self.space.constraints):
-                self.convert_auto(self.space.constraints.auto, self.space)
-            if 'fill' in vars(self.space.constraints):
-                self.convert_fill(self.space.constraints.fill, self.space)
-
-    def convert_duplicate_autofill(self, constraints):
-        """ Remove duplicate auto or fill for a variable
-        This variable must be redefined
-        """
-        fills = {}
+    def convert_fill(self):  # pylint: disable=C0111,R0912
+        if not hasattr(self.space, 'constraints') or not hasattr(self.space.constraints, 'fill'):
+            return
         # sort fill/auto by index
-        if 'fill' in vars(constraints):
-            for idx, fill in enumerate(constraints.fill):
-                fills[fill.index] = {'idx': idx, 'fill': fill, 'type': 'fill'}
-        if 'auto' in vars(constraints):
-            for idx, fill in enumerate(constraints.auto):
-                fills[fill.index] = {'idx': idx, 'fill': fill, 'type': 'auto'}
+        fills = {fill.index: fill for idx, fill in enumerate(self.space.constraints.fill)}
         indexes = list(fills.keys())
         indexes.sort()
-        targets = {}
-        remove_autos = []
-        remove_fills = []
+        targets = []
+        eosfunc = dir(self.eosfunc)
         for idx in indexes:
-            fill = fills[idx]['fill']
-            redefine = bool(fill.redefine)
-            if fill.target in targets:
-                if redefine:
-                    if targets[fill.target][1] == 'auto':
-                        remove_autos.append(targets[fill.target][0])
-                    else:
-                        remove_fills.append(targets[fill.target][0])
-                else:
-                    raise CreoleDictConsistencyError(_("An auto or fill already exists "
-                                                       "for the target: {}").format(
-                                                           fill.target))
-            targets[fill.target] = (fills[idx]['idx'], fills[idx]['type'])
-        remove_autos.sort(reverse=True)
-        for idx in remove_autos:
-            constraints.auto.pop(idx)
-        remove_fills.sort(reverse=True)
-        for idx in remove_fills:
-            constraints.fill.pop(idx)
+            fill = fills[idx]
+            # test if it's redefined calculation
+            if fill.target in targets and not fill.redefine:
+                raise CreoleDictConsistencyError(_(f"A fill already exists for the target: {fill.target}"))
+            targets.append(fill.target)
+            #
+            if not fill.name in eosfunc:
+                raise CreoleDictConsistencyError(_('cannot find fill function {}').format(fill.name))
 
-    def convert_auto(self, auto_space, space):  # pylint: disable=C0111
-        for auto in auto_space:
-            if HIGH_COMPATIBILITY and auto.target in self.has_frozen_if_in_condition:
-                # if a variable has a 'frozen_if_in' condition
-                # then we change the 'auto' variable as a 'fill' variable
+            namespace = fill.namespace
+            # let's replace the target by the path
+            fill.target = self.paths.get_variable_path(fill.target,
+                                                       namespace)
+
+            value = self.objectspace.value()
+            value.type = 'calculation'
+            value.name = fill.name
+            if hasattr(fill, 'param'):
+                param_to_delete = []
+                for fill_idx, param in enumerate(fill.param):
+                    if param.type not in TYPE_PARAM_FILL:
+                        raise CreoleDictConsistencyError(_(f'cannot use {param.type} type as a param in a fill/auto'))
+                    if param.type != 'string' and not hasattr(param, 'text'):
+                        raise CreoleDictConsistencyError(_(f"All '{param.type}' variables shall have a value in order to calculate {fill.target}"))
+                    if param.type == 'variable':
+                        try:
+                            param.text, suffix = self.paths.get_variable_path(param.text,
+                                                                              namespace,
+                                                                              with_suffix=True)
+                            if suffix:
+                                param.suffix = suffix
+                        except CreoleDictConsistencyError as err:
+                            if param.optional is False:
+                                raise err
+                            param_to_delete.append(fill_idx)
                             continue
-            # an auto is a fill with "hidden" and "frozen" properties
-            variable = self.get_variable(auto.target)
-            if variable.auto_freeze:
-                raise CreoleDictConsistencyError(_('variable with auto value '
-                                                   'cannot be auto_freeze').format(auto.target))
-            if variable.auto_save:
-                raise CreoleDictConsistencyError(_('variable with auto value '
-                                                   'cannot be auto_save').format(auto.target))
-            leader = self.paths.get_leader(auto.target)
-            if leader is None or variable.name != leader:
-                variable.hidden = True
-            else:
-                leadership = self.paths.get_family_obj(self.paths.get_variable_family_path(auto.target))
-                leadership.hidden = True
-            variable.frozen = True
-            variable.force_default_on_freeze = True
-        if 'fill' not in vars(space.constraints):
-            space.constraints.fill = []
-        space.constraints.fill.extend(auto_space)
-        del space.constraints.auto
+                    if param.hidden is True:
+                        param.transitive = False
+                    param.hidden = None
+                param_to_delete.sort(reverse=True)
+                for param_idx in param_to_delete:
+                    fill.param.pop(param_idx)
+                value.param = fill.param
+            variable = self.paths.get_variable_obj(fill.target)
+            variable.value = [value]
+        del self.space.constraints.fill
 
     def filter_separators(self):  # pylint: disable=C0111,R0201
         # FIXME devrait etre dans la variable
@@ -827,8 +759,8 @@ class SpaceAnnotator(object):
                     raise CreoleDictConsistencyError(_('Cannot load {}').format(param.text))
             elif param.type == 'python':
                 try:
+                    #values = eval(param.text, {'eosfunc': self.eosfunc, '__builtins__': {'range': range, 'str': str}})
                     values = eval(param.text, {'eosfunc': self.eosfunc, '__builtins__': {'range': range, 'str': str}})
-                    #FIXME : eval('[str(i) for i in range(3, 13)]', {'eosfunc': eosfunc, '__builtins__': {'range': range, 'str': str}})
                 except NameError:
                     raise CreoleDictConsistencyError(_('The function {} is unknown').format(param.text))
             if not isinstance(values, list):
@@ -841,87 +773,54 @@ class SpaceAnnotator(object):
             values = param.text
         return values
 
-    def filter_check(self):  # pylint: disable=C0111
-        # valid param in check
-        if not hasattr(self.space, 'constraints') or not hasattr(self.space.constraints, 'check'):
-            return
-        space = self.space.constraints.check
+    def check_check(self):
         remove_indexes = []
-        for check_idx, check in enumerate(space):
-            namespace = check.namespace
+        functions = dir(self.eosfunc)
+        functions.extend(['valid_enum', 'valid_in_network', 'valid_differ'])
+        for check_idx, check in enumerate(self.space.constraints.check):
+            if not check.name in functions:
+                raise CreoleDictConsistencyError(_('cannot find check function {}').format(check.name))
             if hasattr(check, 'param'):
                 param_option_indexes = []
                 for idx, param in enumerate(check.param):
                     if param.type not in TYPE_PARAM_CHECK:
                         raise CreoleDictConsistencyError(_('cannot use {} type as a param in check for {}').format(param.type, check.target))
-                    if param.type == 'eole':
-                        param.type = 'variable'
-                    if param.type == 'variable':
-                        # if HIGH_COMPATIBILITY and param.text.startswith('container_ip'):
-                        #     if param.optional is True:
-                        #         param_option_indexes.append(idx)
-                        try:
-                            param.text = self.paths.get_variable_path(param.text, namespace)
-                        except CreoleDictConsistencyError as err:
+                    if param.type == 'variable' and not self.paths.path_is_defined(param.text):
                         if param.optional is True:
                             param_option_indexes.append(idx)
                         else:
-                                raise err
+                            raise CreoleDictConsistencyError(_(f'unknown param {param.text} in check'))
                 param_option_indexes = list(set(param_option_indexes))
                 param_option_indexes.sort(reverse=True)
                 for idx in param_option_indexes:
                     check.param.pop(idx)
-                if not HIGH_COMPATIBILITY and check.param == []:
+                if check.param == []:
                     remove_indexes.append(check_idx)
         remove_indexes.sort(reverse=True)
         for idx in remove_indexes:
-            del space[idx]
-        variables = {}
-        for index, check in enumerate(space):
+            del self.space.constraints.check[idx]
+
+    def check_replace_text(self):
+        for check_idx, check in enumerate(self.space.constraints.check):
+            if hasattr(check, 'param'):
                 namespace = check.namespace
-            if HIGH_COMPATIBILITY:
-                if not self.paths.path_is_defined(check.target):
-                    continue
+                for idx, param in enumerate(check.param):
+                    if param.type == 'variable':
+                        param.text = self.paths.get_variable_path(param.text, namespace)
             check.is_in_leadership = self.paths.get_leader(check.target) != None
             # let's replace the target by the path
             check.target = self.paths.get_variable_path(check.target, namespace)
-            if check.target not in variables:
-                variables[check.target] = []
-            variables[check.target].append((index, check))
-        # remove check already set for a variable
+
+    def check_valid_enum(self):
         remove_indexes = []
-        for checks in variables.values():
-            names = {}
-            for idx, check in checks:
-                if HIGH_COMPATIBILITY and check.name == 'valid_enum':
-                    redefine = True
-                else:
-                    redefine = False
-                    #redefine = bool(check.redefine)
-                if redefine and check.name in names:
-                    remove_indexes.append(names[check.name])
-                    del names[check.name]
-                names[check.name] = idx
-                del check.index
-        remove_indexes.sort(reverse=True)
-        for idx in remove_indexes:
-            del space[idx]
-        remove_indexes = []
-        functions = dir(self.eosfunc)
-        functions.extend(['valid_enum', 'valid_in_network', 'valid_differ'])
-        for idx, check in enumerate(space):
-            if not check.name in functions:
-                raise CreoleDictConsistencyError(_('cannot find check function {}').format(check.name))
-            #is_probe = not check.name in self.eosfunc.func_on_zephir_context
-            #if is_probe:
-            #    raise CreoleDictConsistencyError(_('cannot have a check with probe function ({})').format(check.name))
+        for idx, check in enumerate(self.space.constraints.check):
             if check.name == 'valid_enum':
                 proposed_value_type = False
                 remove_params = []
                 for param_idx, param in enumerate(check.param):
                     if hasattr(param, 'name') and param.name == 'checkval':
                         try:
-                            proposed_value_type = self.objectspace._convert_boolean(param.text) == False
+                            proposed_value_type = self.objectspace.convert_boolean(param.text) == False
                             remove_params.append(param_idx)
                         except TypeError as err:
                             raise CreoleDictConsistencyError(_('cannot load checkval value for variable {}: {}').format(check.target, err))
@@ -936,30 +835,30 @@ class SpaceAnnotator(object):
                                                        'for valid_enum for variable {}'
                                                        '').format(check.target))
                 param = check.param[0]
+                if check.target in self.valid_enums:
+                    raise CreoleDictConsistencyError(_('valid_enum already set for {}'
+                                                       '').format(check.target))
                 if proposed_value_type:
                     if param.type == 'variable':
                         try:
                             values = self.load_params_in_validenum(param)
                         except NameError as err:
                             raise CreoleDictConsistencyError(_('cannot load value for variable {}: {}').format(check.target, err))
-                        add_value = True
-                        if HIGH_COMPATIBILITY and check.is_in_leadership:
-                            add_value = False
-                        if add_value and values:
+                        add_default_value = not check.is_in_leadership
+                        if add_default_value and values:
                             self.force_value[check.target] = values[0]
                 else:
-                    if check.target in self.valid_enums:
-                        raise CreoleDictConsistencyError(_('valid_enum already set for {}'
-                                                           '').format(check.target))
                     values = self.load_params_in_validenum(param)
                     self.valid_enums[check.target] = {'type': param.type,
                                                       'values': values}
                     remove_indexes.append(idx)
         remove_indexes.sort(reverse=True)
         for idx in remove_indexes:
-            del space[idx]
+            del self.space.constraints.check[idx]
+
+    def check_change_warning(self):
         #convert level to "warnings_only" and hidden to "transitive"
-        for check in space:
+        for check in self.space.constraints.check:
             if check.level == 'warning':
                 check.warnings_only = True
             else:
@@ -971,6 +870,14 @@ class SpaceAnnotator(object):
                         check.transitive = False
                     param.hidden = None
 
+    def filter_check(self):  # pylint: disable=C0111
+        # valid param in check
+        if not hasattr(self.space, 'constraints') or not hasattr(self.space.constraints, 'check'):
+            return
+        self.check_check()
+        self.check_replace_text()
+        self.check_valid_enum()
+        self.check_change_warning()
         if not self.space.constraints.check:
             del self.space.constraints.check
 
@@ -1010,103 +917,11 @@ class SpaceAnnotator(object):
             variable.check.append(check_)
         del self.space.constraints.check
 
-
-    def convert_fill(self, fill_space, space):  # pylint: disable=C0111,R0912
-        fills = {}
-        # sort fill/auto by index
-        for idx, fill in enumerate(fill_space):
-            fills[fill.index] = {'idx': idx, 'fill': fill}
-            del fill.index
-        indexes = list(fills.keys())
-        indexes.sort()
-        del_idx = []
-        for idx in indexes:
-            fill = fills[idx]['fill']
-            variable = self.get_variable(fill.target)
-            if hasattr(variable, 'value'):
-                del variable.value
-            namespace = fill.namespace
-            # let's replace the target by the path
-            fill.target = self.paths.get_variable_path(fill.target, namespace)
-            if not fill.name in dir(self.eosfunc):
-                raise CreoleDictConsistencyError(_('cannot find fill function {}').format(fill.name))
-            #is_probe = not fill.name in self.eosfunc.func_on_zephir_context
-            if hasattr(fill, 'param'):
-                for param in fill.param:
-                    if param.type not in TYPE_PARAM_FILL:
-                        raise CreoleDictConsistencyError(_('cannot use {} type as a param '
-                                                           'in a fill/auto').format(param.type))
-                    if param.type == 'eole':
-                        param.type = 'variable'
-                param_option_indexes = []
-                for fill_idx, param in enumerate(fill.param):
-                    if not hasattr(param, 'text') and \
-                            (param.type == 'variable' or param.type == 'number' or \
-                                param.type == 'python'):
-                        raise CreoleDictConsistencyError(_("All '{}' variables shall be set in "
-                                                           "order to calculate {}").format(
-                                                               param.type,
-                                                               fill.target))
-                    # if param.type == 'container':
-                    #     param.type = 'eole'
-                    #     param.text = 'container_ip_{}'.format(param.text)
-                    if param.type == 'variable':
-                        #if is_probe:
-                        #    raise CreoleDictConsistencyError(_('Function {0} used to calculate {1} '
-                        #                                       'is executed on remote server, '
-                        #                                       'so cannot depends to an '
-                        #                                       'other variable'
-                        #                                      ).format(fill.name, fill.target))
-                        # if HIGH_COMPATIBILITY and param.text.startswith('container_ip'):
-                        #     if param.optional is True:
-                        #         param_option_indexes.append(fill_idx)
-                        try:
-                            param.text = self.paths.get_variable_path(param.text, namespace)
-                        except CreoleDictConsistencyError as err:
-                            if param.optional is True:
-                                param_option_indexes.append(fill_idx)
-                            else:
-                                raise err
-                param_option_indexes = list(set(param_option_indexes))
-                param_option_indexes.sort(reverse=True)
-                for param_idx in param_option_indexes:
-                    fill.param.pop(param_idx)
-            self.has_calc.append(fill.target)
-
-            #if is_probe:
-            #    variable.force_default_on_freeze = False
-            #    self.objectspace.probe_variables.append(fill)
-            #    del_idx.append(fills[idx]['idx'])
-        del_idx.sort(reverse=True)
-        for idx in del_idx:
-            space.constraints.fill.pop(idx)
-        for fill in space.constraints.fill:
-            variable = self.paths.get_variable_obj(fill.target)
-            value = self.objectspace.value()
-            value.type = 'calculation'
-            value.name = fill.name
-            if hasattr(fill, 'param'):
-                for param in fill.param:
-                    if param.hidden is True:
-                        param.transitive = False
-                    param.hidden = None
-                value.param = fill.param
-            if not hasattr(variable, 'value'):
-                variable.value = []
-            variable.value.append(value)
-            self.force_not_mandatory.append(fill.target)
-        del space.constraints.fill
-
     def filter_targets(self):  # pylint: disable=C0111
         for condition_idx, condition in enumerate(self.space.constraints.condition):
             namespace = condition.namespace
-            del_idx = []
             for idx, target in enumerate(condition.target):
                 if target.type == 'variable':
-                    if (hasattr(target, 'optional') and target.optional is True and
-                            not self.paths.path_is_defined(target.name)):
-                        del_idx.append(idx)
-                        continue
                     if condition.source == target.name:
                         raise CreoleDictConsistencyError(_('target name and source name must be different: {}').format(condition.source))
                     target.name = self.paths.get_variable_path(target.name, namespace)
@@ -1115,84 +930,8 @@ class SpaceAnnotator(object):
                         target.name = self.paths.get_family_path(target.name, namespace)
                     except KeyError:
                         raise CreoleDictConsistencyError(_('cannot found family {}').format(target.name))
-            del_idx = list(set(del_idx))
-            del_idx.sort(reverse=True)
-            for idx in del_idx:
-                condition.target.pop(idx)
 
-    def filter_condition_servicelist(self):
-        # automatic generation of the service_access lists
-        # and the service_restriction lists from the servicelist
-        for condition in self.space.constraints.condition:
-            if hasattr(condition, 'target'):
-                new_targets = []
-                for target in condition.target:
-                    if target.type == 'servicelist':
-                        new_target = copy(target)
-                        new_target.type = 'service_accesslist'
-                        new_target.name = '___auto_{}'.format(new_target.name)
-                        new_targets.append(new_target)
-
-                        new_target = copy(target)
-                        new_target.type = 'service_restrictionlist'
-                        new_target.name = '___auto_{}'.format(new_target.name)
-                        new_targets.append(new_target)
-                condition.target.extend(new_targets)
-
-    def check_condition_without_target(self):
-        for condition in self.space.constraints.condition:
-            if not hasattr(condition, 'target'):
-                raise CreoleDictConsistencyError(_('target is mandatory in condition'))
-
-    def check_condition_fallback_not_exists(self, fallback_variables, fallback_lists):
-        # a condition with a fallback **and** the source variable doesn't exist
-        remove_conditions = []
-        for idx, condition in enumerate(self.space.constraints.condition):
-            if (hasattr(condition, 'fallback') and condition.fallback is True and
-                    not self.paths.path_is_defined(condition.source)):
-                for target in condition.target:
-                    if target.type in ['variable', 'family']:
-                        name = target.name.split('.')[-1]
-                        if target.type == 'variable':
-                            variable = self.get_variable(name)
-                        else:
-                            variable = self.paths.get_family_obj(name)
-                        if condition.name in ['disabled_if_in']:
-                            variable.disabled = True
-                        if condition.name in ['mandatory_if_in']:
-                            variable.mandatory = True
-                        if condition.name in ['disabled_if_in', 'disabled_if_not_in',
-                                              'frozen_if_in', 'frozen_if_not_in']:
-                            variable.hidden = False
-                        if HIGH_COMPATIBILITY:
-                            fallback_variables.append(name)
-                    else:
-                        listname = target.type
-                        if not listname.endswith('list'):
-                            raise Exception('not yet implemented')
-                        listvars = self.objectspace.list_conditions.get(listname,
-                                                                        {}).get(target.name)
-                        if listvars:
-                            for listvar in listvars:
-                                try:
-                                    variable = self.get_variable(listvar)
-                                except CreoleDictConsistencyError:
-                                    variable = self.paths.get_family_obj(listvar)
-                                if condition.name in ['disabled_if_in']:
-                                    variable.disabled = True
-                                if condition.name in ['mandatory_if_in']:
-                                    variable.mandatory = True
-                                if condition.name in ['disabled_if_in', 'disabled_if_not_in',
-                                                      'frozen_if_in', 'frozen_if_not_in']:
-                                    variable.hidden = False
-                                fallback_lists.append(listvar)
-                remove_conditions.append(idx)
-        remove_conditions = list(set(remove_conditions))
-        remove_conditions.sort(reverse=True)
-        for idx in remove_conditions:
-            self.space.constraints.condition.pop(idx)
-
-    def convert_xxxlist_to_variable(self, fallback_lists):  # pylint: disable=C0111
+    def convert_xxxlist_to_variable(self):  # pylint: disable=C0111
         # transform *list to variable or family
         for condition_idx, condition in enumerate(self.space.constraints.condition):
             new_targets = []
@@ -1206,14 +945,8 @@ class SpaceAnnotator(object):
                                                                     {}).get(target.name)
                     if listvars:
                         for listvar in listvars:
-                            if listvar in fallback_lists:
-                                continue
-                            try:
-                                variable = self.get_variable(listvar)
+                            variable = self.paths.get_variable_obj(listvar)
                             type_ = 'variable'
-                            except CreoleDictConsistencyError:
-                                variable = self.paths.get_family_obj(listvar)
-                                type_ = 'family'
                             new_target = self.objectspace.target()
                             new_target.type = type_
                             new_target.name = listvar
@@ -1227,25 +960,71 @@ class SpaceAnnotator(object):
             condition.target.extend(new_targets)
 
     def check_condition(self):
-        # if condition.name == 'hidden_if_in':
-        #     condition.name = 'disabled_if_in'
-        # elif condition.name == 'hidden_if_not_in':
-        #     condition.name = 'disabled_if_not_in'
         for condition in self.space.constraints.condition:
-            if condition.name not in ['disabled_if_in', 'disabled_if_not_in', 'frozen_if_in', 'auto_frozen_if_in',
-                                      'frozen_if_not_in', 'mandatory_if_in', 'mandatory_if_not_in']:
-                raise CreoleDictConsistencyError(_('unknown condition {}').format(condition.name))
+            if condition.name not in ['disabled_if_in', 'disabled_if_not_in', 'hidden_if_in', 'auto_hidden_if_not_in',
+                                      'hidden_if_not_in', 'mandatory_if_in', 'mandatory_if_not_in']:
+                raise CreoleDictConsistencyError(_(f'unknown condition {condition.name}'))
 
     def check_params(self):
         for condition in self.space.constraints.condition:
             for param in condition.param:
                 if param.type not in TYPE_PARAM_CONDITION:
-                    raise CreoleDictConsistencyError(_('cannot use {} type as a param '
-                                                       'in a condition').format(param.type))
-                if param.type == 'eole':
-                    param.type = 'variable'
+                    raise CreoleDictConsistencyError(_(f'cannot use {param.type} type as a param in a condition'))
 
-    def check_choice_option_condition(self, force_remove_targets):
+    def check_target(self):
+        for condition in self.space.constraints.condition:
+            if not hasattr(condition, 'target'):
+                raise CreoleDictConsistencyError(_('target is mandatory in condition'))
+            for target in condition.target:
+                if target.type.endswith('list') and condition.name not in ['disabled_if_in', 'disabled_if_not_in']:
+                    raise CreoleDictConsistencyError(_(f'target in condition for {target.type} not allow in {condition.name}'))
+
+    def check_condition_fallback_optional(self):
+        # a condition with a fallback **and** the source variable doesn't exist
+        remove_conditions = []
+        for idx, condition in enumerate(self.space.constraints.condition):
+            remove_targets = []
+            if condition.fallback is True and not self.paths.path_is_defined(condition.source):
+                for target in condition.target:
+                    if target.type in ['variable', 'family']:
+                        if target.name.startswith(VARIABLE_NAMESPACE + '.'):
+                            name = target.name.split('.')[-1]
+                        else:
+                            name = target.name
+                        if target.type == 'variable':
+                            variable = self.paths.get_variable_obj(name)
+                        else:
+                            variable = self.paths.get_family_obj(name)
+                        if condition.name == 'disabled_if_in':
+                            variable.disabled = True
+                        if condition.name == 'mandatory_if_in':
+                            variable.mandatory = True
+                        if condition.name == 'hidden_if_in':
+                            variable.hidden = True
+                    else:
+                        listname = target.type
+                        listvars = self.objectspace.list_conditions.get(listname,
+                                                                        {}).get(target.name, None)
+                        if listvars is not None:
+                            for listvar in listvars:
+                                variable = self.paths.get_variable_obj(listvar)
+                                if condition.name in ['disabled_if_in']:
+                                    variable.value[0].name = False
+                            del self.objectspace.list_conditions[listname][target.name]
+                remove_conditions.append(idx)
+            for idx, target in enumerate(condition.target):
+                if target.optional is True and not self.paths.path_is_defined(target.name):
+                    remove_targets.append(idx)
+            remove_targets = list(set(remove_targets))
+            remove_targets.sort(reverse=True)
+            for idx in remove_targets:
+                condition.target.pop(idx)
+        remove_conditions = list(set(remove_conditions))
+        remove_conditions.sort(reverse=True)
+        for idx in remove_conditions:
+            self.space.constraints.condition.pop(idx)
+
+    def check_choice_option_condition(self):
         # remove condition for ChoiceOption that don't have param
         remove_conditions = []
         for condition_idx, condition in enumerate(self.space.constraints.condition):
@@ -1267,69 +1046,54 @@ class SpaceAnnotator(object):
                 for idx in remove_param:
                     del condition.param[idx]
                 if condition.param == []:
+                    remove_targets = []
                     for target in condition.target:
-                        if target.name.startswith('creole.'):
+                        if target.name.startswith(f'{VARIABLE_NAMESPACE}.'):
                             name = target.name.split('.')[-1]
                         else:
                             name = target.name
                         if target.type == 'variable':
-                            variable = self.get_variable(name)
+                            variable = self.paths.get_variable_obj(name)
                         else:
                             variable = self.paths.get_family_obj(name)
                         if condition.name == 'disabled_if_not_in':
                             variable.disabled = True
-                            force_remove_targets.setdefault(condition.name,
-                                                            []).append(target.name)
-                        elif condition.name == 'frozen_if_not_in':
+                        elif condition.name == 'hidden_if_not_in':
                             variable.hidden = True
-                            force_remove_targets.setdefault(condition.name,
-                                                            []).append(target.name)
                         elif condition.name == 'mandatory_if_not_in':
                             variable.mandatory = True
-                            force_remove_targets.setdefault(condition.name,
-                                                            []).append(target.name)
-                        elif HIGH_COMPATIBILITY and condition.name == 'disabled_if_in':
-                            variable.hidden = False
+                    remove_targets = list(set(remove_targets))
+                    remove_targets.sort(reverse=True)
+                    for target_idx in remove_targets:
+                        condition.target.pop(target_idx)
                     remove_conditions.append(condition_idx)
         remove_conditions = list(set(remove_conditions))
         remove_conditions.sort(reverse=True)
         for idx in remove_conditions:
             self.space.constraints.condition.pop(idx)
 
-    def manage_variable_property(self, force_remove_targets, fallback_variables):
+    def manage_variable_property(self):
         for condition in self.space.constraints.condition:
-            remove_targets = []
             #parse each variable and family
             for target_idx, target in enumerate(condition.target):
-                if target.name in force_remove_targets.get(condition.name, []):
-                    remove_targets.append(target_idx)
-                if target.name.startswith('creole.'):
+                if target.name.startswith(f'{VARIABLE_NAMESPACE}.'):
                     name = target.name.split('.')[-1]
                 else:
                     name = target.name
                 if target.type == 'variable':
-                    variable = self.get_variable(name)
+                    variable = self.paths.get_variable_obj(name)
                 else:
                     variable = self.paths.get_family_obj(name)
-                if name in fallback_variables:
-                    remove_targets.append(target_idx)
-                    continue
-                if condition.name in ['disabled_if_in', 'disabled_if_not_in',
-                                      'frozen_if_in', 'frozen_if_not_in']:
+                if condition.name in ['hidden_if_in', 'hidden_if_not_in']:
                     variable.hidden = False
                 if condition.name in ['mandatory_if_in', 'mandatory_if_not_in']:
                     variable.mandatory = False
-                if HIGH_COMPATIBILITY and condition.name in ['frozen_if_in',
-                                                             'frozen_if_not_in']:
-                    self.has_frozen_if_in_condition.append(name)
+                if HIGH_COMPATIBILITY and condition.name in ['hidden_if_in',
+                                                             'hidden_if_not_in']:
+                    self.has_hidden_if_in_condition.append(name)
                 if condition.name in ['mandatory_if_in', 'mandatory_if_not_in']:
                     self.force_not_mandatory.append(target.name)
 
-            remove_targets = list(set(remove_targets))
-            remove_targets.sort(reverse=True)
-            for target_idx in remove_targets:
-                condition.target.pop(target_idx)
-
     def remove_condition_with_empty_target(self):
         remove_conditions = []
         for condition_idx, condition in enumerate(self.space.constraints.condition):
@@ -1343,53 +1107,37 @@ class SpaceAnnotator(object):
     def filter_condition(self):  # pylint: disable=C0111
         if not hasattr(self.space, 'constraints') or not hasattr(self.space.constraints, 'condition'):
             return
-        fallback_variables = []
-        fallback_lists = []
-        force_remove_targets = {}
         self.check_condition()
         self.check_params()
-        self.check_condition_without_target()
-        self.filter_condition_servicelist()
-        self.check_condition_fallback_not_exists(fallback_variables, fallback_lists)
+        self.check_target()
+        self.check_condition_fallback_optional()
         self.filter_targets()
-        self.convert_xxxlist_to_variable(fallback_lists)
-        self.check_choice_option_condition(force_remove_targets)
-        self.manage_variable_property(force_remove_targets, fallback_variables)
+        self.convert_xxxlist_to_variable()
+        self.check_choice_option_condition()
+        self.manage_variable_property()
         self.remove_condition_with_empty_target()
         for condition in self.space.constraints.condition:
-            if condition.name == 'disabled_if_in':
+            inverse = condition.name.endswith('_if_not_in')
+            if condition.name.startswith('disabled_if_'):
                 actions = ['disabled']
-                inverse = False
-            elif condition.name == 'disabled_if_not_in':
-                actions = ['disabled']
-                inverse = True
-            elif condition.name == 'frozen_if_in':
+            elif condition.name.startswith('hidden_if_'):
                 actions = ['frozen', 'hidden', 'force_default_on_freeze']
-                inverse = False
-            elif condition.name == 'frozen_if_not_in':
-                actions = ['frozen', 'hidden', 'force_default_on_freeze']
-                inverse = True
-            elif condition.name == 'mandatory_if_in':
+            elif condition.name.startswith('mandatory_if_'):
                 actions = ['mandatory']
-                inverse = False
-            elif condition.name == 'mandatory_if_not_in':
-                actions = ['mandatory']
-                inverse = True
-            elif condition.name == 'auto_frozen_if_in':
+            elif condition.name == 'auto_hidden_if_not_in':
                 actions = ['auto_frozen']
-                inverse = True
             for param in condition.param:
                 if hasattr(param, 'text'):
                     param = param.text
                 else:
                     param = None
                 for target in condition.target:
-                    if target.name.startswith('creole.'):
+                    if target.name.startswith(f'{VARIABLE_NAMESPACE}.'):
                         name = target.name.split('.')[-1]
                     else:
                         name = target.name
                     if target.type == 'variable':
-                        variable = self.get_variable(name)
+                        variable = self.paths.get_variable_obj(name)
                     else:
                         variable = self.paths.get_family_obj(name)
                     if not hasattr(variable, 'property'):

src/rougail/data/rougail.dtd

@@ -13,7 +13,7 @@
 
 #    Forked by:
 #    Cadoles (http://www.cadoles.com)
-#    Copyright (C) 2019
+#    Copyright (C) 2019-2020
 
 #    distribued with GPL-2 or later license
 
@@ -37,54 +37,22 @@
 <!-- root element    -->
 <!-- =============== -->
 
-<!ELEMENT rougail (services | family_action | variables | constraints | help)*>
+<!ELEMENT rougail (services | variables | constraints | help)*>
 
 <!-- ============== -->
 <!-- files element  -->
 <!-- ============== -->
 
-<!ELEMENT family_action (action)>
-<!ATTLIST family_action name CDATA #REQUIRED>
-<!ATTLIST family_action description CDATA #IMPLIED>
-<!ATTLIST family_action color CDATA #IMPLIED>
-<!ATTLIST family_action image CDATA #IMPLIED>
-<!ELEMENT action ((input* | profile* | ewtapp* | tag* | saltaction*)*)>
-<!ATTLIST action type (form|custom|external|reader|apache) "custom">
-<!ATTLIST action title CDATA #REQUIRED>
-<!ATTLIST action description CDATA #REQUIRED>
-<!ATTLIST action rewrite CDATA #IMPLIED>
-<!ATTLIST action image CDATA #IMPLIED>
-<!ATTLIST action actionlist CDATA #IMPLIED>
-<!-- for apache action -->
-<!ATTLIST action apache_path CDATA #IMPLIED>
-<!ATTLIST action apache_path_type (FilenameOption|SymLinkOption|variable) "FilenameOption">
-<!-- for external action -->
-<!ATTLIST action url CDATA #IMPLIED>
-<!ATTLIST action url_type (URLOption|SymLinkOption|variable) "URLOption">
-<!-- for form action -->
-<!ATTLIST action save (True|False) "False">
-
 <!ELEMENT services (service*)>
 
-<!ELEMENT service ((port* | tcpwrapper* | ip* | interface* | package* | file* | digitalcertificate*)*) >
+<!ELEMENT service ((port* | tcpwrapper* | ip* | interface* | package* | file* | digitalcertificate* | override*)*) >
 <!ATTLIST service name CDATA #REQUIRED>
-<!ATTLIST service method (systemd|upstart|apache|network) "systemd">
-
-<!ELEMENT input (#PCDATA)>
-<!ELEMENT profile (#PCDATA)>
-<!ELEMENT ewtapp (#PCDATA)>
-<!ELEMENT tag (#PCDATA)>
-<!ELEMENT saltaction (#PCDATA)>
 
 <!ELEMENT port (#PCDATA)>
 <!ATTLIST port port_type (PortOption|SymLinkOption|variable) "PortOption">
 <!ATTLIST port portlist CDATA #IMPLIED >
 <!ATTLIST port protocol (tcp|udp) "tcp">
 
-<!ELEMENT tcpwrapper (#PCDATA)>
-<!ATTLIST tcpwrapper tcpwrapper_type (UnicodeOption|SymLinkOption|variable) "UnicodeOption">
-<!ATTLIST tcpwrapper tcpwrapperlist CDATA #IMPLIED >
-
 <!ELEMENT ip (#PCDATA)>
 <!ATTLIST ip iplist CDATA #IMPLIED >
 <!ATTLIST ip ip_type (NetworkOption|SymLinkOption|variable) "NetworkOption">
@@ -93,9 +61,6 @@
 <!ATTLIST ip netmask_type (NetmaskOption|SymLinkOption|variable) "NetmaskOption">
 <!ATTLIST ip netmask CDATA "255.255.255.255">
 
-<!ELEMENT package (#PCDATA)>
-<!ATTLIST package packagelist CDATA #IMPLIED >
-
 <!ELEMENT file EMPTY>
 <!ATTLIST file name CDATA #REQUIRED >
 <!ATTLIST file file_type (UnicodeOption|SymLinkOption|variable) "UnicodeOption">
@@ -106,9 +71,8 @@
 <!ATTLIST file owner CDATA "root">
 <!ATTLIST file group CDATA "root">
 <!ATTLIST file filelist CDATA #IMPLIED >
-<!ATTLIST file mkdir (True|False) "False">
-<!ATTLIST file rm (True|False) "False">
 <!ATTLIST file redefine (True|False) "False">
+<!ATTLIST file templating (True|False) "True">
 
 <!ELEMENT digitalcertificate EMPTY>
 <!ATTLIST digitalcertificate name CDATA #REQUIRED >
@@ -118,12 +82,15 @@
 <!ATTLIST digitalcertificate type CDATA #REQUIRED >
 <!ATTLIST digitalcertificate ca CDATA #REQUIRED >
 
+<!ELEMENT override EMPTY>
+<!ATTLIST override source CDATA #IMPLIED >
+<!ATTLIST override templating (True|False) "True">
+
 <!ELEMENT variables (family*, separators*)>
 <!ELEMENT family (#PCDATA | variable)*>
 <!ATTLIST family name CDATA #REQUIRED>
 <!ATTLIST family description CDATA #IMPLIED>
 <!ATTLIST family mode (basic|normal|expert) "basic">
-<!ATTLIST family icon CDATA #IMPLIED>
 <!ATTLIST family hidden (True|False) "False">
 <!ATTLIST family dynamic CDATA #IMPLIED>
 
@@ -149,11 +116,10 @@
 
 <!ELEMENT separator (#PCDATA)>
 <!ATTLIST separator name CDATA #REQUIRED>
-<!ATTLIST separator never_hidden CDATA #IMPLIED>
 
 <!ELEMENT value (#PCDATA)>
 
-<!ELEMENT constraints ((fill* | check* | condition* | auto* | group*)*)>
+<!ELEMENT constraints ((fill* | check* | condition* | group*)*)>
 <!ELEMENT fill (param*)>
 <!ATTLIST fill name CDATA #REQUIRED>
 <!ATTLIST fill target CDATA #REQUIRED>
@@ -163,17 +129,13 @@
 <!ATTLIST check target CDATA #REQUIRED>
 <!ATTLIST check level (error|warning) "error">
 
-<!ELEMENT auto ((param)*)>
-<!ATTLIST auto name CDATA #REQUIRED>
-<!ATTLIST auto target CDATA #REQUIRED>
-
 <!ELEMENT condition ((target | param)+ )>
 <!ATTLIST condition name CDATA #REQUIRED>
 <!ATTLIST condition source CDATA #REQUIRED>
 <!ATTLIST condition fallback (True|False) "False">
 
-<!ELEMENT group (slave+)>
-<!ATTLIST group master CDATA #REQUIRED>
+<!ELEMENT group (follower+)>
+<!ATTLIST group leader CDATA #REQUIRED>
 <!ATTLIST group description CDATA #IMPLIED>
 
 <!ELEMENT param (#PCDATA)>
@@ -183,9 +145,9 @@
 <!ATTLIST param optional (True|False) "False">
 
 <!ELEMENT target (#PCDATA)>
-<!ATTLIST target type (family|variable|filelist|iplist|portlist|tcpwrapperlist|packagelist|actionlist) "variable">
+<!ATTLIST target type (family|variable|filelist|iplist|portlist) "variable">
 <!ATTLIST target optional (True|False) "False">
 
-<!ELEMENT slave (#PCDATA)>
+<!ELEMENT follower (#PCDATA)>
 
 <!ELEMENT help ((variable* | family*)*)>

src/rougail/error.py

@@ -34,3 +34,7 @@ class CreoleDictConsistencyError(Exception):
     """It's not only that the Creole XML is valid against the Creole DTD
     it's that it is not consistent.
     """
+
+
+class CreoleLoaderError(Exception):
+    pass

src/rougail/i18n.py

@@ -24,7 +24,7 @@ import sys
 import locale
 
 # Application Name
-APP_NAME = 'creole'
+APP_NAME = 'rougail'
 
 # Traduction dir
 APP_DIR = os.path.join(sys.prefix, 'share')
@@ -44,8 +44,8 @@ mo_location = LOCALE_DIR
 
 gettext.find(APP_NAME, mo_location)
 gettext.textdomain(APP_NAME)
-gettext.bind_textdomain_codeset(APP_NAME, "UTF-8")
-gettext.translation(APP_NAME, fallback=True)
+#gettext.bind_textdomain_codeset(APP_NAME, "UTF-8")
+#gettext.translation(APP_NAME, fallback=True)
 
 t = gettext.translation(APP_NAME, fallback=True)
 

src/rougail/loader.py

@@ -1,31 +1,26 @@
-"""creole loader
+"""loader
 flattened XML specific
 """
-from os.path import join, isfile, isdir
-from os import listdir
-#from ast import literal_eval
-from lxml.etree import parse, DTD
+from os.path import join, isfile
+from lxml.etree import DTD
+import imp
 
 from tiramisu import (StrOption, OptionDescription, DynOptionDescription, PortOption,
                       IntOption, ChoiceOption, BoolOption, SymLinkOption, IPOption,
                       NetworkOption, NetmaskOption, DomainnameOption, BroadcastOption,
                       URLOption, EmailOption, FilenameOption, UsernameOption, DateOption,
                       PasswordOption, BoolOption, MACOption, Leadership, submulti,
-                      Params, ParamSelfOption, ParamOption, ParamValue, Calculation, calc_value,
-                      groups, owners)
-from tiramisu.error import ConfigError
+                      Params, ParamSelfOption, ParamOption, ParamDynOption, ParamValue, Calculation, calc_value)
 
 from .config import dtdfilename
 from .i18n import _
-#For compatibility
-from .xmlreflector import HIGH_COMPATIBILITY
-#from . import eosfunc
-from .objspace import CreoleObjSpace
 from .utils import normalize_family
-import imp
+from .annotator import VARIABLE_NAMESPACE
+from .error import CreoleLoaderError
 
 
 FUNC_TO_DICT = ['valid_not_equal']
+KNOWN_TAGS = ['family', 'variable', 'separators', 'leader', 'property']
 
 
 class ConvertDynOptionDescription(DynOptionDescription):
@@ -36,19 +31,11 @@ class ConvertDynOptionDescription(DynOptionDescription):
                                 check_name=False)
 
 
-class CreoleLoaderError(Exception):
-    pass
-
-
 def convert_tiramisu_value(value, obj):
     """
     convertit les variables dans le bon type si nécessaire
     """
-    if value is None:
-        return value
     def _convert_boolean(value):
-        if isinstance(value, bool):
-            return value
         prop = {'True': True,
                 'False': False,
                 'None': None}
@@ -56,10 +43,9 @@ def convert_tiramisu_value(value, obj):
             raise Exception('unknown value {} while trying to cast {} to boolean'.format(value, obj))
         return prop[value]
 
-    func = {IntOption: int, StrOption: str, PortOption: str,
-            DomainnameOption: str, EmailOption: str, URLOption: str,
-            IPOption: str, NetmaskOption: str, NetworkOption: str,
-            BroadcastOption: str, FilenameOption: str,
+    if value is None:
+        return value
+    func = {IntOption: int,
             BoolOption: _convert_boolean}.get(obj, None)
     if func is None:
         return value
@@ -74,7 +60,7 @@ CONVERT_OPTION = {'number': dict(opttype=IntOption),
                   'string': dict(opttype=StrOption),
                   'password': dict(opttype=PasswordOption),
                   'mail': dict(opttype=EmailOption),
-                  'boolean': dict(opttype=BoolOption),
+                  'boolean': dict(opttype=BoolOption, initkwargs={'default': True}),
                   'symlink': dict(opttype=SymLinkOption),
                   'filename': dict(opttype=FilenameOption),
                   'date': dict(opttype=DateOption),
@@ -97,18 +83,15 @@ CONVERT_OPTION = {'number': dict(opttype=IntOption),
                   }
 
 
-class Elt(object):
+class Elt:
     def __init__(self, attrib):
         self.attrib = attrib
 
 
-class PopulateTiramisuObjects(object):
+class PopulateTiramisuObjects:
     def __init__(self):
         self.storage = ElementStorage()
         self.booleans = []
-        self.force_store_values = set()
-        self.separators = {}
-        self.groups = {}
 
     def parse_dtd(self, dtdfilename):
         """Loads the Creole DTD
@@ -127,129 +110,111 @@ class PopulateTiramisuObjects(object):
                         if set(attr.itervalues()) == set(['True', 'False']):
                             self.booleans.append(attr.name)
 
-    def make_tiramisu_objects(self, xmlroot, creolefunc_file):
-        elt = Elt({'name': 'baseoption'})
-        if creolefunc_file is None:
-            self.eosfunc = None
-        else:
-            self.eosfunc = imp.load_source('eosfunc', creolefunc_file)
-        family = Family(elt, self.booleans, self.storage, self.eosfunc)
+    def get_root_family(self):
+        family = Family(Elt({'name': 'baseoption',
+                             'doc': 'baseoption'}),
+                        self.booleans,
+                        self.storage,
+                        self.eosfunc,
+                        )
         self.storage.add('.', family)
+        return family
 
-        elts = {}
-        for elt in xmlroot:
-            elts.setdefault(elt.tag, []).append(elt)
-        list_elts = list(elts.keys())
-        if 'family' in list_elts:
-            list_elts.remove('family')
-            list_elts.insert(0, 'family')
-        for elt in list_elts:
-            xmlelts_ = elts[elt]
-            if elt == 'family':
+    def reorder_family(self, xmlroot):
         xmlelts = []
-                actions = None
-                # `creole` family has to be loaded before any other family
-                # because `extra` family could use `creole` variables.
-                # `actions` family has to be loaded at the very end
-                # because it may use `creole` or `extra` variables
-                for xml in xmlelts_:
-                    if xml.attrib['name'] == 'creole':
-                        xmlelts.insert(0, xml)
-                    elif xml.attrib['name'] == 'actions':
-                        actions = xml
+        for xmlelt in xmlroot:
+            # VARIABLE_NAMESPACE family has to be loaded before any other family
+            # because `extra` family could use `VARIABLE_NAMESPACE` variables.
+            if xmlelt.attrib['name'] == VARIABLE_NAMESPACE:
+                xmlelts.insert(0, xmlelt)
             else:
-                        xmlelts.append(xml)
-                if actions is not None:
-                    xmlelts.append(actions)
-            else:
-                xmlelts = xmlelts_
-            for xmlelt in xmlelts:
-                if xmlelt.tag != 'family':
-                    raise CreoleLoaderError(_('unknown tag {}').format(xmlelt.tag))
-                self._iter_family(xmlelt, family)
+                xmlelts.append(xmlelt)
+        return xmlelts
 
-    def _populate_variable(self, elt, subpath, is_follower, is_leader):
-        variable = Variable(elt, self.booleans, self.storage, is_follower, is_leader, self.eosfunc)
-        path = self._build_path(subpath, elt)
-        properties = variable.attrib.get('properties', [])
-        if 'force_store_value' in properties or "auto_freeze" in properties:
-            self.force_store_values.add(path)
-        self.storage.add(path, variable)
-        return variable
+    def make_tiramisu_objects(self, xmlroot, eosfunc):
+        self.eosfunc = imp.load_source('eosfunc', eosfunc)
 
-    def _populate_family(self, elt, subpath):
-        if subpath is None:
-            force_icon = False
-        else:
-            force_icon = not subpath.startswith('containers') and not subpath.startswith('actions')
-        family = Family(elt, self.booleans, self.storage, self.eosfunc, force_icon)
-        path = self._build_path(subpath, elt)
-        self.storage.add(path, family)
-        return family
+        family = self.get_root_family()
+        for xmlelt in self.reorder_family(xmlroot):
+            self.iter_family(xmlelt,
+                             family,
+                             None,
+                             )
 
-    def _build_path(self, subpath, elt):
-        if subpath is None:
-            subpath = elt.attrib['name']
-        else:
-            subpath += '.' + elt.attrib['name']
-        return subpath
-
-    def _iter_leader(self, leader, subpath):
-        subpath = self._build_path(subpath, leader)
-        family = Family(leader, self.booleans, self.storage, self.eosfunc)
-        family.set_leader()
-        self.storage.add(subpath, family)
-        leader_name = None
-        for var in leader:
-            if var.tag == 'property':
-                self._parse_properties(family, var)
-            elif var.tag == 'variable':
-                if leader_name is None:
-                    leader_name = var.attrib['name']
-                    self.groups[leader_name] = []
-                else:
-                    self.groups[leader_name].append(var.attrib['name'])
-                self._iter_family(var, family, subpath=subpath)
-            else:
-                raise CreoleLoaderError(_('unknown tag {}').format(var.tag))
-        return family
-
-    def _iter_family(self, child, family, subpath=None):
-        if child.tag not in ['family', 'variable', 'separators', 'leader', 'property']:
+    def iter_family(self,
+                    child,
+                    family,
+                    subpath,
+                    ):
+        if child.tag not in KNOWN_TAGS:
             raise CreoleLoaderError(_('unknown tag {}').format(child.tag))
-        if child.tag == 'family':
-            old_family = family
-            family = self._populate_family(child, subpath)
-            if old_family is not None:
-                old_family.add(family)
-            if len(child) != 0:
-                subpath = self._build_path(subpath, child)
-                for c in child:
-                    self._iter_family(c, family, subpath=subpath)
-        elif child.tag == 'leader':
-            leader = self._iter_leader(child, subpath)
-            family.add(leader)
+        if child.tag in ['family', 'leader']:
+            self.populate_family(family,
+                                 child,
+                                 subpath,
+                                 )
         elif child.tag == 'separators':
-            self._parse_separators(child)
+            self.parse_separators(child)
         elif child.tag == 'variable':
-            if family is None:
-                raise CreoleLoaderError(_('variable without family'))
-
-            is_follower = False
-            is_leader = False
-            if family.is_leader:
-                if child.attrib['name'] != family.attrib['name']:
-                    is_follower = True
-                else:
-                    is_leader = True
-            variable = self._populate_variable(child, subpath, is_follower, is_leader)
-            family.add(variable)
+            self.populate_variable(child, subpath, family)
         elif child.tag == 'property':
-            self._parse_properties(family, child)
+            self.parse_properties(family, child)
         else:
             raise Exception('unknown tag {}'.format(child.tag))
 
-    def _parse_properties(self, family, child):
+    def populate_family(self,
+                        parent_family,
+                        elt,
+                        subpath,
+                        ):
+        path = self.build_path(subpath,
+                               elt,
+                               )
+        family = Family(elt,
+                        self.booleans,
+                        self.storage,
+                        self.eosfunc,
+                        )
+        self.storage.add(path, family)
+        if elt.tag == 'leader':
+            family.set_leader()
+        parent_family.add(family)
+        if len(elt) != 0:
+            for child in elt:
+                self.iter_family(child,
+                                 family,
+                                 path,
+                                 )
+
+    def parse_separators(self,
+                         separators,
+                         ):
+        for separator in separators:
+            elt = self.storage.get(separator.attrib['name'])
+            elt.add_information('separator', separator.text)
+
+    def populate_variable(self, elt, subpath, family):
+        is_follower = False
+        is_leader = False
+        if family.is_leader:
+            if elt.attrib['name'] != family.attrib['name']:
+                is_follower = True
+            else:
+                is_leader = True
+        path = self.build_path(subpath,
+                               elt,
+                               )
+        variable = Variable(elt,
+                            self.booleans,
+                            self.storage,
+                            is_follower,
+                            is_leader,
+                            self.eosfunc,
+                            )
+        self.storage.add(path, variable)
+        family.add(variable)
+
+    def parse_properties(self, family, child):
         if child.get('type') == 'calculation':
             kwargs = {'condition': child.attrib['source'],
                       'expected':  ParamValue(child.attrib.get('expected'))}
@@ -259,17 +224,13 @@ class PopulateTiramisuObjects(object):
         else:
             family.attrib['properties'].append(child.text)
 
-    def _parse_separators(self, separators):
-        for separator in separators:
-            elt = self.storage.get(separator.attrib['name'])
-            never_hidden = separator.attrib.get('never_hidden')
-            if never_hidden == 'True':
-                never_hidden = True
-            else:
-                never_hidden = None
-            info = (separator.text, never_hidden)
-            self.separators[separator.attrib['name']] = info
-            elt.add_information('separator', info)
+    def build_path(self,
+                   subpath,
+                   elt,
+                   ):
+        if subpath is None:
+            return elt.attrib['name']
+        return subpath + '.' + elt.attrib['name']
 
 
 class ElementStorage:
@@ -281,10 +242,6 @@ class ElementStorage:
             raise CreoleLoaderError(_('path already loaded {}').format(path))
         self.paths[path] = elt
 
-    def add_information(self, path, name, information):
-        elt = self.get(path)
-        elt.add_information(name, information)
-
     def get(self, path):
         if path not in self.paths:
             raise CreoleLoaderError(_('there is no element for path {}').format(path))
@@ -312,45 +269,61 @@ class Variable(Common):
         self.option = None
         self.informations = {}
         self.attrib = {}
+        convert_option = CONVERT_OPTION[elt.attrib['type']]
+        if 'initkwargs' in convert_option:
+            self.attrib.update(convert_option['initkwargs'])
+        if elt.attrib['type'] != 'symlink':
             self.attrib['properties'] = []
         self.attrib['validators'] = []
         self.eosfunc = eosfunc
         self.storage = storage
-        is_submulti = False
+        self.booleans = booleans
+        self.populate_attrib(elt)
+        self.is_follower = is_follower
+        self.is_leader = is_leader
+        self.object_type = convert_option['opttype']
+        self.populate_choice(elt)
+        for child in elt:
+            self.populate_property(child)
+            self.populate_value(child)
+            self.populate_check(child)
+        if elt.attrib['type'] == 'symlink':
+            self.attrib['opt'] = storage.get(self.attrib['opt'])
+
+    def populate_attrib(self,
+                        elt,
+                        ):
         for key, value in elt.attrib.items():
-            if key in booleans:
+            if key == 'multi' and elt.attrib['type'] == 'symlink':
+                continue
+            if key == 'multi' and value == 'submulti':
+                value = submulti
+            elif key in self.booleans:
                 if value == 'True':
                     value = True
                 elif value == 'False':
                     value = False
-                elif key == 'multi' and value == 'submulti':
-                    is_submulti = True
-                    value = submulti
                 else:
                     raise CreoleLoaderError(_('unknown value {} for {}').format(value, key))
             if key in ['help', 'test']:
                 self.add_information(key, value)
-            elif key == 'type':
-                pass
-            else:
+            elif key != 'type':
                 self.attrib[key] = value
-        convert_option = CONVERT_OPTION[elt.attrib['type']]
-        self.object_type = convert_option['opttype']
+
+    def populate_choice(self,
+                        elt,
+                        ):
         if elt.attrib['type'] == 'choice':
-            if self.attrib.get('choice'):
-                self.attrib['values'] = getattr(self.eosfunc, self.attrib.get('choice'))
-            else:
-                self.attrib['values'] = []
+            values = []
             for child in elt:
                 if child.tag == 'choice':
                     value = child.text
-                        if 'type' in child.attrib and child.attrib['type'] == 'number':
+                    if child.attrib['type'] == 'number':
                         value = int(value)
-                        if value is None:
-                            value = u''
-                        self.attrib['values'].append(value)
-                self.attrib['values'] = tuple(self.attrib['values'])
-        for child in elt:
+                    values.append(value)
+            self.attrib['values'] = tuple(values)
+
+    def populate_property(self, child):
         if child.tag == 'property':
             if child.get('type') == 'calculation':
                 kwargs = {'condition': child.attrib['source'],
@@ -360,7 +333,9 @@ class Variable(Common):
                 self.attrib['properties'].append((ParamValue(child.text), kwargs))
             else:
                 self.attrib['properties'].append(child.text)
-            elif child.tag == 'value':
+
+    def populate_value(self, child):
+        if child.tag == 'value':
             if child.attrib.get('type') == 'calculation':
                 if child.text is not None and child.text.strip():
                     self.attrib['default'] = (child.text.strip(),)
@@ -374,50 +349,41 @@ class Variable(Common):
                     type_ = CONVERT_OPTION[child.attrib['type']]['opttype']
                 else:
                     type_ = self.object_type
-                    if self.attrib['multi'] is True and not is_follower:
+                if self.attrib['multi'] is True and not self.is_follower:
                     if 'default' not in self.attrib:
                         self.attrib['default'] = []
                     value = convert_tiramisu_value(child.text, type_)
                     self.attrib['default'].append(value)
-                        if 'default_multi' not in self.attrib and not is_leader:
+                    if 'default_multi' not in self.attrib and not self.is_leader:
                         self.attrib['default_multi'] = value
                 elif self.attrib['multi'] == submulti:
                     if 'default' not in self.attrib:
                         self.attrib['default'] = []
                     value = convert_tiramisu_value(child.text, type_)
-                        if not isinstance(value, list) and not is_follower:
-                            value = [value]
-                        self.attrib['default'].append(value)
-                        if 'default_multi' not in self.attrib and not is_leader:
-                            self.attrib['default_multi'] = value
+                    if not self.is_follower:
+                        if not isinstance(value, list):
+                            dvalue = [value]
+                        else:
+                            dvalue = value
+                        self.attrib['default'].append(dvalue)
+                    if value and 'default_multi' not in self.attrib and not self.is_leader:
+                        self.attrib['default_multi'] = []
+                    if not self.is_leader:
+                        self.attrib['default_multi'].append(value)
                 else:
-                        if 'default' in self.attrib:
-                            raise CreoleLoaderError(_('default value already set for {}'
-                                                      '').format(self.attrib['path']))
                     value = convert_tiramisu_value(child.text, type_)
-                        if value is None:  # and (elt.attrib['type'] != 'choice' or value not in self.attrib['values']):
-                            value = u''
-                        if is_follower:
+                    if self.is_follower:
                         self.attrib['default_multi'] = value
                     else:
                         self.attrib['default'] = value
-            elif child.tag == 'choice':
-                # already load
-                pass
-            elif child.tag == 'check':
+
+    def populate_check(self, child):
+        if child.tag == 'check':
             params = []
             for param in child:
                 params.append(self.parse_param(param))
             #check.params = params
             self.attrib['validators'].append((child.attrib['name'], params, child.attrib['warnings_only']))
-            else:
-                raise Exception('unknown tag {}'.format(child.tag))
-        if 'initkwargs' in convert_option:
-            self.attrib.update(convert_option['initkwargs'])
-        if elt.attrib['type'] == 'symlink':
-            del self.attrib['properties']
-            del self.attrib['multi']
-            self.attrib['opt'] = storage.get(self.attrib['opt'])
 
     def parse_param(self, param):
         name = param.attrib.get('name', '')
@@ -431,7 +397,7 @@ class Variable(Common):
                 transitive = False
             else:
                 raise CreoleLoaderError(_('unknown transitive boolean {}').format(transitive))
-            value = [param.text, transitive]
+            value = [param.text, transitive, param.attrib.get('suffix')]
         elif param.attrib['type'] == 'number':
             value = int(param.text)
         else:
@@ -462,10 +428,21 @@ class Variable(Common):
                     if len(value) == 3:
                         for param in value[1]:
                             if isinstance(param[1], list):
+                                option = self.storage.get(param[1][0]).get()
+                                param_kwargs = {'notraisepropertyerror': param[1][1]}
                                 if value[0] in FUNC_TO_DICT:
-                                    param_value = ParamOption(self.storage.get(param[1][0]).get(), notraisepropertyerror=param[1][1], todict=True)
+                                    param_kwargs['todict'] = True
+                                if not param[1][2]:
+                                    param_value = ParamOption(option,
+                                                              **param_kwargs,
+                                                              )
                                 else:
-                                    param_value = ParamOption(self.storage.get(param[1][0]).get(), notraisepropertyerror=param[1][1])
+                                    family = '.'.join(param[1][0].split('.', 3)[:2])
+                                    param_value = ParamDynOption(option,
+                                                                 param[1][2],
+                                                                 self.storage.get(family).get(),
+                                                                 **param_kwargs,
+                                                                 )
                             else:
                                 param_value = ParamValue(param[1])
                             if not param[0]:
@@ -500,7 +477,7 @@ class Variable(Common):
                 import traceback
                 traceback.print_exc()
                 name = self.attrib['name']
-                raise CreoleLoaderError(_('cannot create option {}: {}').format(name, err))
+                raise CreoleLoaderError(_('cannot create option "{}": {}').format(name, err))
             for key, value in self.informations.items():
                 option.impl_set_information(key, value)
             self.option = option
@@ -508,42 +485,25 @@ class Variable(Common):
 
 
 class Family(Common):
-    def __init__(self, elt, booleans, storage, eosfunc, force_icon=False):
+    def __init__(self,
+                 elt,
+                 booleans,
+                 storage,
+                 eosfunc,
+                 ):
         self.option = None
         self.attrib = {}
         self.is_leader = False
-        if force_icon:
-            self.informations = {'icon': None}
-        else:
         self.informations = {}
         self.children = []
         self.storage = storage
         self.eosfunc = eosfunc
         self.attrib['properties'] = []
         for key, value in elt.attrib.items():
-            if key in booleans:
-                if value == 'True':
-                    value = True
-                elif value == 'False':
-                    value = False
-                else:
-                    raise CreoleLoaderError(_('unknown value {} for {}').format(value, key))
-            if key == 'icon':
-                self.add_information('icon', value)
-                continue
-            elif key == 'hidden':
-                if value:
-                    self.attrib['properties'].append(key)
-            elif key == 'mode':
-                self.attrib['properties'].append(value)
-            elif key == 'help':
+            if key == 'help':
                 self.add_information(key, value)
-            elif key == 'type':
-                pass
             else:
                 self.attrib[key] = value
-        if 'doc' not in self.attrib:
-            self.attrib['doc'] = u''
 
     def add(self, child):
         self.children.append(child)
@@ -574,13 +534,11 @@ class Family(Common):
                 else:
                     option = Leadership(**self.attrib)
             except Exception as err:
-                raise CreoleLoaderError(_('cannot create optiondescription {}: {}').format(self.attrib['name'], err))
+                print(self.attrib)
+                raise CreoleLoaderError(_('cannot create optiondescription "{}": {}').format(self.attrib['name'], err))
             for key, value in self.informations.items():
                 option.impl_set_information(key, value)
             self.option = option
-            #if self.is_leader:
-            #    self.option.impl_set_group_type(groups.leader)
-
         return self.option
 
 

src/rougail/objspace.py

@@ -4,11 +4,11 @@ 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'])
+    >>> from rougail.objspace import CreoleObjSpace
+    >>> eolobj = CreoleObjSpace('/usr/share/rougail/rougail.dtd')
+    >>> eolobj.create_or_populate_from_xml('rougail', ['/usr/share/eole/rougail/dicos'])
     >>> eolobj.space_visitor()
-    >>> eolobj.save('/tmp/creole_flatened_output.xml')
+    >>> eolobj.save('/tmp/rougail_flatened_output.xml')
 
 The CreoleObjSpace
 
@@ -25,19 +25,18 @@ has to be moved in family2. The visit procedure changes the varable1's object sp
 """
 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, ServiceAnnotator, SpaceAnnotator
+from .annotator import ERASED_ATTRIBUTES, VARIABLE_NAMESPACE, ServiceAnnotator, SpaceAnnotator
 from .utils import normalize_family
 from .error import CreoleOperationError, SpaceObjShallNotBeUpdated, CreoleDictConsistencyError
+from .path import Path
 
-# CreoleObjSpace's elements like 'family' or 'slave', that shall be forced to the Redefinable type
-FORCE_REDEFINABLES = ('family', 'slave', 'service', 'disknod', 'variables', 'family_action')
+# CreoleObjSpace's elements like 'family' or 'follower', that shall be forced to the Redefinable type
+FORCE_REDEFINABLES = ('family', 'follower', 'service', 'disknod', 'variables')
 # CreoleObjSpace's elements that shall be forced to the UnRedefinable type
-FORCE_UNREDEFINABLES = ('value', 'input', 'profile', 'ewtapp', 'tag', 'saltaction')
+FORCE_UNREDEFINABLES = ('value',)
 # CreoleObjSpace's elements that shall be set to the UnRedefinable type
 UNREDEFINABLE = ('submulti', 'multi', 'type')
 
@@ -48,16 +47,26 @@ CONVERT_PROPERTIES = {'auto_save': ['force_store_value'], 'auto_freeze': ['force
 RENAME_ATTIBUTES = {'description': 'doc'}
 
 INCOMPATIBLE_ATTRIBUTES = [['multi', 'submulti']]
+FORCED_TEXT_ELTS_AS_NAME = ('choice', 'property', 'value', 'target')
 
-#TYPE_TARGET_CONDITION = ('variable', 'family')
+CONVERT_EXPORT = {'Leadership': 'leader',
+                  'Separators': 'separators',
+                  'Variable': 'variable',
+                  'Value': 'value',
+                  'Property': 'property',
+                  'Choice': 'choice',
+                  'Param': 'param',
+                  'Separator': 'separator',
+                  'Check': 'check',
+                  }
 
 # _____________________________________________________________________________
 # special types definitions for the Object Space's internal representation
-class RootCreoleObject(object):
+class RootCreoleObject:
     ""
 
 
-class CreoleObjSpace(object):
+class CreoleObjSpace:
     """DOM XML reflexion free internal representation of a Creole Dictionary
     """
     choice = type('Choice', (RootCreoleObject,), OrderedDict())
@@ -78,149 +87,174 @@ class CreoleObjSpace(object):
 
     def __init__(self, dtdfilename):  # pylint: disable=R0912
         self.index = 0
-        class ObjSpace(object):  # pylint: disable=R0903
+        class ObjSpace:  # pylint: disable=R0903
             """
             Base object space
             """
         self.space = ObjSpace()
+        self.paths = Path()
         self.xmlreflector = XMLReflector()
         self.xmlreflector.parse_dtd(dtdfilename)
         self.redefine_variables = None
-        self.probe_variables = []
+        self.check_removed = None
+        self.condition_removed = None
 
         # ['variable', 'separator', 'family']
         self.forced_text_elts = set()
-        self.forced_text_elts_as_name = set(['choice', 'property'])
-        self.forced_choice_option = {}
-        self.paths = Path()
+        self.forced_text_elts_as_name = set(FORCED_TEXT_ELTS_AS_NAME)
         self.list_conditions = {}
-
         self.booleans_attributs = []
 
-        for elt in self.xmlreflector.dtd.iterelements():
+        self.make_object_space_class()
+
+    def make_object_space_class(self):
+        """Create Rougail ObjectSpace class types, it enables us to create objects like:
+        File(), Variable(), Ip(), Family(), Constraints()... and so on.
+        
+        Creole ObjectSpace is an object's reflexion of the XML elements"""
+
+        for dtd_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 == 'service':
-                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':
+            if dtd_elt.name in FORCE_REDEFINABLES:
                 clstype = self.Redefinable
-                if attr.name == 'name' and forced_text_elt is True:
-                    self.forced_text_elts.add(elt.name)
+            else:
+                clstype = self.UnRedefinable
+            atomic = dtd_elt.name not in FORCE_UNREDEFINABLES and dtd_elt.name not in FORCE_REDEFINABLES
+            forced_text_elt = dtd_elt.type == 'mixed'
+            for dtd_attr in dtd_elt.iterattributes():
+                atomic = False
+                if set(dtd_attr.itervalues()) == set(['True', 'False']):
+                    # it's a boolean
+                    self.booleans_attributs.append(dtd_attr.name)
+                if dtd_attr.default_value:
+                    # set default value for this attribute
+                    default_value = dtd_attr.default_value
+                    if dtd_attr.name in self.booleans_attributs:
+                        default_value = self.convert_boolean(dtd_attr.default_value)
+                    attrs[dtd_attr.name] = default_value
+                if dtd_attr.name == 'redefine':
+                    # has a redefine attribute, so it's a Redefinable object
+                    clstype = self.Redefinable
+                if dtd_attr.name == 'name' and forced_text_elt:
+                    # child.text should be transform has a "name" attribute
+                    self.forced_text_elts.add(dtd_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:
+                self.forced_text_elts_as_name.add(dtd_elt.name)
+            if atomic:
+                # has any attribute so it's an Atomic object
                 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))
+            # create ObjectSpace object
+            setattr(self, dtd_elt.name, type(dtd_elt.name.capitalize(), (clstype,), attrs))
 
-    def parse_dtd_right_left_elt(self, elt):
-        if elt.right.type == 'or':
-            self.parse_dtd_right_left_elt(elt.right)
-
-    def _convert_boolean(self, value):  # pylint: disable=R0201
-        """Boolean coercion. The Creole XML may contain srings like `True` or `False`
+    def create_or_populate_from_xml(self,
+                                    namespace,
+                                    xmlfolders):
+        """Parses a bunch of XML files
+        populates the CreoleObjSpace
         """
-        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
+        for xmlfile, document in self.xmlreflector.load_xml_from_folders(xmlfolders):
+            self.redefine_variables = []
+            self.check_removed = []
+            self.condition_removed = []
+            self.xml_parse_document(document,
+                                    self.space,
+                                    namespace,
+                                    )
 
-    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 xml_parse_document(self,
+                           document,
+                           space,
+                           namespace,
+                           ):
+        """Parses a Creole XML file
+        populates the CreoleObjSpace
+        """
+        family_names = []
+        for child in document:
+            # this index enables us to reorder objects
+            self.index += 1
+            # doesn't proceed the XML commentaries
+            if not isinstance(child.tag, str):
+                continue
+            if child.tag == 'family':
+                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:
+                # FIXME should not be here
+                continue
+            # variable objects creation
+            try:
+                variableobj = self.generate_variableobj(child,
+                                                    space,
+                                                    namespace,
+                                                    )
+            except SpaceObjShallNotBeUpdated:
+                continue
+            self.set_text_to_obj(child,
+                                 variableobj,
+                                 )
+            self.set_xml_attributes_to_obj(child,
+                                           variableobj,
+                                           )
+            self.variableobj_tree_visitor(child,
+                                          variableobj,
+                                          namespace,
+                                          )
+            self.fill_variableobj_path_attribute(space,
+                                                 child,
+                                                 namespace,
+                                                 document,
+                                                 variableobj,
+                                                 )
+            self.add_to_tree_structure(variableobj,
+                                       space,
+                                       child,
+                                       )
+            if list(child) != []:
+                self.xml_parse_document(child,
+                                        variableobj,
+                                        namespace,
+                                        )
 
-    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 generate_variableobj(self,
+                           child,
+                           space,
+                           namespace,
+                           ):
+        """
+        instanciates or creates Creole Object Subspace objects
+        """
+        variableobj = getattr(self, child.tag)()
+        if isinstance(variableobj, self.Redefinable):
+            variableobj = self.create_or_update_redefinable_object(child.attrib,
+                                                                 space,
+                                                                 child,
+                                                                 namespace,
+                                                                 )
+        elif isinstance(variableobj, self.Atom) and child.tag in vars(space):
+            # instanciates an object from the CreoleObjSpace's builtins types
+            # example : child.tag = constraints -> a self.Constraints() object is created
+            # this Atom instance has to be a singleton here
+            # we do not re-create it, we reuse it
+            variableobj = getattr(space, child.tag)
+        self.create_tree_structure(space,
+                                   child,
+                                   variableobj,
+                                   )
+        return variableobj
 
-    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):
+    def create_or_update_redefinable_object(self,
+                                            subspace,
+                                            space,
+                                            child,
+                                            namespace,
+                                            ):
         """Creates or retrieves the space object that corresponds
         to the `child` XML object
 
@@ -249,46 +283,34 @@ class CreoleObjSpace(object):
             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 self.is_already_exists(name,
+                                  space,
+                                  child,
+                                  namespace,
+                                  ):
+            default_redefine = child.tag in FORCE_REDEFINABLES
+            redefine = self.convert_boolean(subspace.get('redefine', default_redefine))
+            exists = self.convert_boolean(subspace.get('exists', True))
             if redefine is True:
-                return self._translate_in_space(name, space, child, namespace)
+                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))
+            raise CreoleDictConsistencyError(_(f'Already present in another XML file, {name} cannot be re-created'))
+        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))
+        raise CreoleDictConsistencyError(_(f'Redefined object: {name} does not exist yet'))
 
-    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
+    def create_tree_structure(self,
+                              space,
+                              child,
+                              variableobj,
+                              ):  # pylint: disable=R0201
         """
         Builds the tree structure of the object space here
         we set services attributes in order to be populated later on
@@ -301,63 +323,144 @@ class CreoleObjSpace(object):
             space.value = list()
         """
         if child.tag not in vars(space):
-            if isinstance(creoleobj, self.Redefinable):
+            if isinstance(variableobj, self.Redefinable):
                 setattr(space, child.tag, OrderedDict())
-            elif isinstance(creoleobj, self.UnRedefinable):
+            elif isinstance(variableobj, self.UnRedefinable):
                 setattr(space, child.tag, [])
-            elif isinstance(creoleobj, self.Atom):
-                pass
-            else: # pragma: no cover
+            elif not isinstance(variableobj, self.Atom):  # pragma: no cover
                 raise CreoleOperationError(_("Creole object {} "
-                                             "has a wrong type").format(type(creoleobj)))
+                                             "has a wrong type").format(type(variableobj)))
 
-    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)
+    def is_already_exists(self, name, space, child, namespace):
+        if isinstance(space, self.family):  # pylint: disable=E1101
+            if namespace != VARIABLE_NAMESPACE:
+                name = space.path + '.' + name
+            return self.paths.path_is_defined(name)
+        if child.tag == 'family':
+            norm_name = normalize_family(name)
         else:
-            setattr(space, child.tag, creoleobj)
+            norm_name = name
+        return norm_name in getattr(space, child.tag, {})
 
-    def _set_text_to_obj(self, child, creoleobj):
+    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 translate_in_space(self,
+                           name,
+                           family,
+                           variable,
+                           namespace,
+                           ):
+        if not isinstance(family, self.family):  # pylint: disable=E1101
+            if variable.tag == 'family':
+                norm_name = normalize_family(name)
+            else:
+                norm_name = name
+            return getattr(family, variable.tag)[norm_name]
+        if namespace == VARIABLE_NAMESPACE:
+            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[VARIABLE_NAMESPACE].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.add_variable(namespace,
+                                name,
+                                family.name,
+                                False,
+                                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 add_to_tree_structure(self,
+                              variableobj,
+                              space,
+                              child,
+                              ):  # pylint: disable=R0201
+        if isinstance(variableobj, self.Redefinable):
+            name = variableobj.name
+            if child.tag == 'family':
+                name = normalize_family(name)
+            getattr(space, child.tag)[name] = variableobj
+        elif isinstance(variableobj, self.UnRedefinable):
+            getattr(space, child.tag).append(variableobj)
+        else:
+            setattr(space, child.tag, variableobj)
+
+    def set_text_to_obj(self,
+                        child,
+                        variableobj,
+                        ):
         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
+                variableobj.name = text
             else:
-                creoleobj.text = text
+                variableobj.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')
+    def set_xml_attributes_to_obj(self,
+                                  child,
+                                  variableobj,
+                                  ):
+        redefine = self.convert_boolean(child.attrib.get('redefine', False))
+        has_value = hasattr(variableobj, '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
+        if redefine is True and child.tag == 'variable' and has_value and len(child) != 0:
+            del variableobj.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)
-        keys = list(vars(creoleobj).keys())
+                raise CreoleDictConsistencyError(_(f'cannot redefine attribute {attr} for variable {name}'))
+            if attr in self.booleans_attributs:
+                val = self.convert_boolean(val)
+            if not (attr == 'name' and getattr(variableobj, 'name', None) != None):
+                setattr(variableobj, attr, val)
+        keys = list(vars(variableobj).keys())
         for incompatible in INCOMPATIBLE_ATTRIBUTES:
             found = False
             for inc in incompatible:
@@ -366,101 +469,68 @@ class CreoleObjSpace(object):
                         raise CreoleDictConsistencyError(_('those attributes are incompatible {}').format(incompatible))
                     found = True
 
-
-    def _creoleobj_tree_visitor(self, child, creoleobj, namespace):
+    def variableobj_tree_visitor(self,
+                                 child,
+                                 variableobj,
+                                 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
+        if child.tag == 'variable':
+            if child.attrib.get('remove_check', False):
+                self.remove_check(variableobj.name)
+            if child.attrib.get('remove_condition', False):
+                self.remove_condition(variableobj.name)
+        if child.tag == 'fill':
+            # if variable is a redefine in current dictionary
+            # XXX not working with variable not in variable and in leader/followers
+            variableobj.redefine = child.attrib['target'] in self.redefine_variables
+        if not hasattr(variableobj, 'index'):
+            variableobj.index = self.index
+        if child.tag == 'check' and child.attrib['target'] in self.redefine_variables and child.attrib['target'] not in self.check_removed:
+            self.remove_check(child.attrib['target'])
+            self.check_removed.append(child.attrib['target'])
+        if child.tag == 'condition' and child.attrib['source'] in self.redefine_variables and child.attrib['source'] not in self.check_removed:
+            self.remove_condition(child.attrib['source'])
+            self.condition_removed.append(child.attrib['source'])
+        variableobj.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
+    def fill_variableobj_path_attribute(self,
+                                        space,
+                                        child,
+                                        namespace,
+                                        document,
+                                        variableobj,
+                                        ):  # pylint: disable=R0913
         """Fill self.paths attributes
         """
-        if not isinstance(space, self.help):  # pylint: disable=E1101
+        if isinstance(space, self.help):  # pylint: disable=E1101
+            return
         if child.tag == 'variable':
             family_name = normalize_family(document.attrib['name'])
-                self.paths.append('variable', child.attrib['name'], namespace, family_name,
-                                  creoleobj)
+            self.paths.add_variable(namespace,
+                                    child.attrib['name'],
+                                    family_name,
+                                    document.attrib.get('dynamic') != None,
+                                    variableobj)
             if child.attrib.get('redefine', 'False') == 'True':
-                    if namespace == 'creole':
+                if namespace == VARIABLE_NAMESPACE:
                     self.redefine_variables.append(child.attrib['name'])
                 else:
                     self.redefine_variables.append(namespace + '.' + family_name + '.' +
                                                    child.attrib['name'])
 
-            if child.tag == 'family':
+        elif child.tag == 'family':
             family_name = normalize_family(child.attrib['name'])
-                if namespace != 'creole':
+            if namespace != VARIABLE_NAMESPACE:
                 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)
+            self.paths.add_family(namespace,
+                                  family_name,
+                                  variableobj,
+                                  )
+            variableobj.path = self.paths.get_family_path(family_name, namespace)
 
     def space_visitor(self, eosfunc_file):  # pylint: disable=C0111
-        ActionAnnotator(self)
         ServiceAnnotator(self)
         SpaceAnnotator(self, eosfunc_file)
 
@@ -469,42 +539,13 @@ class CreoleObjSpace(object):
 
         :param filename: the full XML filename
         """
-        xml = Element('creole')
+        xml = Element('rougail')
         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
+    def get_attributes(self, space):  # pylint: disable=R0201
         for attr in dir(space):
             if not attr.startswith('_'):
                 yield attr
@@ -514,45 +555,35 @@ class CreoleObjSpace(object):
             space = list(space.values())
         if isinstance(space, list):
             for subspace in space:
-                if isinstance(subspace, self.Leadership):
-                    _name = 'leader'
-                else:
-                    _name = name
-                if name in ['services', '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):
+                if name == 'value' and (not hasattr(subspace, 'name') or subspace.name is None):
+                    raise Exception('pfff')
                     continue
+                _name = CONVERT_EXPORT.get(subspace.__class__.__name__, 'family')
                 child_node = SubElement(node, _name)
                 self._xml_export(child_node, subspace, _name)
-        elif isinstance(space, self.Atom):
-            if name == 'services':
-                child_node = SubElement(node, 'family')
+        elif isinstance(space, (self.Atom, (self.Redefinable, self.UnRedefinable))):
+            _name = CONVERT_EXPORT.get(space.__class__.__name__, 'family')
+            child_node = SubElement(node, _name)
+            if _name != name:
                 child_node.attrib['name'] = name
-            else:
-                child_node = SubElement(node, name)
-            for subname in self._get_attributes(space):
+                if 'doc' not in child_node.attrib.keys():
+                    child_node.attrib['doc'] = 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']:
+        elif name not in ERASED_ATTRIBUTES:
+            # # FIXME plutot dans annotator ...
+            if node.tag in ['variable', 'family', 'leader']:
+                if name in PROPERTIES:
                     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:
+                    return
+                if name == 'mode' and space:
+                    SubElement(node, 'property').text = space
+                    return
+            # Not param for calculation ...
+            if name == 'name' and node_name in FORCED_TEXT_ELTS_AS_NAME and not hasattr(current_space, 'param'):
                 node.text = str(space)
             elif name == 'text' and node_name in self.forced_text_elts:
                 node.text = space
@@ -560,137 +591,22 @@ class CreoleObjSpace(object):
                 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):
+    def _xml_export(self,
+                    node,
+                    space,
+                    node_name=VARIABLE_NAMESPACE,
+                    ):
+        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,
-                                              allow_dot=True)]
-        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'] not in ['creole', 'services'] 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']
+            self._sub_xml_export(name,
+                                 node,
+                                 node_name,
+                                 subspace,
+                                 space,
+                                 )

src/rougail/path.py

@@ -0,0 +1,174 @@
+from .i18n import _
+from .utils import normalize_family
+from .error import CreoleOperationError, CreoleDictConsistencyError
+from .annotator import VARIABLE_NAMESPACE
+
+
+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 = {}
+
+    # Family
+    def add_family(self,
+                   namespace: str,
+                   name: str,
+                   variableobj: str,
+                   ) -> str:  # pylint: disable=C0111
+        self.families[name] = dict(name=name,
+                                   namespace=namespace,
+                                   variableobj=variableobj,
+                                   )
+
+    def get_family_path(self,
+                        name: str,
+                        current_namespace: str,
+                        ) -> str:  # 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,
+                                              allow_dot=True,
+                                              )]
+        if dico['namespace'] != VARIABLE_NAMESPACE 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_obj(self,
+                       name: str,
+                       ) -> 'Family':  # pylint: disable=C0111
+        if name not in self.families:
+            raise CreoleDictConsistencyError(_('unknown family {}').format(name))
+        dico = self.families[name]
+        return dico['variableobj']
+
+    # Leadership
+    def set_leader(self,
+                   namespace: str,
+                   leader_family_name: str,
+                   name: str,
+                   leader_name: str,
+                   ) -> None:  # pylint: disable=C0111
+        if namespace != VARIABLE_NAMESPACE:
+            # need rebuild path and move object in new path
+            old_path = namespace + '.' + leader_family_name + '.' + name
+            dico = self._get_variable(old_path)
+            del self.variables[old_path]
+            new_path = namespace + '.' + leader_family_name + '.' + leader_name + '.' + name
+            self.add_variable(namespace,
+                              new_path,
+                              dico['family'],
+                              False,
+                              dico['variableobj'],
+                              )
+            name = new_path
+        dico = self._get_variable(name)
+        if dico['leader'] != None:
+            raise CreoleDictConsistencyError(_('Already defined leader {} for variable'
+                                               ' {}'.format(dico['leader'], name)))
+        dico['leader'] = leader_name
+
+    def get_leader(self, name):  # pylint: disable=C0111
+        return self._get_variable(name)['leader']
+
+    # Variable
+    def add_variable(self,
+                     namespace: str,
+                     name: str,
+                     family: str,
+                     is_dynamic: bool,
+                     variableobj,
+                     ) -> str:  # pylint: disable=C0111
+        if namespace == VARIABLE_NAMESPACE or '.' in name:
+            varname = name
+        else:
+            varname = '.'.join([namespace, family, name])
+        self.variables[varname] = dict(name=name,
+                                       family=family,
+                                       namespace=namespace,
+                                       leader=None,
+                                       is_dynamic=is_dynamic,
+                                       variableobj=variableobj)
+
+    def get_variable_name(self,
+                          name,
+                          ):  # pylint: disable=C0111
+        return self._get_variable(name)['name']
+
+    def get_variable_obj(self,
+                         name:str,
+                         ) -> 'Variable':  # pylint: disable=C0111
+        return self._get_variable(name)['variableobj']
+
+    def get_variable_family_name(self,
+                                 name: str,
+                                 ) -> str:  # pylint: disable=C0111
+        return self._get_variable(name)['family']
+
+    def get_variable_namespace(self,
+                               name: str,
+                               ) -> str:  # pylint: disable=C0111
+        return self._get_variable(name)['namespace']
+
+    def get_variable_path(self,
+                          name: str,
+                          current_namespace: str,
+                          allow_source: str=False,
+                          with_suffix: bool=False,
+                          ) -> str:  # pylint: disable=C0111
+        if current_namespace is None:  # pragma: no cover
+            raise CreoleOperationError('current_namespace must not be None')
+        if with_suffix:
+            dico, suffix = self._get_variable(name,
+                                              with_suffix=True,
+                                              )
+        else:
+            dico = self._get_variable(name)
+        if not allow_source:
+            if dico['namespace'] not in [VARIABLE_NAMESPACE, 'services'] 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']:
+            value = dico['name']
+        else:
+            list_path = [dico['namespace'], dico['family']]
+            if dico['leader'] is not None:
+                list_path.append(dico['leader'])
+            list_path.append(dico['name'])
+            value = '.'.join(list_path)
+        if with_suffix:
+            return value, suffix
+        return value
+
+    def path_is_defined(self,
+                        name: str,
+                        ) -> str:  # pylint: disable=C0111
+        return name in self.variables
+
+    def _get_variable(self,
+                      name: str,
+                      with_suffix: bool=False,
+                      ) -> str:
+        if name not in self.variables:
+            if name.startswith(f'{VARIABLE_NAMESPACE}.'):
+                name = name.split('.')[-1]
+            if name not in self.variables:
+                for var_name, variable in self.variables.items():
+                    if variable['is_dynamic'] and name.startswith(var_name):
+                        return variable, name[len(var_name):]
+                raise CreoleDictConsistencyError(_('unknown option {}').format(name))
+        if with_suffix:
+            return self.variables[name], None
+        return self.variables[name]
+

src/rougail/template.py

@@ -5,32 +5,12 @@ On travaille sur les fichiers cibles
 """
 
 import imp
-import sys
 from shutil import copy
 import logging
 from typing import Dict, Any
-
 from subprocess import call
-from os import listdir, unlink, makedirs
-from os.path import dirname, basename, join, split, isfile, isdir
-
-from tempfile import mktemp
-
-from Cheetah import Parser
-
-
-# l'encoding du template est déterminé par une regexp (encodingDirectiveRE dans Parser.py)
-# il cherche un ligne qui ressemble à '#encoding: utf-8
-# cette classe simule le module 're' et retourne toujours l'encoding utf-8
-# 6224
-class FakeEncoding:
-    def groups(self):
-        return ('utf-8',)
-
-    def search(self, *args):
-        return self
-Parser.encodingDirectiveRE = FakeEncoding()
-
+from os import listdir, makedirs
+from os.path import dirname, join, isfile
 
 from Cheetah.Template import Template as ChtTemplate
 from Cheetah.NameMapper import NotFound as CheetahNotFound
@@ -38,8 +18,9 @@ from Cheetah.NameMapper import NotFound as CheetahNotFound
 from tiramisu import Config
 from tiramisu.error import PropertiesOptionError
 
+from .annotator import VARIABLE_NAMESPACE
 from .config import patch_dir
-from .error import FileNotFound, TemplateError, TemplateDisabled
+from .error import FileNotFound, TemplateError
 from .i18n import _
 from .utils import normalize_family
 
@@ -47,6 +28,7 @@ from .utils import normalize_family
 log = logging.getLogger(__name__)
 log.addHandler(logging.NullHandler())
 
+
 class IsDefined:
     """
     filtre permettant de ne pas lever d'exception au cas où
@@ -59,34 +41,16 @@ class IsDefined:
         if '.' in varname:
             splitted_var = varname.split('.')
             if len(splitted_var) != 2:
-                msg = _("Group variables must be of type master.slave")
+                msg = _("Group variables must be of type leader.follower")
                 raise KeyError(msg)
-            master, slave = splitted_var
-            if master in self.context:
-                return slave in self.context[master].slave.keys()
+            leader, follower = splitted_var
+            if leader in self.context:
+                return follower in self.context[leader].follower.keys()
             return False
         else:
             return varname in self.context
 
 
-class CreoleGet:
-    def __init__(self, context):
-        self.context = context
-
-    def __call__(self, varname):
-        return self.context[varname]
-
-    def __getitem__(self, varname):
-        """For bracket and dotted notation
-        """
-        return self.context[varname]
-
-    def __contains__(self, varname):
-        """Check variable existence in context
-        """
-        return varname in self.context
-
-
 @classmethod
 def cl_compile(kls, *args, **kwargs):
     kwargs['compilerSettings'] = {'directiveStartToken' : '%',
@@ -103,12 +67,6 @@ ChtTemplate.old_compile = ChtTemplate.compile
 ChtTemplate.compile = cl_compile
 
 
-class CreoleClient:
-    def __init__(self,
-                 config: Config):
-        self.config = config
-
-
 class CheetahTemplate(ChtTemplate):
     """classe pour personnaliser et faciliter la construction
     du template Cheetah
@@ -133,7 +91,7 @@ class CheetahTemplate(ChtTemplate):
 
 
 class CreoleLeader:
-    def __init__(self, value, slave=None, index=None):
+    def __init__(self, value, follower=None, index=None):
         """
         On rend la variable itérable pour pouvoir faire:
         for ip in iplist:
@@ -143,20 +101,20 @@ class CreoleLeader:
         index is used for CreoleLint
         """
         self._value = value
-        if slave is not None:
-            self.slave = slave
+        if follower is not None:
+            self.follower = follower
         else:
-            self.slave = {}
+            self.follower = {}
         self._index = index
 
     def __getattr__(self, name):
-        """Get slave variable or attribute of master value.
+        """Get follower variable or attribute of leader value.
 
-        If the attribute is a name of a slave variable, return its value.
-        Otherwise, returns the requested attribute of master value.
+        If the attribute is a name of a follower variable, return its value.
+        Otherwise, returns the requested attribute of leader value.
         """
-        if name in self.slave:
-            value = self.slave[name]
+        if name in self.follower:
+            value = self.follower[name]
             if isinstance(value, PropertiesOptionError):
                 raise AttributeError()
             return value
@@ -164,36 +122,36 @@ class CreoleLeader:
             return getattr(self._value, name)
 
     def __getitem__(self, index):
-        """Get a master.slave at requested index.
+        """Get a leader.follower at requested index.
         """
         ret = {}
-        for key, values in self.slave.items():
+        for key, values in self.follower.items():
             ret[key] = values[index]
         return CreoleLeader(self._value[index], ret, index)
 
     def __iter__(self):
-        """Iterate over master.slave.
+        """Iterate over leader.follower.
 
-        Return synchronised value of master.slave.
+        Return synchronised value of leader.follower.
         """
         for i in range(len(self._value)):
             ret = {}
-            for key, values in self.slave.items():
+            for key, values in self.follower.items():
                 ret[key] = values[i]
             yield CreoleLeader(self._value[i], ret, i)
 
     def __len__(self):
-        """Delegate to master value
+        """Delegate to leader value
         """
         return len(self._value)
 
     def __repr__(self):
         """Show CreoleLeader as dictionary.
 
-        The master value is stored under 'value' key.
-        The slaves are stored under 'slave' key.
+        The leader value is stored under 'value' key.
+        The followers are stored under 'follower' key.
         """
-        return repr({'value': self._value, 'slave': self.slave})
+        return repr({'value': self._value, 'follower': self.follower})
 
     def __eq__(self, value):
         return value == self._value
@@ -214,7 +172,7 @@ class CreoleLeader:
         return self._value >= value
 
     def __str__(self):
-        """Delegate to master value
+        """Delegate to leader value
         """
         return str(self._value)
 
@@ -227,7 +185,7 @@ class CreoleLeader:
     def __contains__(self, item):
         return item in self._value
 
-    async def add_slave(self, config, name, path):
+    async def add_follower(self, config, name, path):
         if isinstance(self._value, list):
             values = []
             for idx in range(len(self._value)):
@@ -237,7 +195,7 @@ class CreoleLeader:
                     values.append(err)
         else:
             raise Exception('hu?')
-        self.slave[name] = values
+        self.follower[name] = values
 
 
 class CreoleExtra:
@@ -252,6 +210,9 @@ class CreoleExtra:
     def __repr__(self):
         return self.suboption.__str__()
 
+    def __iter__(self):
+        return iter(self.suboption.values())
+
 
 class CreoleTemplateEngine:
     """Engine to process Creole cheetah template
@@ -261,7 +222,8 @@ class CreoleTemplateEngine:
                  eosfunc_file: str,
                  distrib_dir: str,
                  tmp_dir: str,
-                 dest_dir:str) -> None:
+                 dest_dir: str,
+                 ) -> None:
         self.config = config
         self.dest_dir = dest_dir
         self.tmp_dir = tmp_dir
@@ -273,9 +235,9 @@ class CreoleTemplateEngine:
                  if not func.startswith('_'):
                      eos[func] = getattr(eosfunc, func)
         self.eosfunc = eos
-        self.creole_variables_dict = {}
+        self.rougail_variables_dict = {}
 
-    async def load_eole_variables_creole(self,
+    async def load_eole_variables_rougail(self,
                                           optiondescription):
         for option in await optiondescription.list('all'):
             if await option.option.isoptiondescription():
@@ -283,15 +245,15 @@ class CreoleTemplateEngine:
                     for idx, suboption in enumerate(await option.list('all')):
                         if idx == 0:
                             leader = CreoleLeader(await suboption.value.get())
-                            self.creole_variables_dict[await suboption.option.name()] = leader
+                            self.rougail_variables_dict[await suboption.option.name()] = leader
                         else:
-                            await leader.add_slave(self.config,
+                            await leader.add_follower(self.config,
                                                    await suboption.option.name(),
                                                    await suboption.option.path())
                 else:
-                    await self.load_eole_variables_creole(option)
+                    await self.load_eole_variables_rougail(option)
             else:
-                self.creole_variables_dict[await option.option.name()] = await option.value.get()
+                self.rougail_variables_dict[await option.option.name()] = await option.value.get()
 
     async def load_eole_variables(self,
                                   namespace,
@@ -300,20 +262,26 @@ class CreoleTemplateEngine:
         for family in await optiondescription.list('all'):
             variables = {}
             for variable in await family.list('all'):
-                if await variable.option.isoptiondescription() and await variable.option.isleadership():
+                if await variable.option.isoptiondescription():
+                    if await variable.option.isleadership():
                         for idx, suboption in enumerate(await variable.list('all')):
                             if idx == 0:
                                 leader = CreoleLeader(await suboption.value.get())
                                 leader_name = await suboption.option.name()
                             else:
-                            await leader.add_slave(self.config,
+                                await leader.add_follower(self.config,
                                                        await suboption.option.name(),
                                                        await suboption.option.path())
                         variables[leader_name] = leader
+                    else:
+                        subfamilies = await self.load_eole_variables(await variable.option.name(),
+                                                                     variable,
+                                                                     )
+                        variables[await variable.option.name()] = subfamilies
                 else:
                     variables[await variable.option.name()] = await variable.value.get()
             families[await family.option.name()] = CreoleExtra(variables)
-        self.creole_variables_dict[namespace] = CreoleExtra(families)
+        return CreoleExtra(families)
 
     def patch_template(self,
                        filename: str):
@@ -342,6 +310,8 @@ class CreoleTemplateEngine:
         self.patch_template(filename)
 
     def process(self,
+                source: str,
+                true_destfilename: str,
                 destfilename: str,
                 filevar: Dict,
                 variable: Any):
@@ -350,12 +320,12 @@ class CreoleTemplateEngine:
         # full path of the destination file
         log.info(_(f"Cheetah processing: '{destfilename}'"))
         try:
-            cheetah_template = CheetahTemplate(join(self.tmp_dir,
-                                               filevar['source']),
-                                               self.creole_variables_dict,
+            cheetah_template = CheetahTemplate(source,
+                                               self.rougail_variables_dict,
                                                self.eosfunc,
-                                               destfilename,
-                                               variable)
+                                               true_destfilename,
+                                               variable,
+                                               )
             data = str(cheetah_template)
         except CheetahNotFound as err:
             varname = err.args[0][13:-1]
@@ -368,51 +338,53 @@ class CreoleTemplateEngine:
 
     def instance_file(self,
                       filevar: Dict,
-                      systemd_rights: list) -> None:
+                      service_name: str) -> None:
         """Run templatisation on one file
         """
         log.info(_("Instantiating file '{filename}'"))
-        filenames = filevar['name']
         if 'variable' in filevar:
             variable = filevar['variable']
         else:
             variable = None
+        filenames = filevar['name']
         if not isinstance(filenames, list):
             filenames = [filenames]
             if variable:
                 variable = [variable]
         for idx, filename in enumerate(filenames):
-            destfilename = join(self.dest_dir,
-                                filename[1:])
+            destfilename = join(self.dest_dir, filename[1:])
             makedirs(dirname(destfilename), exist_ok=True)
             if variable:
                 var = variable[idx]
             else:
                 var = None
-            self.process(destfilename,
+            source = join(self.tmp_dir, filevar['source'])
+            if filevar['templating']:
+                self.process(source,
+                             filename,
+                             destfilename,
                              filevar,
                              var)
-            systemd_rights.append(f'C {filename} {filevar["mode"]} {filevar["owner"]} {filevar["group"]} - -')
-            systemd_rights.append(f'z {filename} - - - - -')
+            else:
+                copy(source, destfilename)
 
     async def instance_files(self) -> None:
         """Run templatisation on all files
         """
         for option in await self.config.option.list(type='all'):
             namespace = await option.option.name()
-            if namespace in ['services', 'actions']:
-                continue
-            elif namespace == 'creole':
-                await self.load_eole_variables_creole(option)
+            if namespace == VARIABLE_NAMESPACE:
+                await self.load_eole_variables_rougail(option)
             else:
-                await self.load_eole_variables(namespace,
+                families = await self.load_eole_variables(namespace,
                                                           option)
+                self.rougail_variables_dict[namespace] = families
         for template in listdir(self.distrib_dir):
             self.prepare_template(join(self.distrib_dir, template))
-        systemd_rights = []
         for service_obj in await self.config.option('services').list('all'):
+            service_name = await service_obj.option.doc()
             for fills in await service_obj.list('all'):
-                if await fills.option.name() == 'files':
+                if await fills.option.name() in ['files', 'overrides']:
                     for fill_obj in await fills.list('all'):
                         fill = await fill_obj.value.dict()
                         filename = fill['source']
@@ -421,23 +393,22 @@ class CreoleTemplateEngine:
                             raise FileNotFound(_(f"File {distib_file} does not exist."))
                         if fill.get('activate', False):
                             self.instance_file(fill,
-                                               systemd_rights)
+                                               service_name,
+                                               )
                         else:
                             log.debug(_("Instantiation of file '{filename}' disabled"))
 
-        with open(join(self.dest_dir, 'rougail.conf'), 'w') as fh:
-            fh.write('\n'.join(systemd_rights))
-            fh.write('\n')
-
 
 async def generate(config: Config,
                    eosfunc_file: str,
                    distrib_dir: str,
                    tmp_dir: str,
-             dest_dir: str) -> None:
+                   dest_dir: str,
+                   ) -> None:
     engine = CreoleTemplateEngine(config,
                                   eosfunc_file,
                                   distrib_dir,
                                   tmp_dir,
-                                  dest_dir)
+                                  dest_dir,
+                                  )
     await engine.instance_files()

src/rougail/xmlreflector.py

@@ -35,23 +35,18 @@ class XMLReflector(object):
 
         :returns: the root element tree object
         """
-        # FIXME zephir2
         # document = parse(BytesIO(xmlfile), XMLParser(remove_blank_text=True))
         document = parse(xmlfile)
         if not self.dtd.validate(document):
             raise CreoleDictConsistencyError(_("not a valid xml file: {}").format(xmlfile))
         return document.getroot()
 
-    def load_xml_from_folders(self, xmlfolders, from_zephir):
+    def load_xml_from_folders(self, xmlfolders):
         """Loads all the XML files located in the xmlfolders' list
 
         :param xmlfolders: list of full folder's name
         """
         documents = []
-        if from_zephir:
-            for idx, xmlfile in enumerate(xmlfolders):
-                documents.append(('generate_{}'.format(idx), self.parse_xmlfile(xmlfile, from_zephir=from_zephir)))
-        else:
         if not isinstance(xmlfolders, list):
             xmlfolders = [xmlfolders]
         for xmlfolder in xmlfolders:

tests/eosfunc/test.py

@@ -59,3 +59,7 @@ def cdrom_minormajor(*args, **kwargs):
 
 def device_type(*args, **kwargs):
     pass
+
+
+def calc_list(*args, **kwargs):
+    return []

tests/flattener_dicos/00empty/result/00-base.xml

@@ -1,8 +1,7 @@
 <?xml version='1.0' encoding='UTF-8'?>
-<creole>
-  <family name="services">
-    <family name="service0" doc="tata">
-      <property>basic</property>
+<rougail>
+  <family name="services" doc="services">
+    <property>hidden</property>
+    <family doc="tata" name="tata"/>
   </family>
-  </family>
-</creole>
+</rougail>

tests/flattener_dicos/00load_autofreeze/00-base.xml

@@ -1,8 +1,6 @@
 <?xml version='1.0' encoding='UTF-8'?>
 <rougail>
 
-    <services/>
-
     <variables>
         <family name="général">
             <variable name="mode_conteneur_actif" type="oui/non" description="No change" auto_freeze="True">

tests/flattener_dicos/00load_autofreeze/makedict/base.json

@@ -1 +1 @@
-{"creole.general.mode_conteneur_actif": "non", "creole.general.module_instancie": "non"}
+{"rougail.general.mode_conteneur_actif": "non", "rougail.general.module_instancie": "non"}

tests/flattener_dicos/00load_autofreeze/result/00-base.xml

@@ -1,6 +1,6 @@
 <?xml version='1.0' encoding='UTF-8'?>
-<creole>
-  <family doc="" name="creole">
+<rougail>
+  <family doc="rougail" name="rougail">
     <family doc="général" name="general">
       <property>basic</property>
       <variable doc="No change" multi="False" name="mode_conteneur_actif" type="choice">
@@ -10,7 +10,7 @@
         <choice type="string">non</choice>
         <property>mandatory</property>
         <property>basic</property>
-        <property expected="oui" inverse="True" source="creole.general.module_instancie" type="calculation">auto_frozen</property>
+        <property expected="oui" inverse="True" source="rougail.general.module_instancie" type="calculation">auto_frozen</property>
         <value type="string">non</value>
       </variable>
       <variable doc="No change" multi="False" name="module_instancie" type="choice">
@@ -23,4 +23,4 @@
     </family>
     <separators/>
   </family>
-</creole>
+</rougail>

tests/flattener_dicos/00load_autofreezeexpert/makedict/base.json

@@ -1 +1 @@
-{"creole.general.mode_conteneur_actif": "non", "creole.general.module_instancie": "non"}
+{"rougail.general.mode_conteneur_actif": "non", "rougail.general.module_instancie": "non"}

tests/flattener_dicos/00load_autofreezeexpert/result/00-base.xml

@@ -1,6 +1,6 @@
 <?xml version='1.0' encoding='UTF-8'?>
-<creole>
-  <family doc="" name="creole">
+<rougail>
+  <family doc="rougail" name="rougail">
     <family doc="général" name="general">
       <property>normal</property>
       <variable doc="No change" multi="False" name="mode_conteneur_actif" type="choice">
@@ -10,7 +10,7 @@
         <choice type="string">non</choice>
         <property>mandatory</property>
         <property>expert</property>
-        <property expected="oui" inverse="True" source="creole.general.module_instancie" type="calculation">auto_frozen</property>
+        <property expected="oui" inverse="True" source="rougail.general.module_instancie" type="calculation">auto_frozen</property>
         <value type="string">non</value>
       </variable>
       <variable doc="No change" multi="False" name="module_instancie" type="choice">
@@ -23,4 +23,4 @@
     </family>
     <separators/>
   </family>
-</creole>
+</rougail>

tests/flattener_dicos/00load_autosave/makedict/base.json

@@ -1 +1 @@
-{"creole.general.mode_conteneur_actif": "non"}
+{"rougail.general.mode_conteneur_actif": "non"}

tests/flattener_dicos/00load_autosave/result/00-base.xml

@@ -1,6 +1,6 @@
 <?xml version='1.0' encoding='UTF-8'?>
-<creole>
-  <family doc="" name="creole">
+<rougail>
+  <family doc="rougail" name="rougail">
     <family doc="général" name="general">
       <property>basic</property>
       <variable doc="No change" multi="False" name="mode_conteneur_actif" type="choice">
@@ -14,4 +14,4 @@
     </family>
     <separators/>
   </family>
-</creole>
+</rougail>

tests/flattener_dicos/00load_autosaveexpert/makedict/base.json

@@ -1 +1 @@
-{"creole.general.mode_conteneur_actif": "non"}
+{"rougail.general.mode_conteneur_actif": "non"}

tests/flattener_dicos/00load_autosaveexpert/result/00-base.xml

@@ -1,6 +1,6 @@
 <?xml version='1.0' encoding='UTF-8'?>
-<creole>
-  <family doc="" name="creole">
+<rougail>
+  <family doc="rougail" name="rougail">
     <family doc="général" name="general">
       <property>expert</property>
       <variable doc="No change" multi="False" name="mode_conteneur_actif" type="choice">
@@ -14,4 +14,4 @@
     </family>
     <separators/>
   </family>
-</creole>
+</rougail>

tests/flattener_dicos/00load_comment/makedict/base.json

@@ -0,0 +1 @@
+{"rougail.general.mode_conteneur_actif": "non"}

tests/flattener_dicos/00load_comment/result/00-base.xml

@@ -1,6 +1,6 @@
 <?xml version='1.0' encoding='UTF-8'?>
-<creole>
-  <family doc="" name="creole">
+<rougail>
+  <family doc="rougail" name="rougail">
     <family doc="général" name="general">
       <property>normal</property>
       <variable doc="No change" multi="False" name="mode_conteneur_actif" type="choice">
@@ -16,4 +16,4 @@
     </family>
     <separators/>
   </family>
-</creole>
+</rougail>

tests/flattener_dicos/00load_notype/makedict/base.json

@@ -1 +1 @@
-{"creole.general.without_type": "non"}
+{"rougail.general.mode_conteneur_actif": "non", "rougail.general.without_type": "non"}

tests/flattener_dicos/00load_notype/result/00-base.xml

@@ -1,6 +1,6 @@
 <?xml version='1.0' encoding='UTF-8'?>
-<creole>
-  <family doc="" name="creole">
+<rougail>
+  <family doc="rougail" name="rougail">
     <family doc="général" name="general">
       <property>normal</property>
       <variable doc="No change" multi="False" name="mode_conteneur_actif" type="choice">
@@ -21,4 +21,4 @@
     </family>
     <separators/>
   </family>
-</creole>
+</rougail>

tests/flattener_dicos/00load_save/makedict/base.json

@@ -0,0 +1 @@
+{"rougail.general.mode_conteneur_actif": "non"}

tests/flattener_dicos/00load_save/result/00-base.xml

@@ -1,6 +1,6 @@
 <?xml version='1.0' encoding='UTF-8'?>
-<creole>
-  <family doc="" name="creole">
+<rougail>
+  <family doc="rougail" name="rougail">
     <family doc="général" name="general">
       <property>normal</property>
       <variable doc="No change" multi="False" name="mode_conteneur_actif" type="choice">
@@ -16,4 +16,4 @@
     </family>
     <separators/>
   </family>
-</creole>
+</rougail>

tests/flattener_dicos/00load_subfolder/makedict/base.json

@@ -0,0 +1 @@
+{"rougail.general.mode_conteneur_actif": "non", "rougail.general.mode_conteneur_actif1": "non"}

tests/flattener_dicos/00load_subfolder/result/00-base.xml

@@ -1,6 +1,6 @@
 <?xml version='1.0' encoding='UTF-8'?>
-<creole>
-  <family doc="" name="creole">
+<rougail>
+  <family doc="rougail" name="rougail">
     <family doc="général" name="general">
       <property>normal</property>
       <variable doc="No change" multi="False" name="mode_conteneur_actif" type="choice">
@@ -26,4 +26,4 @@
     </family>
     <separators/>
   </family>
-</creole>
+</rougail>

tests/flattener_dicos/01auto_base/00-base.xml

@@ -16,9 +16,9 @@
     </variables>
 
     <constraints>
-        <auto name="calc_val" target="mode_conteneur_actif">
+        <fill name="calc_val" target="mode_conteneur_actif">
             <param type="variable">mode_conteneur_actif1</param>
-        </auto>
+        </fill>
     </constraints>
 
     <help/>

tests/flattener_dicos/01auto_base/makedict/base.json

@@ -1 +1 @@
-{"creole.general.mode_conteneur_actif1": "non"}
+{"rougail.general.mode_conteneur_actif": null, "rougail.general.mode_conteneur_actif1": "non"}

tests/flattener_dicos/01auto_base/result/00-base.xml

@@ -1,6 +1,6 @@
 <?xml version='1.0' encoding='UTF-8'?>
-<creole>
-  <family doc="" name="creole">
+<rougail>
+  <family doc="rougail" name="rougail">
     <family doc="general" name="general">
       <property>normal</property>
       <variable doc="No change" multi="False" name="mode_conteneur_actif" type="choice">
@@ -12,7 +12,7 @@
         <property>mandatory</property>
         <property>normal</property>
         <value name="calc_val" type="calculation">
-          <param transitive="False" type="variable">creole.general.mode_conteneur_actif1</param>
+          <param transitive="False" type="variable">rougail.general.mode_conteneur_actif1</param>
         </value>
       </variable>
       <variable doc="No change" multi="False" name="mode_conteneur_actif1" type="choice">
@@ -25,4 +25,4 @@
     </family>
     <separators/>
   </family>
-</creole>
+</rougail>

tests/flattener_dicos/01auto_withoutparam/00-base.xml

@@ -16,8 +16,8 @@
     </variables>
 
     <constraints>
-        <auto name="calc_val" target="mode_conteneur_actif">
-        </auto>
+        <fill name="calc_val" target="mode_conteneur_actif">
+        </fill>
     </constraints>
 
     <help/>

tests/flattener_dicos/01auto_withoutparam/makedict/base.json

@@ -1 +1 @@
-{"creole.general.mode_conteneur_actif1": "non"}
+{"rougail.general.mode_conteneur_actif": null, "rougail.general.mode_conteneur_actif1": "non"}

tests/flattener_dicos/01auto_withoutparam/result/00-base.xml

@@ -1,6 +1,6 @@
 <?xml version='1.0' encoding='UTF-8'?>
-<creole>
-  <family doc="" name="creole">
+<rougail>
+  <family doc="rougail" name="rougail">
     <family doc="general" name="general">
       <property>normal</property>
       <variable doc="No change" multi="False" name="mode_conteneur_actif" type="choice">
@@ -23,4 +23,4 @@
     </family>
     <separators/>
   </family>
-</creole>
+</rougail>

tests/flattener_dicos/01base_multi/makedict/base.json

@@ -0,0 +1 @@
+{"rougail.general.mode_conteneur_actif": ["non"]}

tests/flattener_dicos/01base_multi/result/00-base.xml

@@ -1,6 +1,6 @@
 <?xml version='1.0' encoding='UTF-8'?>
-<creole>
-  <family doc="" name="creole">
+<rougail>
+  <family doc="rougail" name="rougail">
     <family doc="general" name="general">
       <property>normal</property>
       <variable doc="Redefine description" multi="True" name="mode_conteneur_actif" type="choice">
@@ -16,4 +16,4 @@
     </family>
     <separators/>
   </family>
-</creole>
+</rougail>

tests/flattener_dicos/01base_submulti/makedict/base.json

@@ -0,0 +1 @@
+{"rougail.general.mode_conteneur_actif": [["non"]]}

tests/flattener_dicos/01base_submulti/result/00-base.xml

@@ -1,6 +1,6 @@
 <?xml version='1.0' encoding='UTF-8'?>
-<creole>
-  <family doc="" name="creole">
+<rougail>
+  <family doc="rougail" name="rougail">
     <family doc="general" name="general">
       <property>normal</property>
       <variable doc="Redefine description" multi="submulti" name="mode_conteneur_actif" type="choice">
@@ -16,4 +16,4 @@
     </family>
     <separators/>
   </family>
-</creole>
+</rougail>

tests/flattener_dicos/01fill_autofreeze/makedict/base.json

@@ -1 +1 @@
-{"creole.general.mode_conteneur_actif": null, "creole.general.mode_conteneur_actif1": "non", "creole.general.module_instancie": "non"}
+{"rougail.general.mode_conteneur_actif": null, "rougail.general.mode_conteneur_actif1": "non", "rougail.general.module_instancie": "non"}

tests/flattener_dicos/01fill_autofreeze/result/00-base.xml

@@ -1,6 +1,6 @@
 <?xml version='1.0' encoding='UTF-8'?>
-<creole>
-  <family doc="" name="creole">
+<rougail>
+  <family doc="rougail" name="rougail">
     <family doc="general" name="general">
       <property>basic</property>
       <variable doc="No change" multi="False" name="mode_conteneur_actif" type="choice">
@@ -10,9 +10,9 @@
         <choice type="string">non</choice>
         <property>mandatory</property>
         <property>basic</property>
-        <property expected="oui" inverse="True" source="creole.general.module_instancie" type="calculation">auto_frozen</property>
+        <property expected="oui" inverse="True" source="rougail.general.module_instancie" type="calculation">auto_frozen</property>
         <value name="calc_val" type="calculation">
-          <param transitive="False" type="variable">creole.general.mode_conteneur_actif1</param>
+          <param transitive="False" type="variable">rougail.general.mode_conteneur_actif1</param>
         </value>
       </variable>
       <variable doc="No change" multi="False" name="mode_conteneur_actif1" type="choice">
@@ -32,4 +32,4 @@
     </family>
     <separators/>
   </family>
-</creole>
+</rougail>

tests/flattener_dicos/01fill_autosave/makedict/base.json

@@ -1 +1 @@
-{"creole.general.mode_conteneur_actif": null, "creole.general.mode_conteneur_actif1": "non"}
+{"rougail.general.mode_conteneur_actif": null, "rougail.general.mode_conteneur_actif1": "non"}

tests/flattener_dicos/01fill_autosave/result/00-base.xml

@@ -1,6 +1,6 @@
 <?xml version='1.0' encoding='UTF-8'?>
-<creole>
-  <family doc="" name="creole">
+<rougail>
+  <family doc="rougail" name="rougail">
     <family doc="general" name="general">
       <property>basic</property>
       <variable doc="No change" multi="False" name="mode_conteneur_actif" type="choice">
@@ -10,7 +10,7 @@
         <property>mandatory</property>
         <property>basic</property>
         <value name="calc_val" type="calculation">
-          <param transitive="False" type="variable">creole.general.mode_conteneur_actif1</param>
+          <param transitive="False" type="variable">rougail.general.mode_conteneur_actif1</param>
         </value>
       </variable>
       <variable doc="No change" multi="False" name="mode_conteneur_actif1" type="choice">
@@ -23,4 +23,4 @@
     </family>
     <separators/>
   </family>
-</creole>
+</rougail>

tests/flattener_dicos/01fill_base/makedict/base.json

@@ -1 +1 @@
-{"creole.general.mode_conteneur_actif1": "non"}
+{"rougail.general.mode_conteneur_actif": null, "rougail.general.mode_conteneur_actif1": "non"}

tests/flattener_dicos/01fill_base/result/00-base.xml

@@ -1,6 +1,6 @@
 <?xml version='1.0' encoding='UTF-8'?>
-<creole>
-  <family doc="" name="creole">
+<rougail>
+  <family doc="rougail" name="rougail">
     <family doc="general" name="general">
       <property>normal</property>
       <variable doc="No change" multi="False" name="mode_conteneur_actif" type="choice">
@@ -12,7 +12,7 @@
         <property>mandatory</property>
         <property>normal</property>
         <value name="calc_val" type="calculation">
-          <param transitive="False" type="variable">creole.general.mode_conteneur_actif1</param>
+          <param transitive="False" type="variable">rougail.general.mode_conteneur_actif1</param>
         </value>
       </variable>
       <variable doc="No change" multi="False" name="mode_conteneur_actif1" type="choice">
@@ -25,4 +25,4 @@
     </family>
     <separators/>
   </family>
-</creole>
+</rougail>

tests/flattener_dicos/01fill_baseaccent/makedict/base.json

@@ -1 +1 @@
-{"creole.general.mode_conteneur_actif1": "non"}
+{"rougail.general.mode_conteneur_actif": null, "rougail.general.mode_conteneur_actif1": "non"}

tests/flattener_dicos/01fill_baseaccent/result/00-base.xml

@@ -1,6 +1,6 @@
 <?xml version='1.0' encoding='UTF-8'?>
-<creole>
-  <family doc="" name="creole">
+<rougail>
+  <family doc="rougail" name="rougail">
     <family doc="Général" name="general">
       <property>normal</property>
       <variable doc="No change" multi="False" name="mode_conteneur_actif" type="choice">
@@ -12,7 +12,7 @@
         <property>mandatory</property>
         <property>normal</property>
         <value name="calc_val" type="calculation">
-          <param transitive="False" type="variable">creole.general.mode_conteneur_actif1</param>
+          <param transitive="False" type="variable">rougail.general.mode_conteneur_actif1</param>
         </value>
       </variable>
       <variable doc="No change" multi="False" name="mode_conteneur_actif1" type="choice">
@@ -25,4 +25,4 @@
     </family>
     <separators/>
   </family>
-</creole>
+</rougail>

tests/flattener_dicos/01fill_mandatory/makedict/base.json

@@ -1 +1 @@
-{"creole.general.mode_conteneur_actif": null, "creole.general.mode_conteneur_actif1": "non"}
+{"rougail.general.mode_conteneur_actif": null, "rougail.general.mode_conteneur_actif1": "non"}

tests/flattener_dicos/01fill_mandatory/result/00-base.xml

@@ -1,13 +1,13 @@
 <?xml version='1.0' encoding='UTF-8'?>
-<creole>
-  <family doc="" name="creole">
+<rougail>
+  <family doc="rougail" name="rougail">
     <family doc="general" name="general">
       <property>normal</property>
       <variable doc="No change" multi="False" name="mode_conteneur_actif" type="domain">
         <property>mandatory</property>
         <property>expert</property>
         <value name="calc_val" type="calculation">
-          <param transitive="False" type="variable">creole.general.mode_conteneur_actif1</param>
+          <param transitive="False" type="variable">rougail.general.mode_conteneur_actif1</param>
         </value>
       </variable>
       <variable doc="No change" multi="False" name="mode_conteneur_actif1" type="choice">
@@ -20,4 +20,4 @@
     </family>
     <separators/>
   </family>
-</creole>
+</rougail>

tests/flattener_dicos/01fill_number/makedict/base.json

@@ -1 +1 @@
-{"creole.general.mode_conteneur_actif1": "non"}
+{"rougail.general.mode_conteneur_actif": null, "rougail.general.mode_conteneur_actif1": "non"}

tests/flattener_dicos/01fill_number/result/00-base.xml

@@ -1,12 +1,13 @@
 <?xml version='1.0' encoding='UTF-8'?>
-<creole>
-  <family doc="" name="creole">
+<rougail>
+  <family doc="rougail" name="rougail">
     <family doc="general" name="general">
       <property>normal</property>
       <variable doc="No change" multi="False" name="mode_conteneur_actif" type="number">
         <property>force_default_on_freeze</property>
         <property>frozen</property>
         <property>hidden</property>
+        <property>mandatory</property>
         <property>normal</property>
         <value name="calc_val" type="calculation">
           <param transitive="False" type="number">3</param>
@@ -22,4 +23,4 @@
     </family>
     <separators/>
   </family>
-</creole>
+</rougail>

tests/flattener_dicos/01fill_optional/makedict/base.json

@@ -1 +1 @@
-{"creole.general.mode_conteneur_actif1": "non"}
+{"rougail.general.mode_conteneur_actif": null, "rougail.general.mode_conteneur_actif1": "non"}

tests/flattener_dicos/01fill_optional/result/00-base.xml

@@ -1,6 +1,6 @@
 <?xml version='1.0' encoding='UTF-8'?>
-<creole>
-  <family doc="" name="creole">
+<rougail>
+  <family doc="rougail" name="rougail">
     <family doc="general" name="general">
       <property>normal</property>
       <variable doc="No change" multi="False" name="mode_conteneur_actif" type="choice">
@@ -12,7 +12,7 @@
         <property>mandatory</property>
         <property>normal</property>
         <value name="calc_val" type="calculation">
-          <param transitive="False" type="variable">creole.general.mode_conteneur_actif1</param>
+          <param transitive="False" type="variable">rougail.general.mode_conteneur_actif1</param>
         </value>
       </variable>
       <variable doc="No change" multi="False" name="mode_conteneur_actif1" type="choice">
@@ -25,4 +25,4 @@
     </family>
     <separators/>
   </family>
-</creole>
+</rougail>

tests/flattener_dicos/01separator_base/makedict/base.json

@@ -0,0 +1 @@
+{"rougail.general.mode_conteneur_actif": "non"}

tests/flattener_dicos/01separator_base/result/00-base.xml

@@ -1,6 +1,6 @@
 <?xml version='1.0' encoding='UTF-8'?>
-<creole>
-  <family doc="" name="creole">
+<rougail>
+  <family doc="rougail" name="rougail">
     <family doc="general" name="general">
       <property>normal</property>
       <variable doc="No change" multi="False" name="mode_conteneur_actif" type="choice">
@@ -15,7 +15,7 @@
       </variable>
     </family>
     <separators>
-      <separator name="creole.general.mode_conteneur_actif">Établissement</separator>
+      <separator name="rougail.general.mode_conteneur_actif">Établissement</separator>
     </separators>
   </family>
-</creole>
+</rougail>

tests/flattener_dicos/01separator_neverhidden/00-base.xml

@@ -10,7 +10,7 @@
             </variable>
         </family>
         <separators>
-            <separator name="mode_conteneur_actif" never_hidden="True">Établissement</separator>
+            <separator name="mode_conteneur_actif">Établissement</separator>
         </separators>
     </variables>
 

tests/flattener_dicos/01separator_neverhidden/makedict/base.json

@@ -0,0 +1 @@
+{"rougail.general.mode_conteneur_actif": "non"}

tests/flattener_dicos/01separator_neverhidden/result/00-base.xml

@@ -1,6 +1,6 @@
 <?xml version='1.0' encoding='UTF-8'?>
-<creole>
-  <family doc="" name="creole">
+<rougail>
+  <family doc="rougail" name="rougail">
     <family doc="general" name="general">
       <property>normal</property>
       <variable doc="No change" multi="False" name="mode_conteneur_actif" type="choice">
@@ -15,7 +15,7 @@
       </variable>
     </family>
     <separators>
-      <separator name="creole.general.mode_conteneur_actif" never_hidden="True">Établissement</separator>
+      <separator name="rougail.general.mode_conteneur_actif">Établissement</separator>
     </separators>
   </family>
-</creole>
+</rougail>

tests/flattener_dicos/10autosave_hidden/makedict/base.json

@@ -0,0 +1 @@
+{"rougail.general.mode_conteneur_actif": "non", "rougail.general.autosavevar": null}

tests/flattener_dicos/10autosave_hidden/result/00-base.xml

@@ -1,6 +1,6 @@
 <?xml version='1.0' encoding='UTF-8'?>
-<creole>
-  <family doc="" name="creole">
+<rougail>
+  <family doc="rougail" name="rougail">
     <family doc="général" name="general">
       <property>basic</property>
       <variable doc="No change" multi="False" name="mode_conteneur_actif" type="choice">
@@ -17,6 +17,7 @@
         <property>force_store_value</property>
         <property>frozen</property>
         <property>hidden</property>
+        <property>mandatory</property>
         <property>basic</property>
         <value name="calc_val" type="calculation">
           <param transitive="False" type="string">oui</param>
@@ -25,4 +26,4 @@
     </family>
     <separators/>
   </family>
-</creole>
+</rougail>

tests/flattener_dicos/10autosave_hidden_frozenifin/00-base.xml

@@ -16,7 +16,7 @@
         <fill name="calc_val" target="autosavevar">
             <param>oui</param>
         </fill>
-        <condition name="frozen_if_in" source="mode_conteneur_actif">
+        <condition name="hidden_if_in" source="mode_conteneur_actif">
              <param>oui</param>
              <target type="variable">autosavevar</target>
         </condition>

tests/flattener_dicos/10autosave_hidden_frozenifin/makedict/base.json

@@ -1 +1 @@
-{"creole.general.autosavevar": null}
+{"rougail.general.mode_conteneur_actif": "non", "rougail.general.autosavevar": null}

tests/flattener_dicos/10autosave_hidden_frozenifin/result/00-base.xml

@@ -1,6 +1,6 @@
 <?xml version='1.0' encoding='UTF-8'?>
-<creole>
-  <family doc="" name="creole">
+<rougail>
+  <family doc="rougail" name="rougail">
     <family doc="général" name="general">
       <property>basic</property>
       <variable doc="No change" multi="False" name="mode_conteneur_actif" type="choice">
@@ -15,10 +15,11 @@
       </variable>
       <variable doc="autosave variable" multi="False" name="autosavevar" type="string">
         <property>force_store_value</property>
+        <property>mandatory</property>
         <property>basic</property>
-        <property expected="oui" inverse="False" source="creole.general.mode_conteneur_actif" type="calculation">frozen</property>
-        <property expected="oui" inverse="False" source="creole.general.mode_conteneur_actif" type="calculation">hidden</property>
-        <property expected="oui" inverse="False" source="creole.general.mode_conteneur_actif" type="calculation">force_default_on_freeze</property>
+        <property expected="oui" inverse="False" source="rougail.general.mode_conteneur_actif" type="calculation">frozen</property>
+        <property expected="oui" inverse="False" source="rougail.general.mode_conteneur_actif" type="calculation">hidden</property>
+        <property expected="oui" inverse="False" source="rougail.general.mode_conteneur_actif" type="calculation">force_default_on_freeze</property>
         <value name="calc_val" type="calculation">
           <param transitive="False" type="string">oui</param>
         </value>
@@ -26,4 +27,4 @@
     </family>
     <separators/>
   </family>
-</creole>
+</rougail>

tests/flattener_dicos/10check_base/makedict/base.json

@@ -1 +1 @@
-{"creole.general.mode_conteneur_actif": "b", "creole.general.int": null}
+{"rougail.general.mode_conteneur_actif": "b", "rougail.general.int": null}

tests/flattener_dicos/10check_base/result/00-base.xml

@@ -1,6 +1,6 @@
 <?xml version='1.0' encoding='UTF-8'?>
-<creole>
-  <family doc="" name="creole">
+<rougail>
+  <family doc="rougail" name="rougail">
     <family doc="general" name="general">
       <property>normal</property>
       <variable doc="No change" multi="False" name="mode_conteneur_actif" type="string">
@@ -18,4 +18,4 @@
     </family>
     <separators/>
   </family>
-</creole>
+</rougail>

tests/flattener_dicos/10check_option/makedict/base.json

@@ -1 +1 @@
-{"creole.general.mode_conteneur_actif": "b", "creole.general.int2": 100, "creole.general.int": null}
+{"rougail.general.mode_conteneur_actif": "b", "rougail.general.int2": 100, "rougail.general.int": null}

tests/flattener_dicos/10check_option/result/00-base.xml

@@ -1,6 +1,6 @@
 <?xml version='1.0' encoding='UTF-8'?>
-<creole>
-  <family doc="" name="creole">
+<rougail>
+  <family doc="rougail" name="rougail">
     <family doc="general" name="general">
       <property>normal</property>
       <variable doc="No change" multi="False" name="mode_conteneur_actif" type="string">
@@ -16,11 +16,11 @@
       <variable doc="No change" multi="False" name="int" type="number">
         <check name="valid_entier" warnings_only="False">
           <param name="mini" type="string">0</param>
-          <param name="maxi" type="variable">creole.general.int2</param>
+          <param name="maxi" type="variable">rougail.general.int2</param>
         </check>
         <property>normal</property>
       </variable>
     </family>
     <separators/>
   </family>
-</creole>
+</rougail>

tests/flattener_dicos/10check_optional/makedict/base.json

@@ -1 +1 @@
-{"creole.general.mode_conteneur_actif": "b", "creole.general.int": null, "creole.general.int2": null}
+{"rougail.general.mode_conteneur_actif": "b", "rougail.general.int": null, "rougail.general.int2": null}

tests/flattener_dicos/10check_optional/result/00-base.xml

@@ -1,6 +1,6 @@
 <?xml version='1.0' encoding='UTF-8'?>
-<creole>
-  <family doc="" name="creole">
+<rougail>
+  <family doc="rougail" name="rougail">
     <family doc="general" name="general">
       <property>normal</property>
       <variable doc="No change" multi="False" name="mode_conteneur_actif" type="string">
@@ -10,9 +10,8 @@
       </variable>
       <variable doc="No change" multi="False" name="int" type="number">
         <check name="valid_not_equal" warnings_only="False">
-          <param type="variable">creole.general.int2</param>
+          <param type="variable">rougail.general.int2</param>
         </check>
-        <check name="valid_not_equal" warnings_only="False"/>
         <property>normal</property>
       </variable>
       <variable doc="No change" multi="False" name="int2" type="number">
@@ -21,4 +20,4 @@
     </family>
     <separators/>
   </family>
-</creole>
+</rougail>

tests/flattener_dicos/10check_valid_differ/makedict/base.json

@@ -1 +1 @@
-{"creole.general.mode_conteneur_actif": "oui", "creole.general.mode_conteneur_actif1": "non"}
+{"rougail.general.mode_conteneur_actif": "oui", "rougail.general.mode_conteneur_actif1": "non"}

tests/flattener_dicos/10check_valid_differ/result/00-base.xml

@@ -1,11 +1,11 @@
 <?xml version='1.0' encoding='UTF-8'?>
-<creole>
-  <family doc="" name="creole">
+<rougail>
+  <family doc="rougail" name="rougail">
     <family doc="general" name="general">
       <property>normal</property>
       <variable doc="No change" multi="False" name="mode_conteneur_actif" type="choice">
         <check name="valid_not_equal" warnings_only="False">
-          <param type="variable">creole.general.mode_conteneur_actif1</param>
+          <param type="variable">rougail.general.mode_conteneur_actif1</param>
         </check>
         <choice type="string">oui</choice>
         <choice type="string">non</choice>
@@ -23,4 +23,4 @@
     </family>
     <separators/>
   </family>
-</creole>
+</rougail>

tests/flattener_dicos/10check_valid_differ_add/makedict/base.json

@@ -1 +1 @@
-{"creole.general.mode_conteneur_actif": "oui", "creole.general.mode_conteneur_actif1": "non", "creole.general.mode_conteneur_actif2": "non", "creole.general.mode_conteneur_actif3": "oui"}
+{"rougail.general.mode_conteneur_actif": "oui", "rougail.general.mode_conteneur_actif1": "non", "rougail.general.mode_conteneur_actif2": "non", "rougail.general.mode_conteneur_actif3": "oui"}

tests/flattener_dicos/10check_valid_differ_add/result/00-base.xml

@@ -1,6 +1,6 @@
 <?xml version='1.0' encoding='UTF-8'?>
-<creole>
-  <family doc="" name="creole">
+<rougail>
+  <family doc="rougail" name="rougail">
     <family doc="general" name="general">
       <property>normal</property>
       <variable doc="No change" multi="False" name="mode_conteneur_actif" type="choice">
@@ -26,16 +26,10 @@
       </variable>
       <variable doc="No change" multi="False" name="mode_conteneur_actif3" type="string">
         <check name="valid_not_equal" warnings_only="False">
-          <param type="variable">creole.general.mode_conteneur_actif1</param>
+          <param type="variable">rougail.general.mode_conteneur_actif1</param>
         </check>
         <check name="valid_not_equal" warnings_only="False">
-          <param type="variable">creole.general.mode_conteneur_actif2</param>
-        </check>
-        <check name="valid_not_equal" warnings_only="False">
-          <param type="variable">creole.general.mode_conteneur_actif1</param>
-        </check>
-        <check name="valid_not_equal" warnings_only="False">
-          <param type="variable">creole.general.mode_conteneur_actif2</param>
+          <param type="variable">rougail.general.mode_conteneur_actif2</param>
         </check>
         <property>mandatory</property>
         <property>normal</property>
@@ -44,4 +38,4 @@
     </family>
     <separators/>
   </family>
-</creole>
+</rougail>

tests/flattener_dicos/10check_valid_differ_removecheck/01-base.xml

@@ -5,7 +5,7 @@
 
     <variables>
         <family name="general">
-            <variable name="mode_conteneur_actif3" redefine="True" remove_check="True">
+            <variable name="mode_conteneur_actif3" redefine="True">
                 <value>oui</value>
             </variable>
         </family>

tests/flattener_dicos/10check_valid_differ_removecheck/makedict/base.json

@@ -1 +1 @@
-{"creole.general.mode_conteneur_actif": "oui", "creole.general.mode_conteneur_actif1": "non", "creole.general.mode_conteneur_actif2": "non", "creole.general.mode_conteneur_actif3": "oui"}
+{"rougail.general.mode_conteneur_actif": "oui", "rougail.general.mode_conteneur_actif1": "non", "rougail.general.mode_conteneur_actif2": "non", "rougail.general.mode_conteneur_actif3": "oui"}

tests/flattener_dicos/10check_valid_differ_removecheck/result/00-base.xml

@@ -1,6 +1,6 @@
 <?xml version='1.0' encoding='UTF-8'?>
-<creole>
-  <family doc="" name="creole">
+<rougail>
+  <family doc="rougail" name="rougail">
     <family doc="general" name="general">
       <property>normal</property>
       <variable doc="No change" multi="False" name="mode_conteneur_actif" type="choice">
@@ -26,10 +26,10 @@
       </variable>
       <variable doc="No change" multi="False" name="mode_conteneur_actif3" type="string">
         <check name="valid_not_equal" warnings_only="False">
-          <param type="variable">creole.general.mode_conteneur_actif1</param>
+          <param type="variable">rougail.general.mode_conteneur_actif1</param>
         </check>
         <check name="valid_not_equal" warnings_only="False">
-          <param type="variable">creole.general.mode_conteneur_actif2</param>
+          <param type="variable">rougail.general.mode_conteneur_actif2</param>
         </check>
         <property>mandatory</property>
         <property>normal</property>
@@ -38,4 +38,4 @@
     </family>
     <separators/>
   </family>
-</creole>
+</rougail>

tests/flattener_dicos/10check_valid_ipnetmask/makedict/base.json

@@ -1 +1 @@
-{"creole.general.mode_conteneur_actif": "oui", "creole.general.adresse_ip_eth0": null, "creole.general.adresse_netmask_eth0": null}
+{"rougail.general.mode_conteneur_actif": "oui", "rougail.general.adresse_ip_eth0": null, "rougail.general.adresse_netmask_eth0": null}

tests/flattener_dicos/10check_valid_ipnetmask/result/00-base.xml

@@ -1,6 +1,6 @@
 <?xml version='1.0' encoding='UTF-8'?>
-<creole>
-  <family doc="" name="creole">
+<rougail>
+  <family doc="rougail" name="rougail">
     <family doc="general" name="general">
       <property>basic</property>
       <variable doc="No change" multi="False" name="mode_conteneur_actif" type="choice">
@@ -16,7 +16,7 @@
       </variable>
       <variable doc="Masque de sous réseau de la carte" multi="False" name="adresse_netmask_eth0" type="netmask">
         <check name="valid_ip_netmask" warnings_only="True">
-          <param type="variable">creole.general.adresse_ip_eth0</param>
+          <param type="variable">rougail.general.adresse_ip_eth0</param>
         </check>
         <property>mandatory</property>
         <property>basic</property>
@@ -24,4 +24,4 @@
     </family>
     <separators/>
   </family>
-</creole>
+</rougail>

tests/flattener_dicos/10leadership_append/00-base.xml

@@ -0,0 +1,34 @@
+<?xml version='1.0' encoding='UTF-8'?>
+<rougail>
+
+    <services/>
+
+    <variables>
+        <family name="general">
+            <variable name="mode_conteneur_actif" type="oui/non" description="No change">
+                <value>non</value>
+            </variable>
+        </family>
+        <family name="general1">
+            <variable name="leader" type="string" description="leader" multi="True"/>
+            <variable name="follower1" type="string" description="follower1" multi="True"/>
+            <variable name="follower2" type="string" description="follower2" multi="True"/>
+        </family>
+    </variables>
+
+    <constraints>
+        <fill name="calc_val" target="follower1">
+            <param name="valeur">valfill</param>
+        </fill>
+        <fill name="calc_val" target="follower2">
+            <param type="variable">follower1</param>
+        </fill>
+        <group leader="leader">
+            <follower>follower1</follower>
+            <follower>follower2</follower>
+        </group>
+    </constraints>
+
+    <help/>
+
+</rougail>

tests/flattener_dicos/10leadership_append/01-base.xml

@@ -5,13 +5,13 @@
 
     <variables>
         <family name="general1">
-            <variable name="slave3" type="string" description="slave3" multi="True"/>
+            <variable name="follower3" type="string" description="follower3" multi="True"/>
         </family>
     </variables>
 
     <constraints>
-	<group master="master">
-            <slave>slave3</slave>
+	<group leader="leader">
+            <follower>follower3</follower>
 	</group>
     </constraints>
 

tests/flattener_dicos/10leadership_append/makedict/base.json

@@ -0,0 +1 @@
+{"rougail.general.mode_conteneur_actif": "non", "rougail.general1.leader.leader": [], "rougail.general1.leader.follower1": [], "rougail.general1.leader.follower2": [], "rougail.general1.leader.follower3": []}

tests/flattener_dicos/10leadership_append/result/00-base.xml

@@ -0,0 +1,39 @@
+<?xml version='1.0' encoding='UTF-8'?>
+<rougail>
+  <family doc="rougail" name="rougail">
+    <family doc="general" name="general">
+      <property>normal</property>
+      <variable doc="No change" multi="False" name="mode_conteneur_actif" type="choice">
+        <choice type="string">oui</choice>
+        <choice type="string">non</choice>
+        <property>mandatory</property>
+        <property>normal</property>
+        <value type="string">non</value>
+      </variable>
+    </family>
+    <family doc="general1" name="general1">
+      <property>normal</property>
+      <leader doc="leader" name="leader">
+        <property>normal</property>
+        <variable doc="leader" multi="True" name="leader" type="string"/>
+        <variable doc="follower1" multi="True" name="follower1" type="string">
+          <property>mandatory</property>
+          <property>normal</property>
+          <value name="calc_val" type="calculation">
+            <param name="valeur" transitive="False" type="string">valfill</param>
+          </value>
+        </variable>
+        <variable doc="follower2" multi="True" name="follower2" type="string">
+          <property>mandatory</property>
+          <property>normal</property>
+          <value name="calc_val" type="calculation">
+            <param transitive="False" type="variable">rougail.general1.leader.follower1</param>
+          </value>
+        </variable>
+        <variable doc="follower3" multi="True" name="follower3" type="string">
+          <property>normal</property>
+        </variable>
+      </leader>
+    </family>
+  </family>
+</rougail>

tests/flattener_dicos/10leadership_auto/00-base.xml

@@ -0,0 +1,37 @@
+<?xml version='1.0' encoding='UTF-8'?>
+<rougail>
+
+    <services/>
+
+    <variables>
+        <family name="general">
+            <variable name="mode_conteneur_actif" type="oui/non" description="No change">
+                <value>non</value>
+            </variable>
+            <variable name="leader" type="string" description="leader" multi="True"/>
+            <variable name="follower1" type="string" description="follower1" multi="True" hidden="True"/>
+            <variable name="follower2" type="string" description="follower2" multi="True" hidden="True"/>
+            <variable name="follower3" type="string" description="follower3" multi="True" hidden="True"/>
+        </family>
+    </variables>
+
+    <constraints>
+        <fill name="calc_val" target="follower1">
+            <param name="valeur">valfill</param>
+        </fill>
+        <fill name="calc_val" target="follower2">
+            <param type="variable">follower1</param>
+        </fill>
+        <fill name="calc_val" target="follower3">
+            <param type="variable">leader</param>
+        </fill>
+        <group leader="leader">
+            <follower>follower1</follower>
+            <follower>follower2</follower>
+            <follower>follower3</follower>
+        </group>
+    </constraints>
+
+    <help/>
+
+</rougail>

tests/flattener_dicos/10leadership_auto/makedict/base.json

@@ -0,0 +1 @@
+{"rougail.general.mode_conteneur_actif": "non", "rougail.general.leader.leader": [], "rougail.general.leader.follower1": [], "rougail.general.leader.follower2": [], "rougail.general.leader.follower3": []}

tests/flattener_dicos/10leadership_auto/result/00-base.xml

@@ -1,6 +1,6 @@
 <?xml version='1.0' encoding='UTF-8'?>
-<creole>
-  <family doc="" name="creole">
+<rougail>
+  <family doc="rougail" name="rougail">
     <family doc="general" name="general">
       <property>normal</property>
       <variable doc="No change" multi="False" name="mode_conteneur_actif" type="choice">
@@ -10,37 +10,40 @@
         <property>normal</property>
         <value type="string">non</value>
       </variable>
-      <leader doc="master" name="master">
+      <leader doc="leader" name="leader">
         <property>normal</property>
-        <variable doc="master" multi="True" name="master" type="string"/>
-        <variable doc="slave1" multi="True" name="slave1" type="string">
+        <variable doc="leader" multi="True" name="leader" type="string"/>
+        <variable doc="follower1" multi="True" name="follower1" type="string">
           <property>force_default_on_freeze</property>
           <property>frozen</property>
           <property>hidden</property>
+          <property>mandatory</property>
           <property>normal</property>
           <value name="calc_val" type="calculation">
             <param name="valeur" transitive="False" type="string">valfill</param>
           </value>
         </variable>
-        <variable doc="slave2" multi="True" name="slave2" type="string">
+        <variable doc="follower2" multi="True" name="follower2" type="string">
           <property>force_default_on_freeze</property>
           <property>frozen</property>
           <property>hidden</property>
+          <property>mandatory</property>
           <property>normal</property>
           <value name="calc_val" type="calculation">
-            <param transitive="False" type="variable">creole.general.master.slave1</param>
+            <param transitive="False" type="variable">rougail.general.leader.follower1</param>
           </value>
         </variable>
-        <variable doc="slave3" multi="True" name="slave3" type="string">
+        <variable doc="follower3" multi="True" name="follower3" type="string">
           <property>force_default_on_freeze</property>
           <property>frozen</property>
           <property>hidden</property>
+          <property>mandatory</property>
           <property>normal</property>
           <value name="calc_val" type="calculation">
-            <param transitive="False" type="variable">creole.general.master.master</param>
+            <param transitive="False" type="variable">rougail.general.leader.leader</param>
           </value>
         </variable>
       </leader>
     </family>
   </family>
-</creole>
+</rougail>

tests/flattener_dicos/10leadership_autoleader/00-base.xml

@@ -0,0 +1,32 @@
+<?xml version='1.0' encoding='UTF-8'?>
+<rougail>
+
+    <services/>
+
+    <variables>
+        <family name="general">
+            <variable name="mode_conteneur_actif" type="oui/non" description="No change">
+                <value>non</value>
+            </variable>
+            <variable name="leader" type="string" description="leader" multi="True"/>
+            <variable name="follower1" type="string" description="follower1" multi="True" hidden="True"/>
+            <variable name="follower2" type="string" description="follower2" multi="True" hidden="True"/>
+        </family>
+    </variables>
+
+    <constraints>
+        <fill name="calc_val" target="follower1">
+            <param name="valeur">valfill</param>
+        </fill>
+        <fill name="calc_val" target="follower2">
+            <param type="variable">leader</param>
+        </fill>
+        <group leader="leader">
+            <follower>follower1</follower>
+            <follower>follower2</follower>
+        </group>
+    </constraints>
+
+    <help/>
+
+</rougail>

tests/flattener_dicos/10leadership_autoleader/makedict/base.json

@@ -0,0 +1 @@
+{"rougail.general.mode_conteneur_actif": "non", "rougail.general.leader.leader": [], "rougail.general.leader.follower1": [], "rougail.general.leader.follower2": []}

tests/flattener_dicos/10leadership_autoleader/result/00-base.xml

@@ -1,6 +1,6 @@
 <?xml version='1.0' encoding='UTF-8'?>
-<creole>
-  <family doc="" name="creole">
+<rougail>
+  <family doc="rougail" name="rougail">
     <family doc="general" name="general">
       <property>normal</property>
       <variable doc="No change" multi="False" name="mode_conteneur_actif" type="choice">
@@ -10,28 +10,30 @@
         <property>normal</property>
         <value type="string">non</value>
       </variable>
-      <leader doc="master" name="master">
+      <leader doc="leader" name="leader">
         <property>normal</property>
-        <variable doc="master" multi="True" name="master" type="string"/>
-        <variable doc="slave1" multi="True" name="slave1" type="string">
+        <variable doc="leader" multi="True" name="leader" type="string"/>
+        <variable doc="follower1" multi="True" name="follower1" type="string">
           <property>force_default_on_freeze</property>
           <property>frozen</property>
           <property>hidden</property>
+          <property>mandatory</property>
           <property>normal</property>
           <value name="calc_val" type="calculation">
             <param name="valeur" transitive="False" type="string">valfill</param>
           </value>
         </variable>
-        <variable doc="slave2" multi="True" name="slave2" type="string">
+        <variable doc="follower2" multi="True" name="follower2" type="string">
           <property>force_default_on_freeze</property>
           <property>frozen</property>
           <property>hidden</property>
+          <property>mandatory</property>
           <property>normal</property>
           <value name="calc_val" type="calculation">
-            <param transitive="False" type="variable">creole.general.master.master</param>
+            <param transitive="False" type="variable">rougail.general.leader.leader</param>
           </value>
         </variable>
       </leader>
     </family>
   </family>
-</creole>
+</rougail>

tests/flattener_dicos/10leadership_autoleader_expert/00-base.xml

@@ -0,0 +1,31 @@
+<?xml version='1.0' encoding='UTF-8'?>
+<rougail>
+
+    <services/>
+
+    <variables>
+        <family name="general" mode="expert">
+            <variable name="mode_conteneur_actif" type="oui/non" description="No change">
+                <value>non</value>
+            </variable>
+        </family>
+        <family name="leadermode" mode="expert">
+            <variable name="leader" type="string" description="leader" multi="True" hidden="True"/>
+            <variable name="follower1" type="string" description="follower1" multi="True"/>
+            <variable name="follower2" type="string" description="follower2" multi="True"/>
+        </family>
+    </variables>
+
+    <constraints>
+        <fill name="calc_list" target="leader">
+            <param name="valeur">valfill</param>
+        </fill>
+        <group leader="leader">
+            <follower>follower1</follower>
+            <follower>follower2</follower>
+        </group>
+    </constraints>
+
+    <help/>
+
+</rougail>

tests/flattener_dicos/10leadership_autoleader_expert/makedict/base.json

@@ -0,0 +1 @@
+{"rougail.general.mode_conteneur_actif": "non", "rougail.leadermode.leader.leader": [], "rougail.leadermode.leader.follower1": [], "rougail.leadermode.leader.follower2": []}

tests/flattener_dicos/10leadership_autoleader_expert/result/00-base.xml

@@ -1,6 +1,6 @@
 <?xml version='1.0' encoding='UTF-8'?>
-<creole>
-  <family doc="" name="creole">
+<rougail>
+  <family doc="rougail" name="rougail">
     <family doc="general" name="general">
       <property>expert</property>
       <variable doc="No change" multi="False" name="mode_conteneur_actif" type="choice">
@@ -11,25 +11,30 @@
         <value type="string">non</value>
       </variable>
     </family>
-    <family doc="mastermode" name="mastermode">
+    <family doc="leadermode" name="leadermode">
       <property>expert</property>
-      <leader doc="master" name="master">
+      <leader doc="leader" name="leader">
         <property>hidden</property>
         <property>expert</property>
-        <variable doc="master" multi="True" name="master" type="string">
+        <variable doc="leader" multi="True" name="leader" type="string">
           <property>force_default_on_freeze</property>
           <property>frozen</property>
-          <value name="calc_val" type="calculation">
+          <property>mandatory</property>
+          <value name="calc_list" type="calculation">
             <param name="valeur" transitive="False" type="string">valfill</param>
           </value>
         </variable>
-        <variable doc="slave1" multi="True" name="slave1" type="string">
+        <variable doc="follower1" multi="True" name="follower1" type="string">
+          <property>force_default_on_freeze</property>
+          <property>frozen</property>
           <property>expert</property>
         </variable>
-        <variable doc="slave2" multi="True" name="slave2" type="string">
+        <variable doc="follower2" multi="True" name="follower2" type="string">
+          <property>force_default_on_freeze</property>
+          <property>frozen</property>
           <property>expert</property>
         </variable>
       </leader>
     </family>
   </family>
-</creole>
+</rougail>

tests/flattener_dicos/10leadership_autosaveexpert/00-base.xml

@@ -0,0 +1,32 @@
+<?xml version='1.0' encoding='UTF-8'?>
+<rougail>
+
+    <services/>
+
+    <variables>
+        <family name="general">
+            <variable name="mode_conteneur_actif" type="oui/non" description="No change">
+                <value>non</value>
+            </variable>
+            <variable name="leader" type="string" description="leader" multi="True"/>
+            <variable name="follower1" type="string" description="follower1" multi="True"/>
+            <variable name="follower2" type="string" description="follower2" multi="True" mode="expert"/>
+        </family>
+    </variables>
+
+    <constraints>
+        <fill name="calc_val" target="follower1">
+            <param name="valeur">valfill</param>
+        </fill>
+        <fill name="calc_val" target="follower2">
+            <param type="variable">follower1</param>
+        </fill>
+        <group leader="leader">
+            <follower>follower1</follower>
+            <follower>follower2</follower>
+        </group>
+    </constraints>
+
+    <help/>
+
+</rougail>

tests/flattener_dicos/10leadership_autosaveexpert/makedict/base.json

@@ -0,0 +1 @@
+{"rougail.general.mode_conteneur_actif": "non", "rougail.general.leader.leader": [], "rougail.general.leader.follower1": [], "rougail.general.leader.follower2": []}

tests/flattener_dicos/10leadership_autosaveexpert/result/00-base.xml

@@ -1,6 +1,6 @@
 <?xml version='1.0' encoding='UTF-8'?>
-<creole>
-  <family doc="" name="creole">
+<rougail>
+  <family doc="rougail" name="rougail">
     <family doc="general" name="general">
       <property>normal</property>
       <variable doc="No change" multi="False" name="mode_conteneur_actif" type="choice">
@@ -10,22 +10,24 @@
         <property>normal</property>
         <value type="string">non</value>
       </variable>
-      <leader doc="master" name="master">
+      <leader doc="leader" name="leader">
         <property>normal</property>
-        <variable doc="master" multi="True" name="master" type="string"/>
-        <variable doc="slave1" multi="True" name="slave1" type="string">
+        <variable doc="leader" multi="True" name="leader" type="string"/>
+        <variable doc="follower1" multi="True" name="follower1" type="string">
+          <property>mandatory</property>
           <property>normal</property>
           <value name="calc_val" type="calculation">
             <param name="valeur" transitive="False" type="string">valfill</param>
           </value>
         </variable>
-        <variable doc="slave2" multi="True" name="slave2" type="string">
+        <variable doc="follower2" multi="True" name="follower2" type="string">
+          <property>mandatory</property>
           <property>expert</property>
           <value name="calc_val" type="calculation">
-            <param transitive="False" type="variable">creole.general.master.slave1</param>
+            <param transitive="False" type="variable">rougail.general.leader.follower1</param>
           </value>
         </variable>
       </leader>
     </family>
   </family>
-</creole>
+</rougail>

tests/flattener_dicos/10leadership_familyaccent/00-base.xml

@@ -0,0 +1,32 @@
+<?xml version='1.0' encoding='UTF-8'?>
+<rougail>
+
+    <services/>
+
+    <variables>
+        <family name="Général">
+            <variable name="mode_conteneur_actif" type="oui/non" description="No change">
+                <value>non</value>
+            </variable>
+            <variable name="leader" type="string" description="leader" multi="True"/>
+            <variable name="follower1" type="string" description="follower1" multi="True"/>
+            <variable name="follower2" type="string" description="follower2" multi="True"/>
+        </family>
+    </variables>
+
+    <constraints>
+        <fill name="calc_val" target="follower1">
+            <param name="valeur">valfill</param>
+        </fill>
+        <fill name="calc_val" target="follower2">
+            <param type="variable">follower1</param>
+        </fill>
+        <group leader="leader">
+            <follower>follower1</follower>
+            <follower>follower2</follower>
+        </group>
+    </constraints>
+
+    <help/>
+
+</rougail>

tests/flattener_dicos/10leadership_familyaccent/makedict/base.json

@@ -0,0 +1 @@
+{"rougail.general.mode_conteneur_actif": "non", "rougail.general.leader.leader": [], "rougail.general.leader.follower1": [], "rougail.general.leader.follower2": []}

tests/flattener_dicos/10leadership_familyaccent/result/00-base.xml

@@ -1,6 +1,6 @@
 <?xml version='1.0' encoding='UTF-8'?>
-<creole>
-  <family doc="" name="creole">
+<rougail>
+  <family doc="rougail" name="rougail">
     <family doc="Général" name="general">
       <property>normal</property>
       <variable doc="No change" multi="False" name="mode_conteneur_actif" type="choice">
@@ -10,22 +10,24 @@
         <property>normal</property>
         <value type="string">non</value>
       </variable>
-      <leader doc="master" name="master">
+      <leader doc="leader" name="leader">
         <property>normal</property>
-        <variable doc="master" multi="True" name="master" type="string"/>
-        <variable doc="slave1" multi="True" name="slave1" type="string">
+        <variable doc="leader" multi="True" name="leader" type="string"/>
+        <variable doc="follower1" multi="True" name="follower1" type="string">
+          <property>mandatory</property>
           <property>normal</property>
           <value name="calc_val" type="calculation">
             <param name="valeur" transitive="False" type="string">valfill</param>
           </value>
         </variable>
-        <variable doc="slave2" multi="True" name="slave2" type="string">
+        <variable doc="follower2" multi="True" name="follower2" type="string">
+          <property>mandatory</property>
           <property>normal</property>
           <value name="calc_val" type="calculation">
-            <param transitive="False" type="variable">creole.general.master.slave1</param>
+            <param transitive="False" type="variable">rougail.general.leader.follower1</param>
           </value>
         </variable>
       </leader>
     </family>
   </family>
-</creole>
+</rougail>

tests/flattener_dicos/10leadership_leadermandatory/00-base.xml

@@ -0,0 +1,32 @@
+<?xml version='1.0' encoding='UTF-8'?>
+<rougail>
+
+    <services/>
+
+    <variables>
+        <family name="general">
+            <variable name="mode_conteneur_actif" type="oui/non" description="No change">
+                <value>non</value>
+            </variable>
+            <variable name="leader" type="string" description="leader" multi="True" mandatory="True"/>
+            <variable name="follower1" type="string" description="follower1" multi="True"/>
+            <variable name="follower2" type="string" description="follower2" multi="True"/>
+        </family>
+    </variables>
+
+    <constraints>
+        <fill name="calc_val" target="follower1">
+            <param name="valeur">valfill</param>
+        </fill>
+        <fill name="calc_val" target="follower2">
+            <param type="variable">follower1</param>
+        </fill>
+        <group leader="leader">
+            <follower>follower1</follower>
+            <follower>follower2</follower>
+        </group>
+    </constraints>
+
+    <help/>
+
+</rougail>

tests/flattener_dicos/10leadership_leadermandatory/makedict/base.json

@@ -0,0 +1 @@
+{"rougail.general.mode_conteneur_actif": "non", "rougail.general.leader.leader": [], "rougail.general.leader.follower1": [], "rougail.general.leader.follower2": []}

tests/flattener_dicos/10leadership_leadermandatory/result/00-base.xml

@@ -1,6 +1,6 @@
 <?xml version='1.0' encoding='UTF-8'?>
-<creole>
-  <family doc="" name="creole">
+<rougail>
+  <family doc="rougail" name="rougail">
     <family doc="general" name="general">
       <property>basic</property>
       <variable doc="No change" multi="False" name="mode_conteneur_actif" type="choice">
@@ -10,24 +10,26 @@
         <property>normal</property>
         <value type="string">non</value>
       </variable>
-      <leader doc="master" name="master">
+      <leader doc="leader" name="leader">
         <property>basic</property>
-        <variable doc="master" multi="True" name="master" type="string">
+        <variable doc="leader" multi="True" name="leader" type="string">
           <property>mandatory</property>
         </variable>
-        <variable doc="slave1" multi="True" name="slave1" type="string">
+        <variable doc="follower1" multi="True" name="follower1" type="string">
+          <property>mandatory</property>
           <property>normal</property>
           <value name="calc_val" type="calculation">
             <param name="valeur" transitive="False" type="string">valfill</param>
           </value>
         </variable>
-        <variable doc="slave2" multi="True" name="slave2" type="string">
+        <variable doc="follower2" multi="True" name="follower2" type="string">
+          <property>mandatory</property>
           <property>normal</property>
           <value name="calc_val" type="calculation">
-            <param transitive="False" type="variable">creole.general.master.slave1</param>
+            <param transitive="False" type="variable">rougail.general.leader.follower1</param>
           </value>
         </variable>
       </leader>
     </family>
   </family>
-</creole>
+</rougail>