condition

creole/annotator.py

@@ -4,13 +4,11 @@ from copy import copy
 from collections import OrderedDict
 from os.path import join, basename
 from ast import literal_eval
-import sys
 import imp
 
 
 from .i18n import _
 from .utils import normalize_family
-from .config import VIRTBASE, VIRTROOT, VIRTMASTER, templatedir
 from .error import CreoleDictConsistencyError
 from .xmlreflector import HIGH_COMPATIBILITY
 
@@ -112,7 +110,7 @@ class ContainerAnnotator:
                     family.name = 'container{}'.format(idx)
                     family.doc = container.name
                     family.family = OrderedDict()
-                    self.convert_container_to_family(family.family, container)
+                    self.convert_container_to_family(family.name, family.family, container)
                     setattr(self.space.containers, family.name, family)
                 del self.space.containers.container
             else:
@@ -147,7 +145,7 @@ class ContainerAnnotator:
                                 old_container[name] = new_elt
             del self.space.containers.all
 
-    def convert_container_to_family(self, container_family, container):
+    def convert_container_to_family(self, container_name, container_family, container):
         # tranform container object to family object
         # add services, service_accesses, ...
         for elttype in self.objectspace.container_elt_attr_list:
@@ -168,7 +166,7 @@ class ContainerAnnotator:
                 family.family = self.make_group_from_elts(elttype,
                                                           values,
                                                           key_type,
-                                                          'containers.{}'.format(family.name),
+                                                          'containers.{}.{}'.format(container_name, family.name),
                                                           True)
                 family.mode = None
                 container_family[family.name] = family
@@ -219,7 +217,7 @@ class ContainerAnnotator:
         self.paths.append('variable', path, 'containers', 'containers', variable)
         return variable
 
-    def _make_disknod_auto(self, type_, index, variable):
+    def _make_disknod_auto(self, type_, index, variable, container_path):
         if not hasattr(self.space.constraints, 'auto'):
             self.space.constraints.auto = []
         auto = self.objectspace.auto()
@@ -233,12 +231,12 @@ class ContainerAnnotator:
         auto.param = [param1, param2]
         auto.name = 'cdrom_minormajor'
         family = 'disknod{}'.format(index)
-        auto.target = 'containers.disknods.{}.{}'.format(family, type_)
+        auto.target = '{}.{}.{}'.format(container_path, family, type_)
         if not hasattr(self.space, 'constraints'):
             self.space.constraints = self.objectspace.constraints()
         self.space.constraints.auto.append(auto)
 
-    def _make_disknod_type(self, index, variable):
+    def _make_disknod_type(self, index, variable, container_path):
         auto = self.objectspace.auto()
         self.objectspace.index += 1
         auto.index = self.objectspace.index
@@ -248,7 +246,7 @@ class ContainerAnnotator:
         auto.param = [param]
         auto.name = 'device_type'
         family = 'disknod{}'.format(index)
-        auto.target = 'containers.disknods.{}.type'.format(family)
+        auto.target = '{}.{}.type'.format(container_path, family)
         if not hasattr(self.space, 'constraints'):
             self.space.constraints = self.objectspace.constraints()
         if not hasattr(self.space.constraints, 'auto'):
@@ -256,17 +254,17 @@ class ContainerAnnotator:
         self.space.constraints.auto.append(auto)
 
 
-    def _update_disknod(self, disknod, index):
+    def _update_disknod(self, disknod, index, container_path):
         disknod.major = None
         disknod.minor = None
         disknod.type = None
-        self._make_disknod_auto('minor', index, disknod)
+        self._make_disknod_auto('minor', index, disknod, container_path)
-        self._make_disknod_auto('major', index, disknod)
+        self._make_disknod_auto('major', index, disknod, container_path)
-        self._make_disknod_type(index, disknod)
+        self._make_disknod_type(index, disknod, container_path)
         disknod.mode = u'rwm'
         disknod.permission = 'allow'
 
-    def _update_file(self, file_, index):
+    def _update_file(self, file_, index, container_path):
         if not hasattr(file_, 'source'):
             file_.source = basename(file_.name)
 
@@ -364,7 +362,7 @@ class ContainerAnnotator:
             # try to launch _update_xxxx() function
             update_elt = '_update_' + elt_name
             if hasattr(self, update_elt):
-                getattr(self, update_elt)(elt, index)
+                getattr(self, update_elt)(elt, index, path)
             variables = []
             subpath = '{}.{}{}'.format(path, name, index)
             listname = '{}list'.format(name)
@@ -387,6 +385,7 @@ class ContainerAnnotator:
                                                                 {}).setdefault(
                                                                     value,
                                                                     []).append(activate_path)
+                    continue
                 default_type = 'string'
                 if key in self.objectspace.booleans_attributs:
                     default_type = 'boolean'
@@ -487,13 +486,14 @@ class SpaceAnnotator(object):
         self.convert_helps()
 
     def absolute_path_for_symlink_in_containers(self):
-        if not hasattr(self.space, 'containers') or not hasattr(self.space.containers, 'family'):
+        if not hasattr(self.space, 'containers'):
             return
-        families = self.space.containers.family.values()
+        families = vars(self.space.containers).values()
         for family in families:
             if hasattr(family, 'family'):
-                for fam in family.family:
+                for fam in family.family.values():
-                    for variable in fam.variable:
+                    for fam1 in fam.family:
+                        for variable in fam1.variable:
                             if variable.type == 'symlink' and '.' not in variable.name:
                                 variable.opt = self.paths.get_variable_path(variable.opt, 'creole')
 
@@ -552,6 +552,9 @@ class SpaceAnnotator(object):
                                 leader_space = self.objectspace.Leadership()
                                 leader_space.variable = []
                                 leader_space.name = leader_name
+                                leader_space.hidden = variable.hidden
+                                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))
@@ -590,6 +593,7 @@ class SpaceAnnotator(object):
                     for variable in family.variable.values():
                         if isinstance(variable, self.objectspace.Leadership):
                             variable_mode = variable.variable[0].mode
+                            variable.variable[0].mode = None
                             variable.mode = variable_mode
                         else:
                             variable_mode = variable.mode
@@ -850,7 +854,12 @@ class SpaceAnnotator(object):
             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):
@@ -875,8 +884,8 @@ class SpaceAnnotator(object):
                     names.append(separator.name)
 
 
-    def load_params_in_validenum(self, param, probe):
+    def load_params_in_validenum(self, param):
-        if not probe and param.type in ['string', 'python', 'number']:
+        if param.type in ['string', 'python', 'number']:
             if not hasattr(param, 'text') and (param.type == 'python' or param.type == 'number'):
                 raise CreoleDictConsistencyError(_("All '{}' variables shall be set in order to calculate {}").format(param.type, 'valid_enum'))
             if param.type in ['string', 'number']:
@@ -894,8 +903,6 @@ class SpaceAnnotator(object):
                 raise CreoleDictConsistencyError(_('Function {} shall return a list').format(param.text))
             new_values = []
             for val in values:
-                if sys.version_info[0] < 3 and isinstance(val, str):
-                    val = val.decode('utf-8')
                 new_values.append(val)
             values = new_values
         else:
@@ -993,7 +1000,7 @@ class SpaceAnnotator(object):
                 if proposed_value_type:
                     if param.type != 'eole':
                         try:
-                            values = self.load_params_in_validenum(param, check.probe)
+                            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
@@ -1005,7 +1012,7 @@ class SpaceAnnotator(object):
                     if check.target in self.valid_enums:
                         raise CreoleDictConsistencyError(_('valid_enum already set for {}'
                                                            '').format(check.target))
-                    values = self.load_params_in_validenum(param, check.probe)
+                    values = self.load_params_in_validenum(param)
                     self.valid_enums[check.target] = {'type': param.type,
                                                       'values': values}
                     remove_indexes.append(idx)
@@ -1097,16 +1104,18 @@ class SpaceAnnotator(object):
         for idx in del_idx:
             space.constraints.fill.pop(idx)
 
-    def filter_target(self, space, namespace):  # pylint: disable=C0111
+    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(space.target):
+            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 space.source == target.name:
+                    if condition.source == target.name:
-                    raise CreoleDictConsistencyError(_('target name and source name must be different: {}').format(space.source))
+                        raise CreoleDictConsistencyError(_('target name and source name must be different: {}').format(condition.source))
                     target.name = self.paths.get_variable_path(target.name, namespace)
                 elif target.type == 'family':
                     try:
@@ -1116,18 +1125,12 @@ class SpaceAnnotator(object):
             del_idx = list(set(del_idx))
             del_idx.sort(reverse=True)
             for idx in del_idx:
-            space.target.pop(idx)
+                condition.target.pop(idx)
 
-    def filter_condition(self):  # pylint: disable=C0111
+    def filter_condition_servicelist(self):
-        if not hasattr(self.space, 'constraints') or not hasattr(self.space.constraints, 'condition'):
-            return
-        space = self.space.constraints.condition
-        remove_conditions = []
-        fallback_variables = []
-        fallback_lists = []
         # automatic generation of the service_access lists
         # and the service_restriction lists from the servicelist
-        for condition in space:
+        for condition in self.space.constraints.condition:
             if hasattr(condition, 'target'):
                 new_targets = []
                 for target in condition.target:
@@ -1143,20 +1146,15 @@ class SpaceAnnotator(object):
                         new_targets.append(new_target)
                 condition.target.extend(new_targets)
 
-        # remove condition with target
+    def check_condition_without_target(self):
-        if HIGH_COMPATIBILITY:
+        for condition in self.space.constraints.condition:
-            for idx, condition in enumerate(space):
             if not hasattr(condition, 'target'):
-                    remove_conditions.append(idx)
+                raise CreoleDictConsistencyError(_('target is mandatory in condition'))
 
-        for idx, condition in enumerate(space):
+    def check_condition_fallback_not_exists(self, fallback_variables, fallback_lists):
-            if idx in remove_conditions:
+        # a condition with a fallback **and** the source variable doesn't exist
-                continue
+        remove_conditions = []
-            if condition.name == 'hidden_if_in':
+        for idx, condition in enumerate(self.space.constraints.condition):
-                condition.name = 'disabled_if_in'
-            elif condition.name == 'hidden_if_not_in':
-                condition.name = 'disabled_if_not_in'
-            # a conditon with a fallback **and** the source variable doesn't exist
             if (hasattr(condition, 'fallback') and condition.fallback is True and
                     not self.paths.path_is_defined(condition.source)):
                 for target in condition.target:
@@ -1196,20 +1194,16 @@ class SpaceAnnotator(object):
                                     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)
 
-        for condition_idx, condition in enumerate(space):
+    def convert_xxxlist_to_variable(self, fallback_lists):  # pylint: disable=C0111
-            if condition_idx in remove_conditions:
-                continue
-            namespace = condition.namespace
-            self.filter_target(condition, namespace)
         # transform *list to variable or family
-        for condition_idx, condition in enumerate(space):
+        for condition_idx, condition in enumerate(self.space.constraints.condition):
-            if condition.name 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']:
             new_targets = []
             remove_targets = []
-                if not hasattr(condition, 'target'):
-                    continue
             for target_idx, target in enumerate(condition.target):
                 if target.type not in ['variable', 'family']:
                     listname = target.type
@@ -1239,21 +1233,31 @@ class SpaceAnnotator(object):
                 condition.target.pop(target_idx)
             condition.target.extend(new_targets)
 
-        force_remove_targets = {}
+    def check_condition(self):
-        for condition_idx, condition in enumerate(space):
+        # if condition.name == 'hidden_if_in':
-            if condition_idx in remove_conditions:
+        #     condition.name = 'disabled_if_in'
-                continue
+        # elif condition.name == 'hidden_if_not_in':
-            namespace = condition.namespace
+        #     condition.name = 'disabled_if_not_in'
-            src_variable = self.paths.get_variable_obj(condition.source)
+        for condition in self.space.constraints.condition:
-            condition.source = self.paths.get_variable_path(condition.source, namespace, allow_source=True)
+            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))
+
+    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 condition.name 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']:
+    def check_choice_option_condition(self, force_remove_targets):
-                valid_enum = None
         # remove condition for ChoiceOption that don't have param
+        remove_conditions = []
+        for condition_idx, condition in enumerate(self.space.constraints.condition):
+            namespace = condition.namespace
+            src_variable = self.paths.get_variable_obj(condition.source)
+            condition.source = self.paths.get_variable_path(condition.source, namespace, allow_source=True)
+            valid_enum = None
             if condition.source in self.valid_enums and \
                     self.valid_enums[condition.source]['type'] == 'string':
                 valid_enum = self.valid_enums[condition.source]['values']
@@ -1295,12 +1299,10 @@ class SpaceAnnotator(object):
         remove_conditions = list(set(remove_conditions))
         remove_conditions.sort(reverse=True)
         for idx in remove_conditions:
-            space.pop(idx)
+            self.space.constraints.condition.pop(idx)
-
-        for condition_idx, condition in enumerate(space):
-            if condition.name 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']:
 
+    def manage_variable_property(self, force_remove_targets, fallback_variables):
+        for condition in self.space.constraints.condition:
             remove_targets = []
             #parse each variable and family
             for target_idx, target in enumerate(condition.target):
@@ -1332,3 +1334,77 @@ class SpaceAnnotator(object):
             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):
+            if not condition.target:
+                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 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.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.remove_condition_with_empty_target()
+        for condition in self.space.constraints.condition:
+            if condition.name == 'disabled_if_in':
+                actions = ['disabled']
+                inverse = False
+            elif condition.name == 'disabled_if_not_in':
+                actions = ['disabled']
+                inverse = True
+            elif condition.name == 'frozen_if_in':
+                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':
+                actions = ['mandatory']
+                inverse = False
+            elif condition.name == 'mandatory_if_not_in':
+                actions = ['mandatory']
+                inverse = True
+            elif condition.name == 'auto_frozen_if_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.'):
+                        name = target.name.split('.')[-1]
+                    else:
+                        name = target.name
+                    if target.type == 'variable':
+                        variable = self.get_variable(name)
+                    else:
+                        variable = self.paths.get_family_obj(name)
+                    if not hasattr(variable, 'property'):
+                        variable.property = []
+                    for action in actions:
+                        prop = self.objectspace.property_()
+                        prop.type = 'calculation'
+                        prop.inverse = inverse
+                        prop.source = condition.source
+                        prop.expected = param
+                        prop.name = action
+                        variable.property.append(prop)
+        del self.space.constraints.condition

creole/config.py

@@ -3,79 +3,23 @@
 fichier de configuration pour créole
 
 """
-from os.path import join, isfile, isdir
+from os.path import join, isfile
 
 eoledir = '/usr/share/eole'
-LOCALKERNEL_FILE = join(eoledir, 'noyau/local')
-REBOOT_FILE = '/var/run/reboot-required'
 
-charset = 'UTF8'
-
-# chemin par defaut des templates, fichier config.eol, etc
-configeoldir = '/etc/eole/'
 eoleroot = join(eoledir, 'creole')
-vareole = '/var/lib/eole'
-
-bareos_restore_root = join(eoledir, 'bareos')
-bareos_restore = join(bareos_restore_root, 'restore')
-
-configeol = join(configeoldir, 'config.eol')
-
-# certificats
-cert_file = '/etc/ssl/certs/eole.crt'
-key_file = '/etc/ssl/certs/eole.key'
-# port du serveur creole_serv
-port_rpc = 4333
 
 # chemin du répertoire source des fichiers templates
 templatedir = '/var/lib/creole'
 
-dicos_dir = join(eoleroot, 'dicos')
-modif_dir = join(eoleroot, 'modif')
 distrib_dir = join(eoleroot, 'distrib')
 patch_dir = join(eoleroot, 'patch')
 
-# chemin pour les fichiers de données
-datadir = '/usr/share/creole'
-# chemin pour les modules de fonctions supplémentaires
-func_dir = join(datadir,'funcs')
-# repertoire du ou des dictionnaires xml creole
-eoledirs = [dicos_dir, join(dicos_dir, 'variante'), join(dicos_dir, 'local')]
-
-# extra
-eoleextradico = join(eoledir, 'creole/extra')
-eoleextraconfig = join(configeoldir, 'extra')
-forbiddenextra = ['containers', 'creole']
-
 # repertoire de la dtd
-dtddir = datadir
+dtddir = '/usr/share/creole'
 if isfile('data/creole.dtd'):
     dtdfilename = 'data/creole.dtd'
 elif isfile('../creole/data/creole.dtd'):
     dtdfilename = '../creole/data/creole.dtd'
 else:
     dtdfilename = join(dtddir, 'creole.dtd')
-
-# repertoire avec le fichier lock
-LOCK_PATH = '/var/lock/eole'
-LOCK_SYSTEM_PATH = join(LOCK_PATH, 'eole-system')
-
-# Nom du serveur maitre
-VIRTMASTER = 'root'
-VIRTROOT = '/var/lib/lxc'
-VIRTBASE = 'rootfs'
-
-container_instance_lockfile = '/etc/eole/.container_instance.lock'
-containers_default_network = '192.0.2'
-gen_conteneurs_needed = '/etc/eole/.gen_conteneurs'
-
-VIRTENABLED_LOCKFILE = '/etc/eole/.VirtEnabled.lock'
-VIRTDISABLED_LOCKFILE = '/etc/eole/.VirtDisabled.lock'
-INSTANCE_LOCKFILE = '/etc/eole/.instance'
-UPGRADE_LOCKFILE = '/etc/eole/.upgrade-auto'
-
-SSL_LAST_FILE = '/etc/eole/ssl/lastfile.txt'
-
-FLATTENED_CREOLE_DIR = join(vareole, 'config')
-if not isdir(FLATTENED_CREOLE_DIR):
-    FLATTENED_CREOLE_DIR = join('/tmp')

creole/error.py

@@ -3,33 +3,10 @@
 Erreurs Creole
 """
 
-class VirtError(Exception):
-    """incohérence concernant les conteneurs"""
-    pass
-
-#class ValueEoleError(Exception):
-#    """Cette valeur n'existe pas"""
-#    pass
-#
-class NoneError(Exception):
-    """Valeur vide"""
-    pass
-
-class OutOfRange(Exception):
-    pass
-
-class TypeEoleError(Exception):
-    """Erreur de type"""
-    pass
 
 class ConfigError(Exception):
     pass
 
-class NetworkConfigError(Exception):
-    """ Network configuration error
-    """
-    pass
-
 class FileNotFound(ConfigError):
     pass
 
@@ -41,37 +18,6 @@ class TemplateDisabled(TemplateError):
     """
     pass
 
-class DependencyError(ConfigError):
-    pass
-
-#class ConstraintError(ConfigError):
-#    pass
-#
-
-
-class LockError(Exception):
-    """ Add lock error
-    """
-    pass
-
-
-class UnlockError(Exception):
-    """ Remove lock error
-    """
-    pass
-
-
-class UserExit(Exception):
-    """ User exit(0) signal
-    """
-    pass
-
-
-class UserExitError(Exception):
-    """ User exit(1) signal
-    """
-    pass
-
 
 class CreoleOperationError(Exception):
     """Type error or value Error for Creole variable's type or values

creole/loader.py

@@ -15,7 +15,7 @@ from tiramisu import Config, MetaConfig, MixConfig
 from tiramisu.setting import groups
 from tiramisu.error import ConfigError
 from tiramisu.setting import owners
-from tiramisu import  Params, ParamOption, ParamValue, ParamContext
+from tiramisu import  Params, ParamOption, ParamValue, ParamContext, Calculation, calc_value
 
 from .config import dtdfilename
 from .i18n import _
@@ -49,8 +49,10 @@ def convert_tiramisu_value(value, obj):
     func = {IntOption: int, UnicodeOption: str, PortOption: str,
             DomainnameOption: str, EmailOption: str, URLOption: str,
             IPOption: str, NetmaskOption: str, NetworkOption: str,
-            BroadcastOption: str, FilenameOption: str
+            BroadcastOption: str, FilenameOption: str,
-            BoolOption: _convert_boolean}.get(obj, return)
+            BoolOption: _convert_boolean}.get(obj, None)
+    if func is None:
+        return value
     if isinstance(value, list):
         return [func(val) for val in value]
     else:
@@ -72,17 +74,18 @@ CONVERT_OPTION = {'number': dict(opttype=IntOption),
                   'netmask': dict(opttype=NetmaskOption),
                   'network': dict(opttype=NetworkOption),
                   'broadcast': dict(opttype=BroadcastOption),
-                  'netbios': dict(opttype=DomainnameOption, initkwargs={'type_': 'netbios', 'warnings_only': True}),
+                  'netbios': dict(opttype=DomainnameOption, initkwargs={'type': 'netbios', 'warnings_only': True}),
-                  'domain': dict(opttype=DomainnameOption, initkwargs={'type_': 'domainname', 'allow_ip': True, 'allow_without_dot': True}),
+                  'domain': dict(opttype=DomainnameOption, initkwargs={'type': 'domainname', 'allow_ip': True, 'allow_without_dot': True}),
-                  'domain_strict': dict(opttype=DomainnameOption, initkwargs={'type_': 'domainname', 'allow_ip': False}),
+                  'domain_strict': dict(opttype=DomainnameOption, initkwargs={'type': 'domainname', 'allow_ip': False}),
-                  'hostname': dict(opttype=DomainnameOption, initkwargs={'type_': 'hostname', 'allow_ip': True}),
+                  'hostname': dict(opttype=DomainnameOption, initkwargs={'type': 'hostname', 'allow_ip': True}),
-                  'hostname_strict': dict(opttype=DomainnameOption, initkwargs={'type_': 'hostname', 'allow_ip': False}),
+                  'hostname_strict': dict(opttype=DomainnameOption, initkwargs={'type': 'hostname', 'allow_ip': False}),
                   'web_address': dict(opttype=URLOption, initkwargs={'allow_ip': True, 'allow_without_dot': True}),
                   'port': dict(opttype=PortOption, initkwargs={'allow_private': True}),
                   'mac': dict(opttype=MACOption) # FIXME YO
                   }
 
 
+# FIXME help
 REMOVED_ATTRIB = ['path', 'type']
 
 
@@ -118,7 +121,7 @@ class PopulateTiramisuObjects(object):
 
     def make_tiramisu_objects(self, xmlroot, creolefunc_file, load_extra=True):
         elt = Elt({'name': 'baseoption'})
-        family = Family(elt, self.booleans)
+        family = Family(elt, self.booleans, self.storage)
         self.storage.add('.', family)
         self.eosfunc = imp.load_source('eosfunc', creolefunc_file)
 
@@ -153,16 +156,14 @@ class PopulateTiramisuObjects(object):
                 xmlelts = xmlelts_
             for xmlelt in xmlelts:
                 if xmlelt.tag == 'family':
-                    self._iter_family(xmlelt, family=family)
+                    self._iter_family(xmlelt, family)
-                elif xmlelt.tag == 'help':
-                    self._iter_help(xmlelt)
                 elif xmlelt.tag == 'constraints':
                     self._iter_constraints(xmlelt, load_extra)
                 else:
                     raise CreoleLoaderError(_('unknown tag {}').format(xmlelt.tag))
 
-    def _populate_variable(self, elt, subpath, is_slave, is_master):
+    def _populate_variable(self, elt, subpath, is_follower, is_leader):
-        variable = Variable(elt, self.booleans, self.storage, is_slave, is_master, self.eosfunc)
+        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:
@@ -175,7 +176,7 @@ class PopulateTiramisuObjects(object):
             force_icon = False
         else:
             force_icon = not subpath.startswith('containers') and not subpath.startswith('actions')
-        family = Family(elt, self.booleans, force_icon)
+        family = Family(elt, self.booleans, self.storage, force_icon)
         path = self._build_path(subpath, elt)
         self.storage.add(path, family)
         return family
@@ -191,8 +192,6 @@ class PopulateTiramisuObjects(object):
         for elt in xmlelt:
             if elt.tag == 'fill':
                 self._parse_fill(elt, load_extra)
-            elif elt.tag == 'condition':
-                self._parse_condition(elt, load_extra)
             elif elt.tag == 'check':
                 self._parse_check(elt, load_extra)
             else:
@@ -247,10 +246,7 @@ class PopulateTiramisuObjects(object):
             # only for valid_enum with checkval to True
             if len(elt) != 1:
                 raise CreoleLoaderError(_('valid_enum cannot have more than one param for {}').format(elt.attrib['target']))
-            if elt.attrib['probe'] == 'True':
+            if elt[0].attrib['type'] == 'eole':
-                proposed = elt[0].text
-                type_ = 'string'
-            elif elt[0].attrib['type'] == 'eole':
                 proposed = elt[0].text
                 type_ = 'eole'
             else:
@@ -350,105 +346,68 @@ class PopulateTiramisuObjects(object):
                 validator_params.setdefault(param.attrib.get('name', ''), []).append(text)
             self.storage.add_validator(elt.attrib['target'], validator, validator_params)
 
-    def _parse_condition(self, elt, load_extra):
+    def _iter_leader(self, leader, subpath):
-        if not self._check_extra(elt.attrib['source'], load_extra):
+        subpath = self._build_path(subpath, leader)
-            return
+        family = Family(leader, self.booleans, self.storage)
-        if elt.attrib['name'] == 'disabled_if_in':
+        family.set_leader()
-            actions = ['disabled']
-            inverse = False
-        elif elt.attrib['name'] == 'disabled_if_not_in':
-            actions = ['disabled']
-            inverse = True
-        elif elt.attrib['name'] == 'auto_frozen_if_in':
-            actions = ['frozen']
-            inverse = False
-        elif elt.attrib['name'] == 'frozen_if_in':
-            actions = ['frozen', 'hidden', 'force_default_on_freeze']
-            inverse = False
-        elif elt.attrib['name'] == 'frozen_if_not_in':
-            actions = ['frozen', 'hidden', 'force_default_on_freeze']
-            inverse = True
-        elif elt.attrib['name'] == 'mandatory_if_in':
-            actions = ['mandatory']
-            inverse = False
-        elif elt.attrib['name'] == 'mandatory_if_not_in':
-            actions = ['mandatory']
-            inverse = True
-        else:
-            raise CreoleLoaderError(_('unknown condition type {} for {}').format(elt.attrib['name'], elt.attrib['source']))
-        expected_values = []
-        options = []
-        for param in elt:
-            if param.tag == 'param':
-                expected_values.append(param.text)
-            elif param.tag == 'target':
-                if param.attrib['type'] in ['variable', 'family']:
-                    if not self._check_extra(param.text, load_extra):
-                        return
-                    option = self.storage.get(param.text)
-                    option_actions = actions
-                    if 'force_store_value' in option.attrib.get('properties', []) and \
-                            'force_default_on_freeze' in option_actions:
-                        option_actions.remove('force_default_on_freeze')
-                    options.append((param.text, option_actions))
-        source = self.storage.get(elt.attrib['source'])
-        for option, actions in options:
-            conditions = []
-            for action in actions:
-                for expected in expected_values:
-                    conditions.append({'option': source, 'expected': expected,
-                                       'action': action, 'inverse': inverse})
-            self.storage.add_requires(option, conditions)
-
-    def _iter_help(self, xmlelt):
-        for elt in xmlelt:
-            self.storage.add_help(elt.attrib['name'], elt.text)
-
-    def _iter_master(self, master, subpath):
-        subpath = self._build_path(subpath, master)
-        family = Family(master, self.booleans)
-        family.set_master()
         self.storage.add(subpath, family)
-        master_name = None
+        leader_name = None
-        for var in master:
+        for var in leader:
-            if master_name is None:
+            if var.tag == 'property':
-                master_name = var.attrib['name']
+                self._parse_properties(family, var)
-                self.groups[master_name] = []
+            elif var.tag == 'variable':
+                if leader_name is None:
+                    leader_name = var.attrib['name']
+                    self.groups[leader_name] = []
                 else:
-                self.groups[master_name].append(var.attrib['name'])
+                    self.groups[leader_name].append(var.attrib['name'])
-            self._iter_family(var, subpath=subpath, family=family)
+                self._iter_family(var, family, subpath=subpath)
+            else:
+                raise CreoleLoaderError(_('unknown tag {}').format(var.tag))
         return family
 
-    def _iter_family(self, child, subpath=None, family=None):
+    def _iter_family(self, child, family, subpath=None):
-        if child.tag not in ['family', 'variable', 'separators', 'master']:
+        if child.tag not in ['family', 'variable', 'separators', 'leader', 'property']:
             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 child.tag == 'master':
+            if len(child) != 0:
-            master = self._iter_master(child, subpath)
+                subpath = self._build_path(subpath, child)
-            family.add(master)
+                for c in child:
+                    self._iter_family(c, family, subpath=subpath)
+        if child.tag == 'leader':
+            leader = self._iter_leader(child, subpath)
+            family.add(leader)
         elif child.tag == 'separators':
             self._parse_separators(child)
         elif child.tag == 'variable':
             if family is None:
                 raise CreoleLoaderError(_('variable without family'))
 
-            is_slave = False
+            is_follower = False
-            is_master = False
+            is_leader = False
-            if family.is_master:
+            if family.is_leader:
                 if child.attrib['name'] != family.attrib['name']:
-                    is_slave = True
+                    is_follower = True
                 else:
-                    is_master = True
+                    is_leader = True
-            variable = self._populate_variable(child, subpath, is_slave, is_master)
+            variable = self._populate_variable(child, subpath, is_follower, is_leader)
             family.add(variable)
-        elif len(child) != 0:
+        elif child.tag == 'property':
-            subpath = self._build_path(subpath, child)
+            self._parse_properties(family, child)
-            for c in child:
+
-                self._iter_family(c, subpath, family)
+    def _parse_properties(self, family, child):
+        if child.get('type') == 'calculation':
+            kwargs = {'condition': child.attrib['source'],
+                      'expected':  ParamValue(child.attrib.get('expected'))}
+            if child.attrib['inverse'] == 'True':
+                kwargs['reverse_condition'] = ParamValue(True)
+            family.attrib['properties'].append((ParamValue(child.text), kwargs))
+        else:
+            family.attrib['properties'].append(child.text)
 
     def _parse_separators(self, separators):
         for separator in separators:
@@ -487,11 +446,13 @@ class PopulateTiramisuObjects(object):
         config.property.setdefault(rw_append, 'read_write', 'append')
 
         config.property.read_only()
-        config.permissive.set(frozenset('basic', 'normal', 'expert', 'hidden'))
+        config.permissive.add('basic')
+        config.permissive.add('normal')
+        config.permissive.add('expert')
         return config
 
 
-class ElementStorage(object):
+class ElementStorage:
     def __init__(self):
         self.paths = {}
 
@@ -500,10 +461,6 @@ class ElementStorage(object):
             raise CreoleLoaderError(_('path already loaded {}').format(path))
         self.paths[path] = elt
 
-    def add_help(self, path, text):
-        elt = self.get(path)
-        self.paths[path].add_information('help', text)
-
     def add_callback(self, path, callback, callback_params):
         elt = self.get(path)
         elt.add_callback(callback, callback_params)
@@ -530,8 +487,24 @@ class ElementStorage(object):
         return self.paths[path]
 
 
-class Variable(object):
+class Common:
-    def __init__(self, elt, booleans, storage, is_slave, is_master, eosfunc):
+    def build_properties(self):
+        for index, prop in enumerate(self.attrib['properties']):
+            if isinstance(prop, tuple):
+                action, kwargs = prop
+                kwargs['condition'] = ParamOption(self.storage.get(kwargs['condition']).get(), todict=True)
+                prop = Calculation(calc_value,
+                                   Params(action,
+                                          kwargs=kwargs))
+                self.attrib['properties'][index] = prop
+        if self.attrib['properties']:
+            self.attrib['properties'] = tuple(self.attrib['properties'])
+        else:
+            del self.attrib['properties']
+
+
+class Variable(Common):
+    def __init__(self, elt, booleans, storage, is_follower, is_leader, eosfunc):
         self.option = None
         self.informations = {}
         self.attrib = {}
@@ -541,6 +514,7 @@ class Variable(object):
         self.consistencies = []
         self.attrib['properties'] = []
         self.eosfunc = eosfunc
+        self.storage = storage
         for key, value in elt.attrib.items():
             if key in REMOVED_ATTRIB:
                 continue
@@ -554,6 +528,9 @@ class Variable(object):
                     value = False
                 else:
                     raise CreoleLoaderError(_('unknown value {} for {}').format(value, key))
+            if key == 'help':
+                self.add_information(key, value)
+            else:
                 self.attrib[key] = value
         convert_option = CONVERT_OPTION[elt.attrib['type']]
         self.object_type = convert_option['opttype']
@@ -572,19 +549,26 @@ class Variable(object):
                         self.attrib['values'].append(value)
                 self.attrib['values'] = tuple(self.attrib['values'])
         for child in elt:
+            if child.tag == 'property':
+                if child.get('type') == 'calculation':
+                    kwargs = {'condition': child.attrib['source'],
+                              'expected':  ParamValue(child.attrib.get('expected'))}
+                    if child.attrib['inverse'] == 'True':
+                        kwargs['reverse_condition'] = ParamValue(True)
+                    self.attrib['properties'].append((ParamValue(child.text), kwargs))
+                else:
+                    self.attrib['properties'].append(child.text)
+            elif child.tag == 'value':
                 if "type" in child.attrib:
                     type_ = CONVERT_OPTION[child.attrib['type']]['opttype']
                 else:
                     type_ = self.object_type
-            if child.tag == 'property':
+                if self.attrib['multi'] and not is_follower:
-                self.attrib['properties'].append(child.text)
-            elif child.tag == 'value':
-                if self.attrib['multi'] and not is_slave:
                     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_master:
+                    if 'default_multi' not in self.attrib and not is_leader:
                         self.attrib['default_multi'] = value
                 else:
                     if 'default' in self.attrib:
@@ -593,13 +577,12 @@ class Variable(object):
                     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_slave:
+                    if is_follower:
                         self.attrib['default_multi'] = value
                     else:
                         self.attrib['default'] = value
         if 'initkwargs' in convert_option:
             self.attrib.update(convert_option['initkwargs'])
-        self.attrib['properties'] = tuple(self.attrib['properties'])
         if elt.attrib['type'] == 'symlink':
             del self.attrib['properties']
             del self.attrib['multi']
@@ -648,17 +631,19 @@ class Variable(object):
         if self.option is None:
             if self.object_type is SymLinkOption:
                 self.attrib['opt'] = self.attrib['opt'].get()
-            for callback, callback_params in self.callbacks:
+            else:
-                self.attrib['callback'] = callback
+                self.build_properties()
-                self.attrib['callback_params'] = self.build_params(callback_params)
+            #for callback, callback_params in self.callbacks:
-            for require in self.requires:
+            #    self.attrib['callback'] = callback
-                if isinstance(require['option'], Variable):
+            #    self.attrib['callback_params'] = self.build_params(callback_params)
-                    require['option'] = require['option'].get()
+            #for require in self.requires:
-            if self.requires != []:
+            #    if isinstance(require['option'], Variable):
-                self.attrib['requires'] = self.requires
+            #        require['option'] = require['option'].get()
-            if self.validator:
+            #if self.requires != []:
-                self.attrib['validator'] = self.validator[0]
+            #    self.attrib['requires'] = self.requires
-                self.attrib['validator_params'] = self.build_params(self.validator[1])
+            #if self.validator:
+            #    self.attrib['validator'] = self.validator[0]
+            #    self.attrib['validator_params'] = self.build_params(self.validator[1])
             try:
                 option = self.object_type(**self.attrib)
             except Exception as err:
@@ -668,35 +653,36 @@ class Variable(object):
                 raise CreoleLoaderError(_('cannot create option {}: {}').format(name, err))
             for key, value in self.informations.items():
                 option.impl_set_information(key, value)
-            for consistency in self.consistencies:
+            #for consistency in self.consistencies:
-                options = []
+            #    options = []
-                for variable in consistency[1]:
+            #    for variable in consistency[1]:
-                    options.append(variable.get())
+            #        options.append(variable.get())
-                try:
+            #    try:
-                    kwargs = {}
+            #        kwargs = {}
-                    if consistency[2] == 'True':
+            #        if consistency[2] == 'True':
-                        kwargs['warnings_only'] = True
+            #            kwargs['warnings_only'] = True
-                    if consistency[3] == 'False':
+            #        if consistency[3] == 'False':
-                        kwargs['transitive'] = False
+            #            kwargs['transitive'] = False
-                    option.impl_add_consistency(consistency[0], *options, **kwargs)
+            #        option.impl_add_consistency(consistency[0], *options, **kwargs)
-                except ConfigError as err:
+            #    except ConfigError as err:
-                    name = self.attrib['name']
+            #        name = self.attrib['name']
-                    raise CreoleLoaderError(_('cannot load consistency for {}: {}').format(name, err))
+            #        raise CreoleLoaderError(_('cannot load consistency for {}: {}').format(name, err))
             self.option = option
         return self.option
 
 
-class Family(object):
+class Family(Common):
-    def __init__(self, elt, booleans, force_icon=False):
+    def __init__(self, elt, booleans, storage, force_icon=False):
         self.requires = []
         self.option = None
         self.attrib = {}
-        self.is_master = False
+        self.is_leader = False
         if force_icon:
             self.informations = {'icon': None}
         else:
             self.informations = {}
         self.children = []
+        self.storage = storage
         self.attrib['properties'] = []
         for key, value in elt.attrib.items():
             if key in REMOVED_ATTRIB:
@@ -716,11 +702,12 @@ class Family(object):
                     self.attrib['properties'].append(key)
             elif key == 'mode':
                 self.attrib['properties'].append(value)
+            elif key == 'help':
+                self.add_information(key, value)
             else:
                 self.attrib[key] = value
         if 'doc' not in self.attrib:
             self.attrib['doc'] = u''
-        self.attrib['properties'] = tuple(self.attrib['properties'])
 
     def add(self, child):
         self.children.append(child)
@@ -730,8 +717,8 @@ class Family(object):
             raise CreoleLoaderError(_('key already exists in information {}').format(key))
         self.informations[key] = value
 
-    def set_master(self):
+    def set_leader(self):
-        self.is_master = True
+        self.is_leader = True
 
     def add_requires(self, requires):
         self.requires.extend(requires)
@@ -746,8 +733,9 @@ class Family(object):
                     require['option'] = require['option'].get()
             if self.requires != []:
                 self.attrib['requires'] = self.requires
+            self.build_properties()
             try:
-                if not self.is_master:
+                if not self.is_leader:
                     option = OptionDescription(**self.attrib)
                 else:
                     option = Leadership(**self.attrib)
@@ -757,7 +745,7 @@ class Family(object):
             for key, value in self.informations.items():
                 option.impl_set_information(key, value)
             self.option = option
-            #if self.is_master:
+            #if self.is_leader:
-            #    self.option.impl_set_group_type(groups.master)
+            #    self.option.impl_set_group_type(groups.leader)
 
         return self.option

creole/objspace.py

@@ -25,7 +25,6 @@ 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
-import sys
 from json import dump
 
 
@@ -60,6 +59,7 @@ class CreoleObjSpace(object):
     """DOM XML reflexion free internal representation of a Creole Dictionary
     """
     choice = type('Choice', (RootCreoleObject,), OrderedDict())
+    property_ = type('Property', (RootCreoleObject,), OrderedDict())
     # Creole ObjectSpace's Leadership variable class type
     Leadership = type('Leadership', (RootCreoleObject,), OrderedDict())
     """
@@ -92,7 +92,7 @@ class CreoleObjSpace(object):
         self.forced_text_elts = set()
         # ['disknod', 'follower', 'target', 'service', 'package', 'ip', 'value', 'tcpwrapper',
         #  'interface', 'input', 'port']
-        self.forced_text_elts_as_name = set(['choice'])
+        self.forced_text_elts_as_name = set(['choice', 'property'])
         self.forced_choice_option = {}
         self.paths = Path()
         self.list_conditions = {}
@@ -541,19 +541,15 @@ class CreoleObjSpace(object):
                 subspace = getattr(space, subname)
                 self._sub_xml_export(subname, child_node, name, subspace)
         else:
-            if name in PROPERTIES and node.tag == 'variable':
+            # FIXME plutot dans annotator ...
+            if name in PROPERTIES and node.tag in ['variable', 'family', 'leader']:
                 if space is True:
                     for prop in CONVERT_PROPERTIES.get(name, [name]):
-                        if sys.version_info[0] < 3:
-                            SubElement(node, 'property').text = unicode(prop)
-                        else:
                         SubElement(node, 'property').text = prop
 
             elif name not in ERASED_ATTRIBUTES:
                 if name == 'name' and node_name in self.forced_text_elts_as_name:
-                    if sys.version_info[0] < 3 and isinstance(space, unicode):
+                    if isinstance(space, str):
-                        node.text = space
-                    elif isinstance(space, str):
                         node.text = space
                     else:
                         node.text = str(space)
@@ -563,16 +559,13 @@ 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 == 'variable' and name == 'mode':
+                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:
-                        if sys.version_info[0] < 3:
-                            node.attrib[name] = unicode(space)
-                        else:
                         node.attrib[name] = str(space)
 
     def _xml_export(self, node, space, node_name='creole'):

creole/template.py

@@ -31,7 +31,7 @@ Parser.encodingDirectiveRE = FakeEncoding()
 from Cheetah.Template import Template as ChtTemplate
 from Cheetah.NameMapper import NotFound as CheetahNotFound
 
-import config as cfg
+from config import patch_dir, templatedir, distrib_dir
 
 from .client import CreoleClient, CreoleClientError
 from .error import FileNotFound, TemplateError, TemplateDisabled
@@ -290,13 +290,13 @@ class CreoleTemplateEngine(object):
     def patch_template(self, filevar, force_no_active=False):
         """Apply patch to a template
         """
-        var_dir = os.path.join(cfg.patch_dir,'variante')
+        var_dir = os.path.join(patch_dir,'variante')
-        patch_cmd = ['patch', '-d', cfg.templatedir, '-N', '-p1']
+        patch_cmd = ['patch', '-d', templatedir, '-N', '-p1']
         patch_no_debug = ['-s', '-r', '-', '--backup-if-mismatch']
 
         tmpl_filename = os.path.split(filevar[u'source'])[1]
         # patches variante + locaux
-        for directory in [var_dir, cfg.patch_dir]:
+        for directory in [var_dir, patch_dir]:
             patch_file = os.path.join(directory, '{0}.patch'.format(tmpl_filename))
             if os.access(patch_file, os.F_OK):
                 msg = _(u"Patching template '{0}' with '{1}'")
@@ -359,13 +359,13 @@ class CreoleTemplateEngine(object):
         """
         self._check_filevar(filevar, force_no_active)
         tmpl_source_name = os.path.split(filevar[u'source'])[1]
-        tmpl_source_file = os.path.join(cfg.distrib_dir, tmpl_source_name)
+        tmpl_source_file = os.path.join(distrib_dir, tmpl_source_name)
         if not os.path.isfile(tmpl_source_file):
             msg = _(u"Template {0} unexistent").format(tmpl_source_file)
             raise FileNotFound(msg)
         else:
-            log.info(_(u"Copy template: '{0}' -> '{1}'").format(tmpl_source_file, cfg.templatedir))
+            log.info(_(u"Copy template: '{0}' -> '{1}'").format(tmpl_source_file, templatedir))
-            shutil.copy(tmpl_source_file, cfg.templatedir)
+            shutil.copy(tmpl_source_file, templatedir)
 
     def prepare_template(self, filevar, force_no_active=False):
         """Prepare template source file
@@ -578,8 +578,8 @@ class CreoleTemplateEngine(object):
                 for group_name in self.client.get_groups():
                     containers_ctx.append(self.client.get_group_infos(group_name))
         if filenames is None:
-            all_files = set(listdir(cfg.distrib_dir))
+            all_files = set(listdir(distrib_dir))
-            prev_files = set(listdir(cfg.templatedir))
+            prev_files = set(listdir(templatedir))
             all_declared_files = set()
             for ctx in containers_ctx:
                 for fdict in ctx[u'files']:
@@ -588,12 +588,12 @@ class CreoleTemplateEngine(object):
             toremove_files = prev_files - all_files
             # delete old templates (#6600)
             for fname in toremove_files:
-                rm_file = join(cfg.templatedir, fname)
+                rm_file = join(templatedir, fname)
                 log.debug(_(u"Removing file '{0}'").format(rm_file))
                 unlink(rm_file)
             # copy template not referenced in a dictionary (#6303)
             for fname in undeclared_files:
-                fobj = {'source': join(cfg.templatedir, fname), 'name': ''}
+                fobj = {'source': join(templatedir, fname), 'name': ''}
                 self.prepare_template(fobj, True)
 
         for ctx in containers_ctx:

creole/utils.py

@@ -1,182 +1,15 @@
-# -*- coding: UTF-8 -*-
 """
 utilitaires créole
 """
+import unicodedata
 
-import sys
-from .error import NoneError, OutOfRange
-from .config import charset
-try:
-    from pyeole.ansiprint import *
-except:
-    pass
-import time, hashlib, random, unicodedata
 
 # définition des classes d'adresse IP existantes
-classes = {
-    u'128.0.0.0' : u'1'
-    , u'192.0.0.0' : u'2'
-    , u'224.0.0.0' : u'3'
-    , u'240.0.0.0' : u'4'
-    , u'248.0.0.0' : u'5'
-    , u'252.0.0.0' : u'6'
-    , u'254.0.0.0' : u'7'
-    , u'255.0.0.0' : u'8'
-    , u'255.128.0.0' : u'9'
-    , u'255.192.0.0' : u'10'
-    , u'255.224.0.0' : u'11'
-    , u'255.240.0.0' : u'12'
-    , u'255.248.0.0' : u'13'
-    , u'255.252.0.0' : u'14'
-    , u'255.254.0.0' : u'15'
-    , u'255.255.0.0' : u'16'
-    , u'255.255.128.0' : u'17'
-    , u'255.255.192.0' : u'18'
-    , u'255.255.224.0' : u'19'
-    , u'255.255.240.0' : u'20'
-    , u'255.255.248.0' : u'21'
-    , u'255.255.252.0' : u'22'
-    , u'255.255.254.0' : u'23'
-    , u'255.255.255.0' : u'24'
-    , u'255.255.255.128' : u'25'
-    , u'255.255.255.192' : u'26'
-    , u'255.255.255.224' : u'27'
-    , u'255.255.255.240' : u'28'
-    , u'255.255.255.248' : u'29'
-    , u'255.255.255.252' : u'30'
-    , u'255.255.255.254' : u'31'
-    , u'255.255.255.255' : u'32'
-}
-
-def string_to_bool(string):
-    """
-    Transforme les chaines 'True' ou 'False' en valeurs booléennes
-    """
-    if string == "":
-        raise ValueError('empty string')
-    result = eval(string)
-    if result not in [True, False]:
-        raise TypeError("string must be like 'True' or 'False'")
-    else: return result
-
-
-def get_text_node(node):
-    """
-    @param node: node minidom contenant du texte
-    Utilitaire minidom permettant de récupérer le texte d'un node texte
-    """
-    texte = ""
-    nodelist = node.childNodes
-    for textnode in nodelist:
-        if textnode.nodeType == textnode.TEXT_NODE:
-            texte = texte + textnode.data
-    return texte
-
-
-# utilitaires pour la
-# ligne de commande
-
-def raw(text):
-    """
-    Question en ligne de commande : permet de repérer si l'utilisateur a renvoyé quelque chose
-
-    @param text: le libellé de message
-    @return: la variable demandée
-    """
-    var = raw_input(text + " : ")
-    if var:
-        return var
-    else:
-        raise NoneError
-
-
-def stringify(string):
-    """
-    Encodage des chaînes avec le charset local
-    """
-    try:
-        return string.encode(charset)
-    except:
-        return string
-
-def encode_list(_list):
-    """ encode une liste en utf-8 si les éléments sont de type dico ou str ou liste, unicode"""
-    encoded_list = []
-    for element in _list:
-        if type(element) == str:
-            encoded_list.append(encode_str(element))
-        elif type(element) == dict:
-            encoded_list.append(encode_dico(element))
-        elif type(element) == list:
-            encoded_list.append(encode_list(element))
-        elif type(element) == unicode:
-            encoded_list.append(encode_str(element))
-        else:
-            encoded_list.append(element)
-    return encoded_list
-
-def encode_str(string):
-    """ encode une string ou un unicode en utf8 """
-    try:
-        string = string.encode(charset)
-    except:
-        pass
-    return string
-
-def encode_dico(dico):
-    """ encode un dico en utf8 dans le cas ou les valeurs soient de type dico, liste, str, unicode """
-    for key in dico.keys():
-        if type(dico[key]) == str:
-            dico[key] = encode_str(dico[key])
-        elif type(dico[key]) == unicode:
-            dico[key] = encode_str(dico[key])
-        elif type(dico[key]) == dict:
-            dico[key] = encode_dico(dico[key])
-        elif type(dico[key]) == list:
-            dico[key] = encode_list(dico[key])
-    return dico
-
-
-def select_list(selection):
-    """
-    Utilitaire de construction d'une sélection en ligne de commande
-    @param selection : liste
-    @return :  l'identifiant sélectionné (entier)
-    """
-    # affichage de la liste (ordonnée)
-    for i in selection:
-        print(selection.index(i) , ':', stringify(i))
-        # print selection.index(i) , ':', i[0]
-
-    # recuperation du numero
-    try:
-        number = int(raw(stringify(_("Choose a number in the list"))))
-    except:
-        raise OutOfRange
-    if number not in range(len(selection)):
-        raise OutOfRange
-    return number
-
-def gen_random(length=None):
-    """
-        length: longueur de la chaine aléatoire attendu
-    """
-    try:
-        random_id = str(time.time()).split('.')[0]
-        random_str = hashlib.sha224('{}/{}'.format(random_id, str(random.randrange(2**100))).encode('utf-8')).hexdigest()
-        return random_str[:length]
-    except:
-        import traceback
-        traceback.print_exc()
-
 def normalize_family(family_name, check_name=True):
     """
     il ne faut pas d'espace, d'accent, de majuscule, de tiré, ...
     dans le nom des familles
     """
-    if sys.version_info[0] < 3:
-        f = unicode(family_name)
-    else:
     f = family_name
     f = f.replace('-', '_')
     #f = f.replace(u'é', 'e')
@@ -185,13 +18,9 @@ def normalize_family(family_name, check_name=True):
     f = u"".join([c for c in nfkd_form if not unicodedata.combining(c)])
     f = f.replace(' ', '_')
     f = f.lower()
-    try:
+    if f[0].isnumeric():
-        int(f[0])
-    except ValueError:
-        pass
-    else:
         raise ValueError(u'Le nom de la famille ne doit pas commencer par un chiffre : {0}'.format(f))
-    if check_name and f.lower() in ['containers']:
+    if check_name and f == 'containers':
         raise ValueError(u'nom de la famille interdit {0}'.format(f))
     return f
 

creole/xmlreflector.py

@@ -1,17 +1,12 @@
 # coding: utf-8
 from os.path import join, isfile, basename, isdir
 from os import listdir
-from base64 import decodestring
+#from io import BytesIO
-from io import BytesIO
-from collections import OrderedDict
-import sys
 
-from lxml.etree import DTD, parse, tostring, XMLParser # pylint: disable=E0611
+from lxml.etree import DTD, parse, tostring  # , XMLParser
 
 from .i18n import _
-from .utils import normalize_family
 from .error import CreoleDictConsistencyError
-from .config import VIRTBASE, VIRTROOT, VIRTMASTER, templatedir
 
 HIGH_COMPATIBILITY = True
 
@@ -35,19 +30,16 @@ class XMLReflector(object):
         with open(dtdfilename, 'r') as dtdfd:
             self.dtd = DTD(dtdfd)
 
-    def parse_xmlfile(self, xmlfile, from_zephir=None, zephir2=False):
+    def parse_xmlfile(self, xmlfile):
         """Parses and validates some Creole XML against the Creole DTD
 
         :returns: the root element tree object
         """
-        if from_zephir:
+        # FIXME zephir2
-            if zephir2:
+        # document = parse(BytesIO(xmlfile), XMLParser(remove_blank_text=True))
-                document = parse(BytesIO(xmlfile), XMLParser(remove_blank_text=True))
-            else:
-                document = parse(BytesIO(decodestring(xmlfile)), XMLParser(remove_blank_text=True))
-        else:
         document = parse(xmlfile)
-        assert self.dtd.validate(document), _("not a valid xml file: {}").format(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):
@@ -101,7 +93,4 @@ class XMLReflector(object):
         """Write a bunch of XML on the disk
         """
         with open(xmlfilename, 'w') as xmlfh:
-            if sys.version_info[0] < 3:
-                xmlfh.write(tostring(xml, pretty_print=True, encoding="UTF-8", xml_declaration=True))
-            else:
             xmlfh.write(tostring(xml, pretty_print=True, encoding="UTF-8", xml_declaration=True).decode('utf8'))

data/creole.dtd

@@ -200,7 +200,6 @@
 <!ATTLIST check name CDATA #REQUIRED>
 <!ATTLIST check target CDATA #REQUIRED>
 <!ATTLIST check level (error|warning) "error">
-<!ATTLIST check probe (True|False) "False">
 
 <!ELEMENT auto ((param)*)>
 <!ATTLIST auto name CDATA #REQUIRED>

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

@@ -1,6 +1,8 @@
 <?xml version='1.0' encoding='UTF-8'?>
 <creole>
   <family name="containers">
-    <family name="container0" doc="tata" hidden="False" mode="basic"/>
+    <family name="container0" doc="tata">
+      <property>basic</property>
+    </family>
   </family>
 </creole>

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

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

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

@@ -1,13 +1,9 @@
 <?xml version='1.0' encoding='UTF-8'?>
 <creole>
-  <constraints>
+  <constraints/>
-    <condition name="auto_frozen_if_in" source="creole.general.module_instancie">
-      <param hidden="True" type="string">oui</param>
-      <target type="variable">creole.general.mode_conteneur_actif</target>
-    </condition>
-  </constraints>
   <family doc="" name="creole">
-    <family hidden="False" mode="basic" doc="général" name="general">
+    <family doc="général" name="general">
+      <property>basic</property>
       <variable doc="No change" multi="False" name="mode_conteneur_actif" type="choice">
         <property>force_store_value</property>
         <property>auto_freeze</property>
@@ -15,6 +11,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>
         <value type="string">non</value>
       </variable>
       <variable doc="No change" multi="False" name="module_instancie" type="choice">

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

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

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

@@ -1,13 +1,9 @@
 <?xml version='1.0' encoding='UTF-8'?>
 <creole>
-  <constraints>
+  <constraints/>
-    <condition name="auto_frozen_if_in" source="creole.general.module_instancie">
-      <param hidden="True" type="string">oui</param>
-      <target type="variable">creole.general.mode_conteneur_actif</target>
-    </condition>
-  </constraints>
   <family doc="" name="creole">
-    <family hidden="False" mode="normal" doc="général" name="general">
+    <family doc="général" name="general">
+      <property>normal</property>
       <variable doc="No change" multi="False" name="mode_conteneur_actif" type="choice">
         <property>force_store_value</property>
         <property>auto_freeze</property>
@@ -15,6 +11,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>
         <value type="string">non</value>
       </variable>
       <variable doc="No change" multi="False" name="module_instancie" type="choice">

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

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

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

@@ -2,7 +2,8 @@
 <creole>
   <constraints/>
   <family doc="" name="creole">
-    <family hidden="False" mode="basic" doc="général" name="general">
+    <family doc="général" name="general">
+      <property>basic</property>
       <variable doc="No change" multi="False" name="mode_conteneur_actif" type="choice">
         <property>force_store_value</property>
         <choice type="string">oui</choice>

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

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

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

@@ -2,7 +2,8 @@
 <creole>
   <constraints/>
   <family doc="" name="creole">
-    <family hidden="False" mode="expert" doc="général" name="general">
+    <family doc="général" name="general">
+      <property>expert</property>
       <variable doc="No change" multi="False" name="mode_conteneur_actif" type="choice">
         <property>force_store_value</property>
         <choice type="string">oui</choice>

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

@@ -2,7 +2,8 @@
 <creole>
   <constraints/>
   <family doc="" name="creole">
-    <family hidden="False" mode="normal" doc="général" name="general">
+    <family doc="général" 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>

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

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

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

@@ -2,7 +2,8 @@
 <creole>
   <constraints/>
   <family doc="" name="creole">
-    <family hidden="False" mode="normal" doc="général" name="general">
+    <family doc="général" 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>

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

@@ -2,7 +2,8 @@
 <creole>
   <constraints/>
   <family doc="" name="creole">
-    <family hidden="False" mode="normal" doc="général" name="general">
+    <family doc="général" 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>

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

@@ -2,7 +2,8 @@
 <creole>
   <constraints/>
   <family doc="" name="creole">
-    <family hidden="False" mode="normal" doc="général" name="general">
+    <family doc="général" 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>

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

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

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

@@ -6,7 +6,8 @@
     </fill>
   </constraints>
   <family doc="" name="creole">
-    <family hidden="False" mode="normal" doc="general" name="general">
+    <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>

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

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

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

@@ -4,7 +4,8 @@
     <fill name="calc_val" target="creole.general.mode_conteneur_actif"/>
   </constraints>
   <family doc="" name="creole">
-    <family hidden="False" mode="normal" doc="general" name="general">
+    <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>

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

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

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

@@ -1,16 +1,13 @@
 <?xml version='1.0' encoding='UTF-8'?>
 <creole>
   <constraints>
-    <condition name="auto_frozen_if_in" source="creole.general.module_instancie">
-      <param hidden="True" type="string">oui</param>
-      <target type="variable">creole.general.mode_conteneur_actif</target>
-    </condition>
     <fill name="calc_val" target="creole.general.mode_conteneur_actif">
       <param hidden="True" type="eole">creole.general.mode_conteneur_actif1</param>
     </fill>
   </constraints>
   <family doc="" name="creole">
-    <family hidden="False" mode="basic" doc="general" name="general">
+    <family doc="general" name="general">
+      <property>basic</property>
       <variable doc="No change" multi="False" name="mode_conteneur_actif" type="choice">
         <property>force_store_value</property>
         <property>auto_freeze</property>
@@ -18,6 +15,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>
       </variable>
       <variable doc="No change" multi="False" name="mode_conteneur_actif1" type="choice">
         <choice type="string">oui</choice>

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

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

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

@@ -6,7 +6,8 @@
     </fill>
   </constraints>
   <family doc="" name="creole">
-    <family hidden="False" mode="basic" doc="general" name="general">
+    <family doc="general" name="general">
+      <property>basic</property>
       <variable doc="No change" multi="False" name="mode_conteneur_actif" type="choice">
         <property>force_store_value</property>
         <choice type="string">oui</choice>

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

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

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

@@ -6,7 +6,8 @@
     </fill>
   </constraints>
   <family doc="" name="creole">
-    <family hidden="False" mode="normal" doc="general" name="general">
+    <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>

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

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

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

@@ -6,7 +6,8 @@
     </fill>
   </constraints>
   <family doc="" name="creole">
-    <family hidden="False" mode="normal" doc="Général" name="general">
+    <family doc="Général" 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>

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

@@ -0,0 +1 @@
+{"creole.general.mode_conteneur_actif1": null}

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

@@ -7,7 +7,8 @@
     </fill>
   </constraints>
   <family doc="" name="creole">
-    <family hidden="False" mode="normal" doc="general" name="general">
+    <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>

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

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

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

@@ -6,7 +6,8 @@
     </fill>
   </constraints>
   <family doc="" name="creole">
-    <family hidden="False" mode="normal" doc="general" name="general">
+    <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>

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

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

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

@@ -6,7 +6,8 @@
     </fill>
   </constraints>
   <family doc="" name="creole">
-    <family hidden="False" mode="normal" doc="general" name="general">
+    <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>

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

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

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

@@ -6,7 +6,8 @@
     </fill>
   </constraints>
   <family doc="" name="creole">
-    <family hidden="False" mode="normal" doc="general" name="general">
+    <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>

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

@@ -2,7 +2,8 @@
 <creole>
   <constraints/>
   <family doc="" name="creole">
-    <family hidden="False" mode="normal" doc="general" name="general">
+    <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>

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

@@ -2,7 +2,8 @@
 <creole>
   <constraints/>
   <family doc="" name="creole">
-    <family hidden="False" mode="normal" doc="general" name="general">
+    <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>

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

@@ -6,7 +6,8 @@
     </fill>
   </constraints>
   <family doc="" name="creole">
-    <family hidden="False" mode="basic" doc="général" name="general">
+    <family doc="général" name="general">
+      <property>basic</property>
       <variable doc="No change" multi="False" name="mode_conteneur_actif" type="choice">
         <choice type="string">oui</choice>
         <choice type="string">non</choice>

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

@@ -0,0 +1 @@
+{"creole.general.autosavevar": null}

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

@@ -1,16 +1,13 @@
 <?xml version='1.0' encoding='UTF-8'?>
 <creole>
   <constraints>
-    <condition name="frozen_if_in" source="creole.general.mode_conteneur_actif">
-      <param hidden="True" type="string">oui</param>
-      <target type="variable">creole.general.autosavevar</target>
-    </condition>
     <fill name="calc_val" target="creole.general.autosavevar">
       <param hidden="True" type="string">oui</param>
     </fill>
   </constraints>
   <family doc="" name="creole">
-    <family hidden="False" mode="basic" doc="général" name="general">
+    <family doc="général" name="general">
+      <property>basic</property>
       <variable doc="No change" multi="False" name="mode_conteneur_actif" type="choice">
         <choice type="string">oui</choice>
         <choice type="string">non</choice>
@@ -24,6 +21,9 @@
       <variable doc="autosave variable" multi="False" name="autosavevar" type="string">
         <property>force_store_value</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>
       </variable>
     </family>
     <separators/>

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

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

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

@@ -1,13 +1,14 @@
 <?xml version='1.0' encoding='UTF-8'?>
 <creole>
   <constraints>
-    <check name="valid_entier" probe="False" target="creole.general.int" transitive="True" warnings_only="False">
+    <check name="valid_entier" target="creole.general.int" transitive="True" warnings_only="False">
       <param name="mini" type="string">0</param>
       <param name="maxi" type="string">100</param>
     </check>
   </constraints>
   <family doc="" name="creole">
-    <family hidden="False" mode="normal" doc="general" name="general">
+    <family doc="general" name="general">
+      <property>normal</property>
       <variable doc="No change" multi="False" name="mode_conteneur_actif" type="string">
         <property>mandatory</property>
         <property>normal</property>

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

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

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

@@ -1,13 +1,14 @@
 <?xml version='1.0' encoding='UTF-8'?>
 <creole>
   <constraints>
-    <check name="valid_entier" probe="False" target="creole.general.int" transitive="True" warnings_only="False">
+    <check name="valid_entier" target="creole.general.int" transitive="True" warnings_only="False">
       <param name="mini" type="string">0</param>
       <param name="maxi" type="eole">creole.general.int2</param>
     </check>
   </constraints>
   <family doc="" name="creole">
-    <family hidden="False" mode="normal" doc="general" name="general">
+    <family doc="general" name="general">
+      <property>normal</property>
       <variable doc="No change" multi="False" name="mode_conteneur_actif" type="string">
         <property>mandatory</property>
         <property>normal</property>

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

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

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

@@ -1,13 +1,14 @@
 <?xml version='1.0' encoding='UTF-8'?>
 <creole>
   <constraints>
-    <check name="valid_differ" probe="False" target="creole.general.int" transitive="True" warnings_only="False">
+    <check name="valid_differ" target="creole.general.int" transitive="True" warnings_only="False">
       <param type="eole">creole.general.int2</param>
     </check>
-    <check name="valid_differ" probe="False" target="creole.general.int" transitive="True" warnings_only="False"/>
+    <check name="valid_differ" target="creole.general.int" transitive="True" warnings_only="False"/>
   </constraints>
   <family doc="" name="creole">
-    <family hidden="False" mode="normal" doc="general" name="general">
+    <family doc="general" name="general">
+      <property>normal</property>
       <variable doc="No change" multi="False" name="mode_conteneur_actif" type="string">
         <property>mandatory</property>
         <property>normal</property>

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

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

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

@@ -1,12 +1,13 @@
 <?xml version='1.0' encoding='UTF-8'?>
 <creole>
   <constraints>
-    <check name="valid_differ" probe="False" target="creole.general.mode_conteneur_actif" transitive="True" warnings_only="False">
+    <check name="valid_differ" target="creole.general.mode_conteneur_actif" transitive="True" warnings_only="False">
       <param type="eole">creole.general.mode_conteneur_actif1</param>
     </check>
   </constraints>
   <family doc="" name="creole">
-    <family hidden="False" mode="normal" doc="general" name="general">
+    <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>

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

@@ -0,0 +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"}

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

@@ -1,21 +1,22 @@
 <?xml version='1.0' encoding='UTF-8'?>
 <creole>
   <constraints>
-    <check name="valid_differ" probe="False" target="creole.general.mode_conteneur_actif3" transitive="True" warnings_only="False">
+    <check name="valid_differ" target="creole.general.mode_conteneur_actif3" transitive="True" warnings_only="False">
       <param type="eole">creole.general.mode_conteneur_actif1</param>
     </check>
-    <check name="valid_differ" probe="False" target="creole.general.mode_conteneur_actif3" transitive="True" warnings_only="False">
+    <check name="valid_differ" target="creole.general.mode_conteneur_actif3" transitive="True" warnings_only="False">
       <param type="eole">creole.general.mode_conteneur_actif2</param>
     </check>
-    <check name="valid_differ" probe="False" target="creole.general.mode_conteneur_actif3" transitive="True" warnings_only="False">
+    <check name="valid_differ" target="creole.general.mode_conteneur_actif3" transitive="True" warnings_only="False">
       <param type="eole">creole.general.mode_conteneur_actif1</param>
     </check>
-    <check name="valid_differ" probe="False" target="creole.general.mode_conteneur_actif3" transitive="True" warnings_only="False">
+    <check name="valid_differ" target="creole.general.mode_conteneur_actif3" transitive="True" warnings_only="False">
       <param type="eole">creole.general.mode_conteneur_actif2</param>
     </check>
   </constraints>
   <family doc="" name="creole">
-    <family hidden="False" mode="normal" doc="general" name="general">
+    <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>

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

@@ -0,0 +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"}

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

@@ -1,15 +1,16 @@
 <?xml version='1.0' encoding='UTF-8'?>
 <creole>
   <constraints>
-    <check name="valid_differ" probe="False" target="creole.general.mode_conteneur_actif3" transitive="True" warnings_only="False">
+    <check name="valid_differ" target="creole.general.mode_conteneur_actif3" transitive="True" warnings_only="False">
       <param type="eole">creole.general.mode_conteneur_actif1</param>
     </check>
-    <check name="valid_differ" probe="False" target="creole.general.mode_conteneur_actif3" transitive="True" warnings_only="False">
+    <check name="valid_differ" target="creole.general.mode_conteneur_actif3" transitive="True" warnings_only="False">
       <param type="eole">creole.general.mode_conteneur_actif2</param>
     </check>
   </constraints>
   <family doc="" name="creole">
-    <family hidden="False" mode="normal" doc="general" name="general">
+    <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>

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

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

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

@@ -1,12 +1,13 @@
 <?xml version='1.0' encoding='UTF-8'?>
 <creole>
   <constraints>
-    <check name="valid_ipnetmask" probe="False" target="creole.general.adresse_netmask_eth0" transitive="True" warnings_only="True">
+    <check name="valid_ipnetmask" target="creole.general.adresse_netmask_eth0" transitive="True" warnings_only="True">
       <param type="eole">creole.general.adresse_ip_eth0</param>
     </check>
   </constraints>
   <family doc="" name="creole">
-    <family hidden="False" mode="basic" doc="general" name="general">
+    <family doc="general" name="general">
+      <property>basic</property>
       <variable doc="No change" multi="False" name="mode_conteneur_actif" type="choice">
         <choice type="string">oui</choice>
         <choice type="string">non</choice>

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

@@ -0,0 +1 @@
+{"creole.general.condition": "non", "creole.general.mode_conteneur_actif": "non", "creole.general.mode_conteneur_actif2": "non"}

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

@@ -1,14 +1,9 @@
 <?xml version='1.0' encoding='UTF-8'?>
 <creole>
-  <constraints>
+  <constraints/>
-    <condition name="disabled_if_in" source="creole.general.condition">
-      <param hidden="True" type="string">oui</param>
-      <target type="variable">creole.general.mode_conteneur_actif</target>
-      <target type="variable">creole.general.mode_conteneur_actif2</target>
-    </condition>
-  </constraints>
   <family doc="" name="creole">
-    <family hidden="False" mode="normal" doc="general" name="general">
+    <family doc="general" name="general">
+      <property>normal</property>
       <variable doc="No change" multi="False" name="condition" type="choice">
         <choice type="string">oui</choice>
         <choice type="string">non</choice>
@@ -21,6 +16,7 @@
         <choice type="string">non</choice>
         <property>mandatory</property>
         <property>normal</property>
+        <property expected="oui" inverse="False" source="creole.general.condition" type="calculation">disabled</property>
         <value type="string">non</value>
       </variable>
       <variable doc="No change" multi="False" name="mode_conteneur_actif2" type="choice">
@@ -28,6 +24,7 @@
         <choice type="string">non</choice>
         <property>mandatory</property>
         <property>normal</property>
+        <property expected="oui" inverse="False" source="creole.general.condition" type="calculation">disabled</property>
         <value type="string">non</value>
       </variable>
     </family>

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

@@ -0,0 +1 @@
+{"creole.general.condition": "non", "creole.general.mode_conteneur_actif": "non", "creole.general.mode_conteneur_actif2": "non"}

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

@@ -1,14 +1,9 @@
 <?xml version='1.0' encoding='UTF-8'?>
 <creole>
-  <constraints>
+  <constraints/>
-    <condition name="disabled_if_in" source="creole.general.condition">
-      <param hidden="True" type="string"/>
-      <target type="variable">creole.general.mode_conteneur_actif</target>
-      <target type="variable">creole.general.mode_conteneur_actif2</target>
-    </condition>
-  </constraints>
   <family doc="" name="creole">
-    <family hidden="False" mode="normal" doc="general" name="general">
+    <family doc="general" name="general">
+      <property>normal</property>
       <variable doc="No change" multi="False" name="condition" type="string">
         <property>mandatory</property>
         <property>normal</property>
@@ -19,6 +14,7 @@
         <choice type="string">non</choice>
         <property>mandatory</property>
         <property>normal</property>
+        <property inverse="False" source="creole.general.condition" type="calculation">disabled</property>
         <value type="string">non</value>
       </variable>
       <variable doc="No change" multi="False" name="mode_conteneur_actif2" type="choice">
@@ -26,6 +22,7 @@
         <choice type="string">non</choice>
         <property>mandatory</property>
         <property>normal</property>
+        <property inverse="False" source="creole.general.condition" type="calculation">disabled</property>
         <value type="string">non</value>
       </variable>
     </family>

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

@@ -0,0 +1 @@
+{"creole.general.condition": "non", "creole.general.mode_conteneur_actif": "non", "creole.general.mode_conteneur_actif2": "non"}

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

@@ -1,15 +1,9 @@
 <?xml version='1.0' encoding='UTF-8'?>
 <creole>
-  <constraints>
+  <constraints/>
-    <condition name="disabled_if_in" source="creole.general.condition">
-      <param hidden="True" type="string">oui</param>
-      <target type="variable">creole.general.mode_conteneur_actif</target>
-      <target type="variable">creole.general.mode_conteneur_actif2</target>
-      <target type="family">creole.general2</target>
-    </condition>
-  </constraints>
   <family doc="" name="creole">
-    <family hidden="False" mode="normal" doc="Général" name="general">
+    <family doc="Général" name="general">
+      <property>normal</property>
       <variable doc="No change" multi="False" name="condition" type="choice">
         <choice type="string">oui</choice>
         <choice type="string">non</choice>
@@ -22,6 +16,7 @@
         <choice type="string">non</choice>
         <property>mandatory</property>
         <property>normal</property>
+        <property expected="oui" inverse="False" source="creole.general.condition" type="calculation">disabled</property>
         <value type="string">non</value>
       </variable>
       <variable doc="No change" multi="False" name="mode_conteneur_actif2" type="choice">
@@ -29,10 +24,13 @@
         <choice type="string">non</choice>
         <property>mandatory</property>
         <property>normal</property>
+        <property expected="oui" inverse="False" source="creole.general.condition" type="calculation">disabled</property>
         <value type="string">non</value>
       </variable>
     </family>
-    <family hidden="False" mode="normal" doc="Général2" name="general2">
+    <family doc="Général2" name="general2">
+      <property>normal</property>
+      <property expected="oui" inverse="False" source="creole.general.condition" type="calculation">disabled</property>
       <variable doc="No change" multi="False" name="mode_conteneur_actif3" type="choice">
         <choice type="string">oui</choice>
         <choice type="string">non</choice>

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

@@ -0,0 +1 @@
+{"creole.general.condition": "non", "creole.general.mode_conteneur_actif2": "non"}

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

@@ -1,13 +1,9 @@
 <?xml version='1.0' encoding='UTF-8'?>
 <creole>
-  <constraints>
+  <constraints/>
-    <condition name="disabled_if_in" source="creole.general.condition">
-      <param hidden="True" type="string">oui</param>
-      <target type="variable">creole.general.mode_conteneur_actif2</target>
-    </condition>
-  </constraints>
   <family doc="" name="creole">
-    <family hidden="False" mode="normal" doc="general" name="general">
+    <family doc="general" name="general">
+      <property>normal</property>
       <variable doc="No change" multi="False" name="condition" type="choice">
         <choice type="string">oui</choice>
         <choice type="string">non</choice>
@@ -28,6 +24,7 @@
         <choice type="string">non</choice>
         <property>mandatory</property>
         <property>normal</property>
+        <property expected="oui" inverse="False" source="creole.general.condition" type="calculation">disabled</property>
         <value type="string">non</value>
       </variable>
     </family>

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

@@ -0,0 +1 @@
+{"creole.general.condition": "non", "creole.general.mode_conteneur_actif": "non", "creole.general.mode_conteneur_actif2": "non"}

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

@@ -1,14 +1,9 @@
 <?xml version='1.0' encoding='UTF-8'?>
 <creole>
-  <constraints>
+  <constraints/>
-    <condition name="disabled_if_in" source="creole.general.condition">
-      <param hidden="True" type="string">oui</param>
-      <target type="variable">creole.general.mode_conteneur_actif</target>
-      <target type="variable">creole.general.mode_conteneur_actif2</target>
-    </condition>
-  </constraints>
   <family doc="" name="creole">
-    <family hidden="False" mode="normal" doc="general" name="general">
+    <family doc="general" name="general">
+      <property>normal</property>
       <variable doc="No change" multi="False" name="condition" type="choice">
         <choice type="string">oui</choice>
         <choice type="string">non</choice>
@@ -21,6 +16,7 @@
         <choice type="string">non</choice>
         <property>mandatory</property>
         <property>normal</property>
+        <property expected="oui" inverse="False" source="creole.general.condition" type="calculation">disabled</property>
         <value type="string">non</value>
       </variable>
       <variable doc="No change" multi="False" name="mode_conteneur_actif2" type="choice">
@@ -28,6 +24,7 @@
         <choice type="string">non</choice>
         <property>mandatory</property>
         <property>normal</property>
+        <property expected="oui" inverse="False" source="creole.general.condition" type="calculation">disabled</property>
         <value type="string">non</value>
       </variable>
     </family>

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

@@ -0,0 +1 @@
+{"creole.general.condition": "non", "creole.general.mode_conteneur_actif": "non", "creole.general.mode_conteneur_actif2": "non"}

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

@@ -1,14 +1,9 @@
 <?xml version='1.0' encoding='UTF-8'?>
 <creole>
-  <constraints>
+  <constraints/>
-    <condition name="frozen_if_in" source="creole.general.condition">
-      <param hidden="True" type="string">oui</param>
-      <target type="variable">creole.general.mode_conteneur_actif</target>
-      <target type="variable">creole.general.mode_conteneur_actif2</target>
-    </condition>
-  </constraints>
   <family doc="" name="creole">
-    <family hidden="False" mode="normal" doc="general" name="general">
+    <family doc="general" name="general">
+      <property>normal</property>
       <variable doc="No change" multi="False" name="condition" type="choice">
         <choice type="string">oui</choice>
         <choice type="string">non</choice>
@@ -21,6 +16,9 @@
         <choice type="string">non</choice>
         <property>mandatory</property>
         <property>normal</property>
+        <property expected="oui" inverse="False" source="creole.general.condition" type="calculation">frozen</property>
+        <property expected="oui" inverse="False" source="creole.general.condition" type="calculation">hidden</property>
+        <property expected="oui" inverse="False" source="creole.general.condition" type="calculation">force_default_on_freeze</property>
         <value type="string">non</value>
       </variable>
       <variable doc="No change" multi="False" name="mode_conteneur_actif2" type="choice">
@@ -28,6 +26,9 @@
         <choice type="string">non</choice>
         <property>mandatory</property>
         <property>normal</property>
+        <property expected="oui" inverse="False" source="creole.general.condition" type="calculation">frozen</property>
+        <property expected="oui" inverse="False" source="creole.general.condition" type="calculation">hidden</property>
+        <property expected="oui" inverse="False" source="creole.general.condition" type="calculation">force_default_on_freeze</property>
         <value type="string">non</value>
       </variable>
     </family>

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

@@ -0,0 +1 @@
+{"creole.general.condition": "non", "creole.general.mode_conteneur_actif": null, "creole.general.mode_conteneur_actif2": "non"}

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

@@ -1,17 +1,13 @@
 <?xml version='1.0' encoding='UTF-8'?>
 <creole>
   <constraints>
-    <condition name="frozen_if_in" source="creole.general.condition">
-      <param hidden="True" type="string">oui</param>
-      <target type="variable">creole.general.mode_conteneur_actif</target>
-      <target type="variable">creole.general.mode_conteneur_actif2</target>
-    </condition>
     <fill name="calc_val" target="creole.general.mode_conteneur_actif">
       <param hidden="True" type="string">non</param>
     </fill>
   </constraints>
   <family doc="" name="creole">
-    <family hidden="False" mode="normal" doc="general" name="general">
+    <family doc="general" name="general">
+      <property>normal</property>
       <variable doc="No change" multi="False" name="condition" type="choice">
         <choice type="string">oui</choice>
         <choice type="string">non</choice>
@@ -24,12 +20,18 @@
         <choice type="string">non</choice>
         <property>mandatory</property>
         <property>normal</property>
+        <property expected="oui" inverse="False" source="creole.general.condition" type="calculation">frozen</property>
+        <property expected="oui" inverse="False" source="creole.general.condition" type="calculation">hidden</property>
+        <property expected="oui" inverse="False" source="creole.general.condition" type="calculation">force_default_on_freeze</property>
       </variable>
       <variable doc="No change" multi="False" name="mode_conteneur_actif2" type="choice">
         <choice type="string">oui</choice>
         <choice type="string">non</choice>
         <property>mandatory</property>
         <property>normal</property>
+        <property expected="oui" inverse="False" source="creole.general.condition" type="calculation">frozen</property>
+        <property expected="oui" inverse="False" source="creole.general.condition" type="calculation">hidden</property>
+        <property expected="oui" inverse="False" source="creole.general.condition" type="calculation">force_default_on_freeze</property>
         <value type="string">non</value>
       </variable>
     </family>

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

@@ -0,0 +1 @@
+{"creole.general.condition": "tous"}

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

@@ -1,15 +1,9 @@
 <?xml version='1.0' encoding='UTF-8'?>
 <creole>
-  <constraints>
+  <constraints/>
-    <condition name="frozen_if_in" source="creole.general.condition">
-      <param hidden="True" type="string">tous</param>
-      <param hidden="True" type="string">authentifié</param>
-      <target type="variable">creole.general.mode_conteneur_actif</target>
-      <target type="variable">creole.general.mode_conteneur_actif2</target>
-    </condition>
-  </constraints>
   <family doc="" name="creole">
-    <family hidden="False" mode="normal" doc="general" name="general">
+    <family doc="general" name="general">
+      <property>normal</property>
       <variable doc="No change" multi="False" name="condition" type="choice">
         <choice type="string">tous</choice>
         <choice type="string">authentifié</choice>
@@ -23,6 +17,12 @@
         <choice type="string">non</choice>
         <property>mandatory</property>
         <property>normal</property>
+        <property expected="tous" inverse="False" source="creole.general.condition" type="calculation">frozen</property>
+        <property expected="tous" inverse="False" source="creole.general.condition" type="calculation">hidden</property>
+        <property expected="tous" inverse="False" source="creole.general.condition" type="calculation">force_default_on_freeze</property>
+        <property expected="authentifié" inverse="False" source="creole.general.condition" type="calculation">frozen</property>
+        <property expected="authentifié" inverse="False" source="creole.general.condition" type="calculation">hidden</property>
+        <property expected="authentifié" inverse="False" source="creole.general.condition" type="calculation">force_default_on_freeze</property>
         <value type="string">non</value>
       </variable>
       <variable doc="No change" multi="False" name="mode_conteneur_actif2" type="choice">
@@ -30,6 +30,12 @@
         <choice type="string">non</choice>
         <property>mandatory</property>
         <property>normal</property>
+        <property expected="tous" inverse="False" source="creole.general.condition" type="calculation">frozen</property>
+        <property expected="tous" inverse="False" source="creole.general.condition" type="calculation">hidden</property>
+        <property expected="tous" inverse="False" source="creole.general.condition" type="calculation">force_default_on_freeze</property>
+        <property expected="authentifié" inverse="False" source="creole.general.condition" type="calculation">frozen</property>
+        <property expected="authentifié" inverse="False" source="creole.general.condition" type="calculation">hidden</property>
+        <property expected="authentifié" inverse="False" source="creole.general.condition" type="calculation">force_default_on_freeze</property>
         <value type="string">non</value>
       </variable>
     </family>

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

@@ -0,0 +1 @@
+{"creole.general.condition": "tous"}

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

@@ -1,7 +1,9 @@
+<?xml version='1.0' encoding='UTF-8'?>
 <creole>
   <constraints/>
   <family doc="" name="creole">
-    <family hidden="False" mode="normal" doc="general" name="general">
+    <family doc="general" name="general">
+      <property>normal</property>
       <variable doc="No change" multi="False" name="condition" type="choice">
         <choice type="string">tous</choice>
         <choice type="string">authentifié</choice>

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

@@ -0,0 +1 @@
+{"creole.general.condition": "non", "creole.general.mode_conteneur_actif": "non", "creole.general.mode_conteneur_actif2": "non"}

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

@@ -1,14 +1,9 @@
 <?xml version='1.0' encoding='UTF-8'?>
 <creole>
-  <constraints>
+  <constraints/>
-    <condition name="mandatory_if_in" source="creole.general.condition">
-      <param hidden="True" type="string">oui</param>
-      <target type="variable">creole.general.mode_conteneur_actif</target>
-      <target type="variable">creole.general.mode_conteneur_actif2</target>
-    </condition>
-  </constraints>
   <family doc="" name="creole">
-    <family hidden="False" mode="normal" doc="general" name="general">
+    <family doc="general" name="general">
+      <property>normal</property>
       <variable doc="No change" multi="False" name="condition" type="choice">
         <choice type="string">oui</choice>
         <choice type="string">non</choice>
@@ -21,6 +16,7 @@
         <choice type="string">non</choice>
         <property>mandatory</property>
         <property>normal</property>
+        <property expected="oui" inverse="False" source="creole.general.condition" type="calculation">mandatory</property>
         <value type="string">non</value>
       </variable>
       <variable doc="No change" multi="False" name="mode_conteneur_actif2" type="choice">
@@ -28,6 +24,7 @@
         <choice type="string">non</choice>
         <property>mandatory</property>
         <property>normal</property>
+        <property expected="oui" inverse="False" source="creole.general.condition" type="calculation">mandatory</property>
         <value type="string">non</value>
       </variable>
     </family>

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

@@ -0,0 +1 @@
+{"creole.general.mode_conteneur_actif": "non", "creole.general1.master.master": [], "creole.general1.master.slave1": [], "creole.general1.master.slave2": []}

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

@@ -9,7 +9,8 @@
     </fill>
   </constraints>
   <family doc="" name="creole">
-    <family hidden="False" mode="normal" doc="general" name="general">
+    <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>
@@ -18,11 +19,11 @@
         <value type="string">non</value>
       </variable>
     </family>
-    <family hidden="False" mode="normal" doc="general1" name="general1">
+    <family doc="general1" name="general1">
-      <leader doc="master" mode="normal" name="master">
-        <variable doc="master" multi="True" name="master" type="string">
       <property>normal</property>
-        </variable>
+      <leader doc="master" name="master">
+        <property>normal</property>
+        <variable doc="master" multi="True" name="master" type="string"/>
         <variable doc="slave1" multi="True" name="slave1" type="string">
           <property>normal</property>
         </variable>

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

@@ -0,0 +1 @@
+{"creole.general.mode_conteneur_actif": ["non"], "creole.general.master.master": [], "creole.general.master.slave1": [], "creole.general.master.slave2": []}

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

@@ -2,7 +2,8 @@
 <creole>
   <constraints/>
   <family doc="" name="creole">
-    <family hidden="False" mode="normal" doc="general" name="general">
+    <family doc="general" name="general">
+      <property>normal</property>
       <variable doc="master" multi="True" name="mode_conteneur_actif" type="choice">
         <choice type="string">oui</choice>
         <choice type="string">non</choice>
@@ -10,10 +11,9 @@
         <property>normal</property>
         <value type="string">non</value>
       </variable>
-      <leader doc="master" mode="normal" name="master">
+      <leader doc="master" name="master">
-        <variable doc="master" multi="True" name="master" type="string">
         <property>normal</property>
-        </variable>
+        <variable doc="master" multi="True" name="master" type="string"/>
         <variable doc="slave1" multi="True" name="slave1" type="string">
           <property>mandatory</property>
           <property>normal</property>

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

@@ -0,0 +1 @@
+{"creole.general.mode_conteneur_actif": ["non"], "creole.general.master.master": ["value"], "creole.general.master.slave1": [null], "creole.general.master.slave2": [null]}

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

@@ -2,7 +2,8 @@
 <creole>
   <constraints/>
   <family doc="" name="creole">
-    <family hidden="False" mode="normal" doc="general" name="general">
+    <family doc="general" name="general">
+      <property>normal</property>
       <variable doc="master" multi="True" name="mode_conteneur_actif" type="choice">
         <choice type="string">oui</choice>
         <choice type="string">non</choice>
@@ -10,10 +11,10 @@
         <property>normal</property>
         <value type="string">non</value>
       </variable>
-      <leader doc="master" mode="normal" name="master">
+      <leader doc="master" name="master">
+        <property>normal</property>
         <variable doc="master" multi="True" name="master" type="string">
           <property>mandatory</property>
-          <property>normal</property>
           <value>value</value>
         </variable>
         <variable doc="slave1" multi="True" name="slave1" type="string">

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

@@ -0,0 +1 @@
+{"creole.general.mode_conteneur_actif": "non", "creole.general_1.master.master": [], "creole.general_1.master.slave1": [], "creole.general_1.master.slave2": []}

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

@@ -2,7 +2,8 @@
 <creole>
   <constraints/>
   <family doc="" name="creole">
-    <family hidden="False" mode="normal" doc="general" name="general">
+    <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>
@@ -11,11 +12,12 @@
         <value type="string">non</value>
       </variable>
     </family>
-    <family hidden="False" mode="basic" doc="general-1" name="general_1">
+    <family doc="general-1" name="general_1">
-      <leader doc="master" mode="basic" name="master">
+      <property>basic</property>
+      <leader doc="master" name="master">
+        <property>basic</property>
         <variable doc="master" multi="True" name="master" type="string">
           <property>mandatory</property>
-          <property>basic</property>
         </variable>
         <variable doc="slave1" multi="True" name="slave1" type="string">
           <property>normal</property>

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

@@ -2,7 +2,8 @@
 <creole>
   <constraints/>
   <family doc="" name="creole">
-    <family hidden="False" mode="normal" doc="general" name="general">
+    <family doc="general" name="general">
+      <property>normal</property>
       <variable doc="No change" multi="True" name="mode_conteneur_actif" type="choice">
         <choice type="string">oui</choice>
         <choice type="string">non</choice>

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

@@ -0,0 +1 @@
+{"creole.general.mode_conteneur_actif": "non", "creole.general.master.master": [], "creole.general.master.slave1": [], "creole.general.master.slave2": []}

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

@@ -9,7 +9,8 @@
     </fill>
   </constraints>
   <family doc="" name="creole">
-    <family hidden="False" mode="normal" doc="general" name="general">
+    <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>
@@ -17,10 +18,9 @@
         <property>normal</property>
         <value type="string">non</value>
       </variable>
-      <leader doc="master" mode="normal" name="master">
+      <leader doc="master" name="master">
-        <variable doc="master" multi="True" name="master" type="string">
         <property>normal</property>
-        </variable>
+        <variable doc="master" multi="True" name="master" type="string"/>
         <variable doc="slave1" multi="True" name="slave1" type="string">
           <property>normal</property>
         </variable>

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

@@ -0,0 +1 @@
+{"creole.general.mode_conteneur_actif": "non", "creole.general.master.master": [], "creole.general.master.slave1": [], "creole.general.master.slave2": []}

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

@@ -9,7 +9,8 @@
     </fill>
   </constraints>
   <family doc="" name="creole">
-    <family hidden="False" mode="normal" doc="general" name="general">
+    <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>
@@ -17,10 +18,9 @@
         <property>normal</property>
         <value type="string">non</value>
       </variable>
-      <leader doc="master" mode="normal" name="master">
+      <leader doc="master" name="master">
-        <variable doc="master" multi="True" name="master" type="string">
         <property>normal</property>
-        </variable>
+        <variable doc="master" multi="True" name="master" type="string"/>
         <variable doc="slave1" multi="True" name="slave1" type="string">
           <property>mandatory</property>
           <property>normal</property>

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

@@ -0,0 +1 @@
+{"creole.general.nut_monitor_netmask.nut_monitor_netmask": [], "creole.general.nut_monitor_netmask.nut_monitor_host": []}

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

@@ -2,7 +2,8 @@
 <creole>
   <constraints/>
   <family doc="" name="creole">
-    <family hidden="False" mode="normal" doc="général" name="general">
+    <family doc="général" 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>
@@ -13,10 +14,9 @@
         <property>normal</property>
         <value type="string">oui</value>
       </variable>
-      <leader doc="Masque de l'IP du réseau de l'esclave" mode="normal" name="nut_monitor_netmask">
+      <leader doc="Masque de l'IP du réseau de l'esclave" name="nut_monitor_netmask">
-        <variable doc="Masque de l'IP du réseau de l'esclave" multi="True" name="nut_monitor_netmask" type="netmask">
         <property>normal</property>
-        </variable>
+        <variable doc="Masque de l'IP du réseau de l'esclave" multi="True" name="nut_monitor_netmask" type="netmask"/>
         <variable doc="Adresse IP du réseau de l'esclave" multi="True" name="nut_monitor_host" type="network">
           <property>mandatory</property>
           <property>normal</property>

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

@@ -0,0 +1 @@
+{"creole.general.mode_conteneur_actif": "non", "creole.general.master.master": [], "creole.general.master.slave1": [], "creole.general.master.slave2": []}

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

@@ -9,7 +9,8 @@
     </fill>
   </constraints>
   <family doc="" name="creole">
-    <family hidden="False" mode="basic" doc="general" name="general">
+    <family doc="general" name="general">
+      <property>basic</property>
       <variable doc="No change" multi="False" name="mode_conteneur_actif" type="choice">
         <choice type="string">oui</choice>
         <choice type="string">non</choice>
@@ -17,10 +18,10 @@
         <property>normal</property>
         <value type="string">non</value>
       </variable>
-      <leader doc="master" mode="basic" name="master">
+      <leader doc="master" name="master">
+        <property>basic</property>
         <variable doc="master" multi="True" name="master" type="string">
           <property>mandatory</property>
-          <property>basic</property>
         </variable>
         <variable doc="slave1" multi="True" name="slave1" type="string">
           <property>normal</property>

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

@@ -0,0 +1 @@
+{"creole.general.mode_conteneur_actif": "non", "creole.general1.master.master": [], "creole.general1.master.slave1": [], "creole.general1.master.slave2": [], "creole.general1.master1.master1": [], "creole.general1.master1.slave11": [], "creole.general1.master1.slave21": []}