Merge branch 'develop' into dist/risotto/risotto-2.8.0/develop

src/rougail/annotator/family.py

@@ -120,7 +120,7 @@ class Annotator(Walk):
                    obj,
                    ) -> None:
         modes_level = self.objectspace.rougailconfig['modes_level']
-        if hasattr(obj, 'mode') and obj.mode not in modes_level:
+        if self._has_mode(obj) and obj.mode not in modes_level:
             msg = _(f'mode "{obj.mode}" for "{obj.name}" is not a valid mode, '
                     f'valid modes are {modes_level}')
             raise DictConsistencyError(msg, 71, obj.xmlfiles)
@@ -128,23 +128,29 @@ class Annotator(Walk):
     def _set_default_mode(self,
                          family: 'self.objectspace.family',
                          ) -> None:
-        if hasattr(family, 'mode') and 'mode' in vars(family):
+        if not hasattr(family, 'variable'):
+            return
+        if self._has_mode(family):
             family_mode = family.mode
         else:
             family_mode = None
-        if not hasattr(family, 'variable'):
+        leader = None
-            return
         for variable in family.variable.values():
-            self.valid_mode(variable)
+            if leader is None and hasattr(family, 'leadership') and family.leadership:
+                leader = variable
             if isinstance(variable, self.objectspace.family):
-                if not variable.leadership:
+                # set default mode a subfamily
-                    if family_mode and not self._has_mode(variable):
+                if family_mode and not self._has_mode(variable):
-                        self._set_auto_mode(variable, family_mode)
+                    self._set_auto_mode(variable, family_mode)
-                    continue
-                func = self._set_default_mode_leader
             else:
-                func = self._set_default_mode_variable
+                # set default mode to a variable
-            func(variable, family_mode)
+                self.valid_mode(variable)
+                if leader:
+                    self._set_default_mode_leader(leader, variable)
+                self._set_default_mode_variable(variable, family_mode)
+        if leader:
+            # here because follower can change leader mode
+            self._set_auto_mode(family, leader.mode)
 
     @staticmethod
     def _has_mode(obj) -> bool:
@@ -174,92 +180,80 @@ class Annotator(Walk):
         obj.mode_auto = True
 
     def _set_default_mode_leader(self,
-                                 leadership: 'self.objectspace.family',
+                                 leader: 'self.objectspace.variable',
-                                 family_mode: str,
+                                 follower: 'self.objectspace.variable',
                                  ) -> None:
-        leader_mode = None
+        if follower.auto_save is True:
-        leader = next(iter(leadership.variable.values()))
+            msg = _(f'leader/followers "{follower.name}" could not be auto_save')
-        for follower in leadership.variable.values():
+            raise DictConsistencyError(msg, 29, follower.xmlfiles)
-            self.valid_mode(follower)
+        if follower.auto_freeze is True:
-            if follower.auto_save is True:
+            msg = f'leader/followers "{follower.name}" could not be auto_freeze'
-                msg = _(f'leader/followers "{follower.name}" could not be auto_save')
+            raise DictConsistencyError(_(msg), 30, follower.xmlfiles)
-                raise DictConsistencyError(msg, 29, leadership.xmlfiles)
+        if leader == follower:
-            if follower.auto_freeze is True:
+            # it's a leader
-                msg = f'leader/followers "{follower.name}" could not be auto_freeze'
+            if not hasattr(leader, 'mode'):
-                raise DictConsistencyError(_(msg), 30, leadership.xmlfiles)
+                self._set_auto_mode(leader, self.objectspace.rougailconfig['default_variable_mode'])
-            if leader_mode is not None:
+            return
-                if hasattr(follower, 'mode'):
+        if self._has_mode(follower):
-                    follower_mode = follower.mode
+            follower_mode = follower.mode
-                else:
+        else:
-                    follower_mode = self.objectspace.rougailconfig['default_variable_mode']
+            follower_mode = self.objectspace.rougailconfig['default_variable_mode']
-                if self.modes[leader_mode] > self.modes[follower_mode]:
+        if self.modes[leader.mode] > self.modes[follower_mode]:
-                    if self._has_mode(follower) and not self._has_mode(leader):
+            if self._has_mode(follower) and not self._has_mode(leader):
-                        # if follower has mode but not the leader
+                # if follower has mode but not the leader
-                        self._set_auto_mode(leader, follower_mode)
+                self._set_auto_mode(leader, follower_mode)
-                    else:
+            else:
-                        # leader's mode is minimum level
+                # leader's mode is minimum level
-                        if self._has_mode(follower):
+                if self._has_mode(follower):
-                            msg = _(f'the follower "{follower.name}" is in "{follower_mode}" mode '
+                    msg = _(f'the follower "{follower.name}" is in "{follower_mode}" mode '
-                                    f'but leader have the higher mode "{leader_mode}"')
+                            f'but leader have the higher mode "{leader.mode}"')
-                            raise DictConsistencyError(msg, 63, follower.xmlfiles)
+                    raise DictConsistencyError(msg, 63, follower.xmlfiles)
-                        self._set_auto_mode(follower, leader_mode)
+                self._set_auto_mode(follower, leader.mode)
-            self._set_default_mode_variable(follower,
-                                            family_mode,
-                                            )
-            if leader_mode is None:
-                if hasattr(leader, 'mode'):
-                    leader_mode = leader.mode
-                else:
-                    leader_mode = self.objectspace.rougailconfig['default_variable_mode']
-        if hasattr(leader, 'mode'):
-            leader_mode = leader.mode
-        self._set_auto_mode(leadership, leader_mode)
 
     def _change_family_mode(self,
-                           family: 'self.objectspace.family',
+                            family: 'self.objectspace.family',
-                           ) -> None:
+                            ) -> None:
         if hasattr(family, 'mode'):
             family_mode = family.mode
         else:
             family_mode = self.objectspace.rougailconfig['default_family_mode']
         min_variable_mode = self.objectspace.rougailconfig['modes_level'][-1]
         # change variable mode, but not if variables are not in a family
+        is_leadership = hasattr(family, 'leadership') and family.leadership
         if hasattr(family, 'variable'):
-            for variable in family.variable.values():
+            for idx, variable in enumerate(family.variable.values()):
                 if isinstance(variable, self.objectspace.family):
-                    if variable.leadership:
+                    if not hasattr(variable, 'mode'):
-                        func = self._change_variable_mode_leader
+                        variable.mode = self.objectspace.rougailconfig['default_family_mode']
-                    else:
+                elif idx == 0 and is_leadership:
-                        func = None
+                    variable.mode = None
+                    continue
                 else:
-                    func = self._change_variable_mode
+                    self._change_variable_mode(variable, family_mode, is_leadership)
-                if func:
-                    func(variable,
-                         family_mode,
-                         )
-                elif not hasattr(variable, 'mode'):
-                    variable.mode = self.objectspace.rougailconfig['default_family_mode']
                 if self.modes[min_variable_mode] > self.modes[variable.mode]:
                     min_variable_mode = variable.mode
-        if isinstance(family, self.objectspace.family) and \
+        if not isinstance(family, self.objectspace.family) or is_leadership:
-                (not hasattr(family, 'mode') or family.mode != min_variable_mode):
+            # it's Variable, Service, ... and leadership
+            return
+        if not hasattr(family, 'mode'):
             # set the lower variable mode to family
-            if self._has_mode(family):
-                msg = _(f'the family "{family.name}" is in "{family.mode}" mode but variables and '
-                        f'families inside have the higher modes "{min_variable_mode}"')
-                raise DictConsistencyError(msg, 62, family.xmlfiles)
             self._set_auto_mode(family, min_variable_mode)
+        if family.mode != min_variable_mode:
+            msg = _(f'the family "{family.name}" is in "{family.mode}" mode but variables and '
+                    f'families inside have the higher modes "{min_variable_mode}"')
+            raise DictConsistencyError(msg, 62, family.xmlfiles)
 
     def _change_variable_mode(self,
                              variable,
                              family_mode: str,
+                             is_follower: bool,
                              ) -> None:
         if hasattr(variable, 'mode'):
             variable_mode = variable.mode
         else:
             variable_mode = self.objectspace.rougailconfig['default_variable_mode']
         # none basic variable in high level family has to be in high level
-        if self.modes[variable_mode] < self.modes[family_mode]:
+        if not is_follower and self.modes[variable_mode] < self.modes[family_mode]:
             if self._has_mode(variable):
                 msg = _(f'the variable "{variable.name}" is in "{variable_mode}" mode '
                         f'but family has the higher family mode "{family_mode}"')
@@ -268,18 +262,6 @@ class Annotator(Walk):
         if not hasattr(variable, 'mode'):
             variable.mode = variable_mode
 
-    def _change_variable_mode_leader(self,
-                                     leadership,
-                                     family_mode: str,
-                                     ) -> None:
-        for idx, follower in enumerate(leadership.variable.values()):
-            if idx == 0:
-                leader = follower
-            self._change_variable_mode(follower,
-                                      family_mode,
-                                      )
-        leader.mode = None
-
     def dynamic_families(self):
         """link dynamic families to object
         """
@@ -293,7 +275,7 @@ class Annotator(Walk):
                         f'to multi variable')
                 raise DictConsistencyError(msg, 16, family.xmlfiles)
             for variable in family.variable.values():
-                if isinstance(variable, self.objectspace.family):
+                if isinstance(variable, self.objectspace.family) and not variable.leadership:
                     msg = _(f'dynamic family "{family.name}" cannot contains another family')
                     raise DictConsistencyError(msg, 22, family.xmlfiles)
 

src/rougail/annotator/group.py

@@ -47,7 +47,7 @@ class Annotator(Walk):
         """convert groups
         """
         # store old leaders family name
-        for family in self.get_families(with_leadership=True):
+        for family in self.get_families():
             if not isinstance(family, self.objectspace.family):
                 continue
             if not family.leadership:
@@ -55,7 +55,6 @@ class Annotator(Walk):
             if hasattr(family, 'dynamic'):
                 msg = _(f'the family "{family.name}" cannot be leadership and dynamic together')
                 raise DictConsistencyError(msg, 31, family.xmlfiles)
-            family.doc = family.description
             for idx, variable in enumerate(family.variable.values()):
                 if idx == 0:
                     # it's a leader
@@ -72,3 +71,7 @@ class Annotator(Walk):
                     if family.hidden:
                         variable.frozen = True
                         variable.force_default_on_freeze = True
+                    if variable.multi is True:
+                        variable.multi = 'submulti'
+                    else:
+                        variable.multi = True

src/rougail/annotator/property.py

@@ -106,8 +106,5 @@ class Annotator(Walk):
     def convert_variable(self) -> None:
         """convert variables
         """
-        for variable in self.get_variables(with_leadership=True):
+        for variable in self.get_variables():
-            if isinstance(variable, self.objectspace.family):
-                for follower in variable.variable.values():
-                    self.convert_property(follower)
             self.convert_property(variable)

src/rougail/annotator/value.py

@@ -45,20 +45,11 @@ class Annotator(Walk):  # pylint: disable=R0903
     def convert_value(self) -> None:
         """convert value
         """
-        for variable in self.get_variables(with_leadership=True):
+        for variable in self.get_variables():
-            if isinstance(variable, self.objectspace.family):
+            self._convert_value(variable)
-                variable_type = 'leader'
-                for follower in variable.variable.values():
-                    self._convert_value(follower,
-                                        variable_type,
-                                        )
-                    variable_type = 'follower'
-            else:
-                self._convert_value(variable)
 
     def _convert_value(self,
                        variable,
-                       variable_type: str=None,
                        ) -> None:
         # a boolean must have value, the default value is "True"
         if not hasattr(variable, 'value') and variable.type == 'boolean':
@@ -83,9 +74,9 @@ class Annotator(Walk):  # pylint: disable=R0903
         if variable.value[0].type == 'calculation':
             variable.default = variable.value[0]
         elif variable.multi:
-            if variable_type != 'follower':
+            if not self.objectspace.paths.is_follower(variable.path):
                 variable.default = [value.name for value in variable.value]
-            if variable_type != 'leader':
+            if not self.objectspace.paths.is_leader(variable.path):
                 if variable.multi == 'submulti':
                     variable.default_multi = [value.name for value in variable.value]
                 else:

src/rougail/annotator/variable.py

@@ -72,45 +72,38 @@ class Walk:
     """
     objectspace = None
 
-    def get_variables(self,
+    def get_variables(self):
-                      with_leadership: bool=False,
-                      ):
         """Iter all variables from the objectspace
         """
         for family in self.objectspace.space.variables.values():
-            yield from self._get_variables(family, with_leadership)
+            yield from self._get_variables(family)
 
     def _get_variables(self,
                        family: 'self.objectspace.family',
-                       with_leadership: bool
                        ):
-        if hasattr(family, 'variable'):
+        if not hasattr(family, 'variable'):
-            for variable in family.variable.values():
+            return
-                if isinstance(variable, self.objectspace.family):
+        for variable in family.variable.values():
-                    if variable.leadership is False:
+            if isinstance(variable, self.objectspace.family):
-                        yield from self._get_variables(variable, with_leadership)
+                yield from self._get_variables(variable)
-                        continue
+            else:
-                    if not with_leadership:
-                        for follower in variable.variable.values():
-                            yield follower
-                        continue
                 yield variable
 
-    def get_families(self, with_leadership=False):
+    def get_families(self):
         """Iter all families from the objectspace
         """
         for family in self.objectspace.space.variables.values():
-            yield from self._get_families(family, with_leadership)
+            yield from self._get_families(family)
 
     def _get_families(self,
                       family: 'self.objectspace.family',
-                      with_leadership: bool,
                       ):
         yield family
-        if hasattr(family, 'variable'):
+        if not hasattr(family, 'variable'):
-            for fam in family.variable.values():
+            return
-                if isinstance(fam, self.objectspace.family) and (with_leadership or not fam.leadership):
+        for fam in family.variable.values():
-                    yield from self._get_families(fam, with_leadership)
+            if isinstance(fam, self.objectspace.family):
+                yield from self._get_families(fam)
 
 
 class Annotator(Walk):  # pylint: disable=R0903
@@ -134,23 +127,11 @@ class Annotator(Walk):  # pylint: disable=R0903
     def convert_variable(self):
         """convert variable
         """
-        for variable in self.get_variables(with_leadership=True):
+        for variable in self.get_variables():
-            if isinstance(variable, self.objectspace.family):
+            self._convert_variable(variable)
-                # first variable is a leader, others are follower
-                variable_type = 'leader'
-                for follower in variable.variable.values():
-                    self._convert_variable(follower,
-                                           variable_type,
-                                           )
-                    variable_type = 'follower'
-            else:
-                self._convert_variable(variable,
-                                       'variable',
-                                       )
 
     def _convert_variable(self,
                           variable,
-                          variable_type: str,
                           ) -> None:
         if variable.namespace == self.objectspace.rougailconfig['variable_namespace'] and \
                 variable.name in self.forbidden_name:
@@ -175,11 +156,6 @@ class Annotator(Walk):  # pylint: disable=R0903
                 del variable.value
         variable.doc = variable.description
         del variable.description
-        if variable_type == 'follower':
-            if variable.multi is True:
-                variable.multi = 'submulti'
-            else:
-                variable.multi = True
         self._convert_valid_enum(variable)
 
     def _convert_valid_enum(self,
@@ -213,21 +189,19 @@ class Annotator(Walk):  # pylint: disable=R0903
         """Convert variable tests value
         """
         for variable in self.get_variables():
-            if not hasattr(variable, 'test'):
+            if not hasattr(variable, 'test') or not variable.test:
+                # with we want remove test, we set "" has test value
                 continue
-            if variable.test:
+            new_values = []
-                if not hasattr(variable, 'information'):
+            for value in variable.test.split('|'):
-                    variable.information = self.objectspace.information(variable.xmlfiles)
+                if value == '':
-                values = variable.test.split('|')
+                    value = None
-                new_values = []
+                else:
-                for value in values:
+                    value = CONVERT_OPTION.get(variable.type, {}).get('func', str)(value)
-                    if value == '':
+                new_values.append(value)
-                        value = None
+            if not hasattr(variable, 'information'):
-                    else:
+                variable.information = self.objectspace.information(variable.xmlfiles)
-                        value = CONVERT_OPTION.get(variable.type, {}).get('func', str)(value)
+            variable.information.test = tuple(new_values)
-                    new_values.append(value)
-                variable.information.test = tuple(new_values)
-            del variable.test
 
     def convert_help(self):
         """Convert variable help

src/rougail/objspace.py

@@ -38,7 +38,7 @@ FORCE_REDEFINABLES = ('family', 'follower', 'service', 'disknod', 'variables')
 # RougailObjSpace's elements that shall be forced to the UnRedefinable type
 FORCE_UNREDEFINABLES = ('value',)
 # RougailObjSpace's elements that shall not be modify
-UNREDEFINABLE = ('multi', 'type', 'leadership')
+UNREDEFINABLE = ('multi', 'type',)
 # RougailObjSpace's elements that did not created automaticly
 FORCE_ELEMENTS = ('choice', 'property_', 'information')
 # XML text are convert has name
@@ -488,7 +488,7 @@ class RougailObjSpace:
         elif isinstance(variableobj, self.family):  # pylint: disable=E1101
             family_name = variableobj.name
             if namespace != self.rougailconfig['variable_namespace']:
-                family_name = namespace + '.' + family_name
+                family_name = space.path + '.' + family_name
             self.paths.add_family(namespace,
                                   family_name,
                                   variableobj,

src/rougail/tiramisureflector.py

@@ -251,7 +251,11 @@ class Common:
         if param.type == 'variable':
             return self.build_option_param(param)
         if param.type == 'information':
-            return f'ParamInformation("{param.text}", None)'
+            if hasattr(self.elt, 'multi') and self.elt.multi:
+                default = []
+            else:
+                default = None
+            return f'ParamInformation("{param.text}", {default})'
         if param.type == 'target_information':
             return f'ParamSelfInformation("{param.text}", None)'
         if param.type == 'suffix':

src/rougail/update.py

@@ -76,6 +76,8 @@ class RougailUpgrade:
         for filename in filenames:
             xmlsrc = join(srcfolder, filename)
             xmldst = join(dstfolder, filename)
+            if isfile(xmldst):
+                raise Exception(f'cannot update "{xmlsrc}" destination file "{xmldst}" already exists')
             try:
                 parser = XMLParser(remove_blank_text=True)
                 document = parse(xmlsrc, parser)

tests/dictionaries/10fill_information_multi/00-base.xml

@@ -0,0 +1,14 @@
+<?xml version='1.0' encoding='UTF-8'?>
+<rougail version="0.10">
+  <variables>
+    <family name="general">
+      <variable name="mode_conteneur_actif" type="string" description="No change" multi="True"/>
+    </family>
+  </variables>
+  <constraints>
+    <fill name="calc_val">
+      <param type="information">test_information</param>
+      <target>mode_conteneur_actif</target>
+    </fill>
+  </constraints>
+</rougail>

tests/dictionaries/10fill_information_multi/makedict/after.json

@@ -0,0 +1,8 @@
+{
+    "rougail.general.mode_conteneur_actif": {
+        "owner": "default",
+        "value": [
+            "value"
+        ]
+    }
+}

tests/dictionaries/10fill_information_multi/makedict/base.json

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

tests/dictionaries/10fill_information_multi/makedict/before.json

@@ -0,0 +1,8 @@
+{
+    "rougail.general.mode_conteneur_actif": {
+        "owner": "default",
+        "value": [
+            "value"
+        ]
+    }
+}

tests/dictionaries/10fill_information_multi/tiramisu/base.py

@@ -0,0 +1,17 @@
+from importlib.machinery import SourceFileLoader
+from importlib.util import spec_from_loader, module_from_spec
+loader = SourceFileLoader('func', 'tests/dictionaries/../eosfunc/test.py')
+spec = spec_from_loader(loader.name, loader)
+func = module_from_spec(spec)
+loader.exec_module(func)
+for key, value in dict(locals()).items():
+    if key != ['SourceFileLoader', 'func']:
+        setattr(func, key, value)
+try:
+    from tiramisu3 import *
+except:
+    from tiramisu import *
+option_3 = StrOption(name="mode_conteneur_actif", doc="No change", multi=True, default=[Calculation(func.calc_val, Params((ParamInformation("test_information", []))))], properties=frozenset({"normal"}))
+option_2 = OptionDescription(name="general", doc="general", children=[option_3], properties=frozenset({"normal"}))
+option_1 = OptionDescription(name="rougail", doc="rougail", children=[option_2])
+option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[option_1])

tests/dictionaries/20family_dynamic_leadership/00-base.xml

@@ -0,0 +1,19 @@
+<?xml version='1.0' encoding='UTF-8'?>
+<rougail version="0.10">
+  <variables>
+    <family name="general">
+      <variable name="varname" type="string" description="No change" multi="True">
+        <value>val1</value>
+        <value>val2</value>
+      </variable>
+    </family>
+    <family name="dyn" dynamic="varname">
+      <variable name="vardyn" type="string" description="No change"/>
+      <family name="leadership" leadership="True">
+        <variable name="leader" type="string" description="leader" multi="True"/>
+        <variable name="follower1" type="string" description="follower1"/>
+        <variable name="follower2" type="string" description="follower2"/>
+      </family>
+    </family>
+  </variables>
+</rougail>

tests/dictionaries/20family_dynamic_leadership/makedict/after.json

@@ -0,0 +1,41 @@
+{
+    "rougail.general.varname": {
+        "owner": "default",
+        "value": [
+            "val1",
+            "val2"
+        ]
+    },
+    "rougail.dynval1.vardynval1": {
+        "owner": "default",
+        "value": null
+    },
+    "rougail.dynval1.leadershipval1.leaderval1": {
+        "owner": "default",
+        "value": []
+    },
+    "rougail.dynval1.leadershipval1.follower1val1": {
+        "owner": [],
+        "value": []
+    },
+    "rougail.dynval1.leadershipval1.follower2val1": {
+        "owner": [],
+        "value": []
+    },
+    "rougail.dynval2.vardynval2": {
+        "owner": "default",
+        "value": null
+    },
+    "rougail.dynval2.leadershipval2.leaderval2": {
+        "owner": "default",
+        "value": []
+    },
+    "rougail.dynval2.leadershipval2.follower1val2": {
+        "owner": [],
+        "value": []
+    },
+    "rougail.dynval2.leadershipval2.follower2val2": {
+        "owner": [],
+        "value": []
+    }
+}

tests/dictionaries/20family_dynamic_leadership/makedict/base.json

@@ -0,0 +1,10 @@
+{
+    "rougail.general.varname": [
+        "val1",
+        "val2"
+    ],
+    "rougail.dynval1.vardynval1": null,
+    "rougail.dynval1.leadershipval1.leaderval1": [],
+    "rougail.dynval2.vardynval2": null,
+    "rougail.dynval2.leadershipval2.leaderval2": []
+}

tests/dictionaries/20family_dynamic_leadership/makedict/before.json

@@ -0,0 +1,41 @@
+{
+    "rougail.general.varname": {
+        "owner": "default",
+        "value": [
+            "val1",
+            "val2"
+        ]
+    },
+    "rougail.dynval1.vardynval1": {
+        "owner": "default",
+        "value": null
+    },
+    "rougail.dynval1.leadershipval1.leaderval1": {
+        "owner": "default",
+        "value": []
+    },
+    "rougail.dynval1.leadershipval1.follower1val1": {
+        "owner": [],
+        "value": []
+    },
+    "rougail.dynval1.leadershipval1.follower2val1": {
+        "owner": [],
+        "value": []
+    },
+    "rougail.dynval2.vardynval2": {
+        "owner": "default",
+        "value": null
+    },
+    "rougail.dynval2.leadershipval2.leaderval2": {
+        "owner": "default",
+        "value": []
+    },
+    "rougail.dynval2.leadershipval2.follower1val2": {
+        "owner": [],
+        "value": []
+    },
+    "rougail.dynval2.leadershipval2.follower2val2": {
+        "owner": [],
+        "value": []
+    }
+}

tests/dictionaries/20family_dynamic_leadership/tiramisu/base.py

@@ -0,0 +1,24 @@
+from importlib.machinery import SourceFileLoader
+from importlib.util import spec_from_loader, module_from_spec
+loader = SourceFileLoader('func', 'tests/dictionaries/../eosfunc/test.py')
+spec = spec_from_loader(loader.name, loader)
+func = module_from_spec(spec)
+loader.exec_module(func)
+for key, value in dict(locals()).items():
+    if key != ['SourceFileLoader', 'func']:
+        setattr(func, key, value)
+try:
+    from tiramisu3 import *
+except:
+    from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+option_3 = StrOption(name="varname", doc="No change", multi=True, default=['val1', 'val2'], default_multi="val1", properties=frozenset({"mandatory", "normal"}))
+option_2 = OptionDescription(name="general", doc="general", children=[option_3], properties=frozenset({"normal"}))
+option_5 = StrOption(name="vardyn", doc="No change", properties=frozenset({"normal"}))
+option_7 = StrOption(name="leader", doc="leader", multi=True)
+option_8 = StrOption(name="follower1", doc="follower1", multi=True, properties=frozenset({"normal"}))
+option_9 = StrOption(name="follower2", doc="follower2", multi=True, properties=frozenset({"normal"}))
+option_6 = Leadership(name="leadership", doc="leadership", children=[option_7, option_8, option_9], properties=frozenset({"normal"}))
+option_4 = ConvertDynOptionDescription(name="dyn", doc="dyn", suffixes=Calculation(func.calc_value, Params((ParamOption(option_3, notraisepropertyerror=True)))), children=[option_5, option_6], properties=frozenset({"normal"}))
+option_1 = OptionDescription(name="rougail", doc="rougail", children=[option_2, option_4])
+option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[option_1])

tests/dictionaries/60extra_leadership_valid_enum/00-base.xml

@@ -0,0 +1,19 @@
+<?xml version='1.0' encoding='UTF-8'?>
+<rougail version="0.10">
+  <services>
+    <service name="test">
+      <file>/etc/mailname</file>
+      <file engine="jinja2">/etc/mailname2</file>
+    </service>
+  </services>
+  <variables>
+    <family name="general" description="général">
+      <variable name="mode_conteneur_actif" type="string" description="No change" hidden="True">
+        <value>non</value>
+      </variable>
+      <variable name="activer_ejabberd" type="string" description="No change" hidden="True">
+        <value>non</value>
+      </variable>
+    </family>
+  </variables>
+</rougail>

tests/dictionaries/60extra_leadership_valid_enum/extra_dirs/extra/00-base.xml

@@ -0,0 +1,22 @@
+<?xml version='1.0' encoding='UTF-8'?>
+<rougail version="0.10">
+  <variables>
+    <family name="ejabberd">
+      <family name="description" description="description" leadership="True">
+        <variable name="description" type="string" multi="True">
+          <value>test</value>
+        </variable>
+        <variable name="mode" type="string">
+          <value>pre</value>
+        </variable>
+      </family>
+    </family>
+  </variables>
+  <constraints>
+    <check name="valid_enum">
+      <param>pre</param>
+      <param>post</param>
+      <target>extra.ejabberd.description.mode</target>
+    </check>
+  </constraints>
+</rougail>

tests/dictionaries/60extra_leadership_valid_enum/makedict/after.json

@@ -0,0 +1,48 @@
+{
+    "rougail.general.mode_conteneur_actif": {
+        "owner": "default",
+        "value": "non"
+    },
+    "rougail.general.activer_ejabberd": {
+        "owner": "default",
+        "value": "non"
+    },
+    "extra.ejabberd.description.description": {
+        "owner": "default",
+        "value": [
+            "test"
+        ]
+    },
+    "extra.ejabberd.description.mode": {
+        "owner": [
+            "default"
+        ],
+        "value": [
+            "pre"
+        ]
+    },
+    "services.test.files.mailname.name": {
+        "owner": "default",
+        "value": "/etc/mailname"
+    },
+    "services.test.files.mailname.activate": {
+        "owner": "default",
+        "value": true
+    },
+    "services.test.files.mailname2.name": {
+        "owner": "default",
+        "value": "/etc/mailname2"
+    },
+    "services.test.files.mailname2.activate": {
+        "owner": "default",
+        "value": true
+    },
+    "services.test.activate": {
+        "owner": "default",
+        "value": true
+    },
+    "services.test.manage": {
+        "owner": "default",
+        "value": true
+    }
+}

tests/dictionaries/60extra_leadership_valid_enum/makedict/base.json

@@ -0,0 +1,16 @@
+{
+    "rougail.general.mode_conteneur_actif": "non",
+    "rougail.general.activer_ejabberd": "non",
+    "extra.ejabberd.description.description": [
+        {
+            "extra.ejabberd.description.description": "test",
+            "extra.ejabberd.description.mode": "pre"
+        }
+    ],
+    "services.test.files.mailname.name": "/etc/mailname",
+    "services.test.files.mailname.activate": true,
+    "services.test.files.mailname2.name": "/etc/mailname2",
+    "services.test.files.mailname2.activate": true,
+    "services.test.activate": true,
+    "services.test.manage": true
+}

tests/dictionaries/60extra_leadership_valid_enum/makedict/before.json

@@ -0,0 +1,48 @@
+{
+    "rougail.general.mode_conteneur_actif": {
+        "owner": "default",
+        "value": "non"
+    },
+    "rougail.general.activer_ejabberd": {
+        "owner": "default",
+        "value": "non"
+    },
+    "extra.ejabberd.description.description": {
+        "owner": "default",
+        "value": [
+            "test"
+        ]
+    },
+    "extra.ejabberd.description.mode": {
+        "owner": [
+            "default"
+        ],
+        "value": [
+            "pre"
+        ]
+    },
+    "services.test.files.mailname.name": {
+        "owner": "default",
+        "value": "/etc/mailname"
+    },
+    "services.test.files.mailname.activate": {
+        "owner": "default",
+        "value": true
+    },
+    "services.test.files.mailname2.name": {
+        "owner": "default",
+        "value": "/etc/mailname2"
+    },
+    "services.test.files.mailname2.activate": {
+        "owner": "default",
+        "value": true
+    },
+    "services.test.activate": {
+        "owner": "default",
+        "value": true
+    },
+    "services.test.manage": {
+        "owner": "default",
+        "value": true
+    }
+}

tests/dictionaries/60extra_leadership_valid_enum/result/etc/mailname

@@ -0,0 +1,11 @@
+contain test
+1
+leader: test
+follower: pre
+supeq
+sup
+diff
+testpre
+pretest
+leader2: test
+follower2: pre

tests/dictionaries/60extra_leadership_valid_enum/result/etc/mailname2

@@ -0,0 +1,11 @@
+contain test
+1
+leader: test
+follower: pre
+supeq
+sup
+diff
+testpre
+pretest
+leader2: test
+follower2: pre

tests/dictionaries/60extra_leadership_valid_enum/result/tmpfiles.d/rougail.conf

@@ -0,0 +1,4 @@
+C /etc/mailname 0644 root root - /usr/local/lib/etc/mailname
+z /etc/mailname - - - - -
+C /etc/mailname2 0644 root root - /usr/local/lib/etc/mailname2
+z /etc/mailname2 - - - - -

tests/dictionaries/60extra_leadership_valid_enum/tiramisu/base.py

@@ -0,0 +1,37 @@
+from importlib.machinery import SourceFileLoader
+from importlib.util import spec_from_loader, module_from_spec
+loader = SourceFileLoader('func', 'tests/dictionaries/../eosfunc/test.py')
+spec = spec_from_loader(loader.name, loader)
+func = module_from_spec(spec)
+loader.exec_module(func)
+for key, value in dict(locals()).items():
+    if key != ['SourceFileLoader', 'func']:
+        setattr(func, key, value)
+try:
+    from tiramisu3 import *
+except:
+    from tiramisu import *
+option_3 = StrOption(name="mode_conteneur_actif", doc="No change", default="non", properties=frozenset({"force_default_on_freeze", "frozen", "hidden", "mandatory", "normal"}))
+option_4 = StrOption(name="activer_ejabberd", doc="No change", default="non", properties=frozenset({"force_default_on_freeze", "frozen", "hidden", "mandatory", "normal"}))
+option_2 = OptionDescription(name="general", doc="général", children=[option_3, option_4], properties=frozenset({"normal"}))
+option_1 = OptionDescription(name="rougail", doc="rougail", children=[option_2])
+option_8 = StrOption(name="description", doc="description", multi=True, default=['test'], properties=frozenset({"mandatory"}))
+option_9 = ChoiceOption(name="mode", doc="mode", values=('pre', 'post'), multi=True, default_multi="pre", properties=frozenset({"mandatory", "normal"}))
+option_7 = Leadership(name="description", doc="description", children=[option_8, option_9], properties=frozenset({"normal"}))
+option_6 = OptionDescription(name="ejabberd", doc="ejabberd", children=[option_7], properties=frozenset({"normal"}))
+option_5 = OptionDescription(name="extra", doc="extra", children=[option_6])
+option_14 = FilenameOption(name="name", doc="name", default="/etc/mailname")
+option_15 = BoolOption(name="activate", doc="activate", default=True)
+option_13 = OptionDescription(name="mailname", doc="mailname", children=[option_14, option_15])
+option_13.impl_set_information('source', "mailname")
+option_17 = FilenameOption(name="name", doc="name", default="/etc/mailname2")
+option_18 = BoolOption(name="activate", doc="activate", default=True)
+option_16 = OptionDescription(name="mailname2", doc="mailname2", children=[option_17, option_18])
+option_16.impl_set_information('engine', "jinja2")
+option_16.impl_set_information('source', "mailname2")
+option_12 = OptionDescription(name="files", doc="files", children=[option_13, option_16])
+option_19 = BoolOption(name="activate", doc="activate", default=True)
+option_20 = BoolOption(name="manage", doc="manage", default=True)
+option_11 = OptionDescription(name="test", doc="test", children=[option_12, option_19, option_20])
+option_10 = OptionDescription(name="services", doc="services", children=[option_11], properties=frozenset({"hidden"}))
+option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[option_1, option_5, option_10])

tests/dictionaries/60extra_leadership_valid_enum/tmpl/mailname

@@ -0,0 +1,35 @@
+%if 'test' in %%extra.ejabberd.description
+contain test
+%end if
+%%len(%%extra.ejabberd.description)
+%if 'a' in %%extra.ejabberd.description
+contain a
+%end if
+%for %%description in %%extra.ejabberd.description
+leader: %%description
+follower: %%description.mode
+%if %%description <= %%description.mode
+infeq
+%end if
+%if %%description >= %%description.mode
+supeq
+%end if
+%if %%description < %%description.mode
+inf
+%end if
+%if %%description > %%description.mode
+sup
+%end if
+%if %%description == %%description.mode
+eq
+%end if
+%if %%description != %%description.mode
+diff
+%end if
+%set %%var = %%description + %%description.mode
+%%var
+%set %%var = %%description.mode + %%description
+%%var
+%end for
+leader2: %%extra.ejabberd.description[0]
+follower2: %%extra.ejabberd.description[0].mode

tests/dictionaries/60extra_leadership_valid_enum/tmpl/mailname2

@@ -0,0 +1,33 @@
+{% if 'test' in extra.ejabberd.description -%}
+contain test
+{% endif -%}
+{{ extra.ejabberd.description|length }}
+{% if 'a' in extra.ejabberd.description -%}
+contain a
+{% endif -%}
+{% for description in extra.ejabberd.description -%}
+leader: {{ description }}
+follower: {{ description.mode }}
+{% if description <= description.mode -%}
+infeq
+{% endif -%}
+{% if description >= description.mode -%}
+supeq
+{% endif -%}
+{% if description < description.mode -%}
+inf
+{% endif -%}
+{% if description > description.mode -%}
+sup
+{% endif -%}
+{% if description == description.mode -%}
+eq
+{% endif -%}
+{% if description != description.mode -%}
+diff
+{% endif -%}
+{{ description + description.mode }}
+{{ description.mode + description }}
+{% endfor -%}
+leader2: {{ extra.ejabberd.description[0] }}
+follower2: {{ extra.ejabberd.description[0].mode }}