Merge branch 'develop' into port

Reviewed-on: #34
Co-authored-by: Emmanuel Garette <egarette@silique.fr>
Co-committed-by: Emmanuel Garette <egarette@silique.fr>

docs/fill.rst

@@ -394,6 +394,24 @@ Copy a variable in another:
         type: variable
         variable: _.my_variable
 
+Copy the default value from a variable, means copy type, params and multi attribute too if not define in second variable.
+
+.. code-block:: yaml
+
+      ---
+      version: 1.1
+      my_variable:
+        multi: true
+        type: domainname
+        params:
+          allow_ip: true
+      my_calculated_variable:
+        default:
+          type: variable
+          variable: _.var1
+
+Here my_calculated_variable is a domainname variable with parameter allow_ip=True and multi to true.
+
 Copy one variable to another if the source has no `property` problem:
 
 .. code-block:: yaml

src/rougail/__init__.py

@@ -28,7 +28,7 @@ along with this program; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 """
 from tiramisu import Config
-from copy import copy
+from warnings import warn
 
 from .convert import RougailConvert
 from .config import RougailConfig
@@ -69,7 +69,7 @@ class Rougail:
         """Add a prefix"""
         self.converted.parse_directories(path_prefix)
 
-    def get_config(self):
+    def run(self):
         """Get Tiramisu Config"""
         if not self.config:
             tiram_obj = self.converted.save(self.rougailconfig["tiramisu_cache"])
@@ -83,5 +83,9 @@ class Rougail:
             self.config.property.read_write()
         return self.config
 
+    def get_config(self):
+        warn("get_config is deprecated, use run instead", DeprecationWarning, stacklevel=2)
+        return self.run()
+
 
 __ALL__ = ("Rougail", "RougailConfig", "RougailUpgrade")

src/rougail/annotator/family.py

@@ -30,7 +30,6 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 from typing import Optional
 from rougail.i18n import _
 from rougail.error import DictConsistencyError
-from rougail.utils import get_realpath
 from rougail.annotator.variable import Walk
 from rougail.object_model import VariableCalculation
 
@@ -244,9 +243,6 @@ class Annotator(Walk):
         leader: "self.objectspace.variable",
         follower: "self.objectspace.variable",
     ) -> None:
-        if follower.auto_save is True:
-            msg = _(f'leader/followers "{follower.name}" could not be auto_save')
-            raise DictConsistencyError(msg, 29, follower.xmlfiles)
         if leader == follower:
             # it's a leader
             if not leader.mode:

src/rougail/annotator/variable.py

@@ -30,7 +30,7 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
 from rougail.i18n import _
 from rougail.error import DictConsistencyError
-from rougail.object_model import Calculation
+from rougail.object_model import Calculation, VariableCalculation
 from tiramisu.error import display_list
 
 
@@ -77,16 +77,22 @@ class Annotator(Walk):  # pylint: disable=R0903
         self.basic_types = {str: "string", int: "number", bool: "boolean", float: "float"}
         self.convert_variable()
         self.convert_test()
+        self.convert_examples()
         self.convert_help()
         self.verify_choices()
 
     def convert_variable(self):
         """convert variable"""
+        for variable in self.get_variables():
+            if variable.version != "1.0":
+                if variable.type == "symlink":
+                    continue
+                self._convert_variable_inference(variable)
         for variable in self.get_variables():
             if variable.type == "symlink":
                 continue
             if variable.version != "1.0":
-                self._convert_variable_inference(variable)
+                self._default_variable_copy_informations(variable)
             if variable.multi is None:
                 variable.multi = False
             if variable.type is None:
@@ -105,6 +111,8 @@ class Annotator(Walk):  # pylint: disable=R0903
             # choice type inference from the `choices` attribute
             if variable.choices is not None:
                 variable.type = "choice"
+            elif variable.regexp is not None:
+                variable.type = "regexp"
             elif variable.default not in [None, []]:
                 if isinstance(variable.default, list):
                     tested_value = variable.default[0]
@@ -112,12 +120,35 @@ class Annotator(Walk):  # pylint: disable=R0903
                     tested_value = variable.default
                 variable.type = self.basic_types.get(type(tested_value), None)
         # variable has no multi attribute
-        if variable.multi is None:
+        if variable.multi is None and not (variable.type is None and isinstance(variable.default, VariableCalculation)):
             if variable.path in self.objectspace.leaders:
                 variable.multi = True
             else:
                 variable.multi = isinstance(variable.default, list)
 
+    def _default_variable_copy_informations(
+            self,
+            variable,
+    ) -> None:
+        # if a variable has a variable as default value, that means the type/params or multi should has same value
+        if variable.type is not None or not isinstance(variable.default, VariableCalculation):
+            return
+        # copy type and params
+        calculated_variable_path = variable.default.variable
+        calculated_variable, suffix = self.objectspace.paths.get_with_dynamic(
+            calculated_variable_path, variable.default.path_prefix, variable.path, variable.version, variable.namespace, variable.xmlfiles
+        )
+        variable.type = calculated_variable.type
+        if variable.params is None and calculated_variable.params is not None:
+            variable.params = calculated_variable.params
+        # copy multi attribut
+        if variable.multi is None:
+            calculated_path = calculated_variable.path
+            if calculated_path in self.objectspace.leaders and variable.path in self.objectspace.followers and calculated_path.rsplit('.')[0] == variable.path.rsplit('.')[0]:
+                variable.multi = False
+            else:
+                variable.multi = calculated_variable.multi
+
     def _convert_variable(
         self,
         variable: dict,
@@ -143,8 +174,11 @@ class Annotator(Walk):  # pylint: disable=R0903
                 variable.hidden = family.hidden
             variable.hidden = None
         if variable.choices is not None and variable.type != 'choice':
-            msg = _(f'the variable "{variable.path}" has choice attribut but has not the "choice" type')
+            msg = _(f'the variable "{variable.path}" has choices attribut but has not the "choice" type')
             raise DictConsistencyError(msg, 11, variable.xmlfiles)
+        if variable.regexp is not None and variable.type != 'regexp':
+            msg = _(f'the variable "{variable.path}" has regexp attribut but has not the "regexp" type')
+            raise DictConsistencyError(msg, 37, variable.xmlfiles)
 
     def convert_test(self):
         """Convert variable tests value"""
@@ -152,12 +186,22 @@ class Annotator(Walk):  # pylint: disable=R0903
             if variable.type == "symlink":
                 continue
             if variable.test is None:
-                # with we want remove test, we set "" has test value
                 continue
             self.objectspace.informations.add(
                 variable.path, "test", tuple(variable.test)
             )
 
+    def convert_examples(self):
+        """Convert variable tests value"""
+        for variable in self.get_variables():
+            if variable.type == "symlink":
+                continue
+            if variable.examples is None:
+                continue
+            self.objectspace.informations.add(
+                variable.path, "examples", tuple(variable.examples)
+            )
+
     def convert_help(self):
         """Convert variable help"""
         for variable in self.get_variables():

src/rougail/config.py

@@ -131,11 +131,41 @@ class _RougailConfig:
     def get_leadership(self,
                        option
                        ) -> dict:
-        leader, *followers = option.value.get().values()
+        leader = None
+        followers = []
+        for opt, value in option.value.get().items():
+            if opt.issymlinkoption():
+                continue
+            if leader is None:
+                leader = value
+            else:
+                followers.append(value)
         return dict(zip(leader, followers))
 
+    def parse(self, config) -> str:
+        for option in config:
+            if option.isoptiondescription():
+                yield from self.parse(option)
+            elif not option.issymlinkoption():
+                yield f'{option.path()}: {option.value.get()}'
+
+    def __repr__(self):
+        self.config.property.read_write()
+        try:
+            values = "\n".join(self.parse(self.config))
+        except Exception as err:
+            values = str(err)
+        self.config.property.read_only()
+        return values
+
 
 class FakeRougailConvert(RougailConvert):
+    def __init__(self,
+                 add_extra_options: bool,
+                 ) -> None:
+        self.add_extra_options = add_extra_options
+        super().__init__({})
+
     def load_config(self,
                     rougailconfig: 'RougailConfig',
                     ) -> None:
@@ -149,10 +179,12 @@ class FakeRougailConvert(RougailConvert):
         self.export_with_import = True
         self.internal_functions = []
         self.plugins = ['structural_commandline']
+        self.add_extra_options = self.add_extra_options
 
 
 def get_rougail_config(*,
-                       backward_compatibility=True,
+                       backward_compatibility: bool=True,
+                       add_extra_options: bool=True,
                        ) -> _RougailConfig:
     if backward_compatibility:
         main_namespace_default = 'rougail'
@@ -178,25 +210,22 @@ main_dictionaries:
 main_namespace:
   description: Main namespace name
   default: MAIN_MAMESPACE_DEFAULT
-  alternative_name: n
+  alternative_name: s
   mandatory: false
 extra_dictionaries:
   description: Extra namespaces
   type: leadership
   disabled:
-    type: jinja
-    jinja: |
-      {% if not main_namespace %}
-      main_namespace not available
-      {% endif %}
+    variable: main_namespace
+    when: null
   names:
     description: 'Extra namespace name'
-#    alternative_name: e
+    alternative_name: xn
     multi: true
     mandatory: false
   directories:
     description: Directories where extra dictionary files are placed
-#    alternative_name: d
+    alternative_name: xd
     type: unix_filename
     params:
       allow_relative: true
@@ -206,7 +235,7 @@ extra_dictionaries:
     multi: true
 functions_files:
   description: File with functions
-  alternative_name: f
+  alternative_name: c
   type: unix_filename
   params:
     allow_relative: true
@@ -279,9 +308,9 @@ suffix:
   mandatory: false
   commandline: false
 """.replace('MAIN_MAMESPACE_DEFAULT', main_namespace_default)
-    processes = {'output': [],
+    processes = {'structural': [],
+                 'output': [],
                  'user data': [],
-                 # 'structural': [],
                  }
     for module in get_sub_modules().values():
         data = module.get_rougail_config()
@@ -302,7 +331,9 @@ suffix:
            )
             for obj in objects:
                 rougail_process += f"      - {obj['name']}\n"
-            if process == 'user data':
+            if process == 'structural':
+                rougail_process += "    commandline: false"
+            elif process == 'user data':
                 rougail_process += """    multi: true
     mandatory: false
 """
@@ -324,10 +355,12 @@ suffix:
   {NAME}:
     description: Select for {NAME}
     hidden: true
+    mandatory: false
+    multi: true
 """.format(NAME=normalize_family(process),
            )
     rougail_options += rougail_process
-    convert = FakeRougailConvert({})
+    convert = FakeRougailConvert(add_extra_options)
     convert._init()
     convert.namespace = None
     convert.parse_root_file(

src/rougail/convert.py

@@ -317,6 +317,7 @@ class Informations:
 class ParserVariable:
     def __init__(self, rougailconfig):
         self.load_config(rougailconfig)
+        self.rougailconfig = rougailconfig
         self.paths = Paths(self.main_namespace)
         self.families = []
         self.variables = []
@@ -332,9 +333,6 @@ class ParserVariable:
         self.convert_options = list(CONVERT_OPTION)
         self.convert_options.extend(self.custom_types)
         #
-        self.family = Family
-        self.dynamic = Dynamic
-        #
         self.exclude_imports = []
         self.informations = Informations()
         self.properties = Property()
@@ -363,12 +361,14 @@ class ParserVariable:
         self.base_option_name = rougailconfig["base_option_name"]
         self.export_with_import = rougailconfig["export_with_import"]
         self.internal_functions = rougailconfig["internal_functions"]
+        self.add_extra_options = rougailconfig["structural_commandline.add_extra_options"]
         self.plugins = []
 
     def _init(self):
         if self.is_init:
             return
         variable = Variable
+        family = Family
         if self.plugins:
             root = Path(__file__).parent
             for plugin in self.plugins:
@@ -376,13 +376,15 @@ class ParserVariable:
                 if not module_path.is_file():
                     continue
                 module = load_modules(f'rougail.{plugin}.object_model', str(module_path))
-                if 'Variable' not in module.__all__:
-                    continue
-                variable = type(variable.__name__ + '_' + plugin, (Variable, module.Variable), {})
+                if 'Variable' in module.__all__:
+                    variable = type(variable.__name__ + '_' + plugin, (variable, module.Variable), {})
+                if 'Family' in module.__all__:
+                    family = type(family.__name__ + '_' + plugin, (family, module.Family), {})
         self.variable = variable
+        self.family = family
+        self.dynamic = type(Dynamic.__name__, (Dynamic, family), {})
         hint = get_type_hints(self.dynamic)
         # FIXME: only for format 1.0
-        hint["variable"] = str
         self.family_types = hint["type"].__args__  # pylint: disable=W0201
         self.family_attrs = frozenset(  # pylint: disable=W0201
             set(hint) - {"name", "path", "xmlfiles"} | {"redefine"}
@@ -588,7 +590,18 @@ class ParserVariable:
             extra_attrs = set(family_obj) - self.family_attrs
             if extra_attrs:
                 raise Exception(f"extra attrs ... {extra_attrs}")
-            if self.get_family_or_variable_type(family_obj) == "dynamic":
+            obj_type = self.get_family_or_variable_type(family_obj)
+            if obj_type is None:
+                # auto set type
+                if '_dynamic' in family_obj:
+                    dynamic = family_obj['_dynamic']
+                elif 'dynamic' in family_obj:
+                    dynamic = family_obj['dynamic']
+                else:
+                    dynamic = None
+                if isinstance(dynamic, (list, dict)):
+                    family_obj['type'] = obj_type = 'dynamic'
+            if obj_type == "dynamic":
                 family_is_dynamic = True
                 parent_dynamic = path
                 if '{{ suffix }}' not in name:
@@ -997,11 +1010,16 @@ class ParserVariable:
             calculations = calculations[0]
         else:
             calculations = calculations[1]
-        return (
-            attribute in calculations
-            and isinstance(value, dict)
-            and value.get("type") in CALCULATION_TYPES
-        )
+        if not isinstance(value, dict) or attribute not in calculations:
+            return False
+        if 'type' in value:
+            return value['type'] in CALCULATION_TYPES
+        # auto set type
+        typ = set(CALCULATION_TYPES) & set(value)
+        if len(typ) == 1:
+            value['type'] = list(typ)[0]
+            return True
+        return False
 
     def set_calculation(
         self,
@@ -1034,6 +1052,11 @@ class ParserVariable:
                 raise Exception("params must be a dict")
             params = []
             for key, val in calculation_object["params"].items():
+                if isinstance(val, dict) and "type" not in val:
+                    # auto set type
+                    param_typ = set(CALCULATION_TYPES) & set(val)
+                    if len(param_typ) == 1:
+                        val['type'] = list(param_typ)[0]
                 if not isinstance(val, dict) or "type" not in val:
                     param_typ = "any"
                     val = {
@@ -1212,6 +1235,8 @@ class RougailConvert(ParserVariable):
             objects,
             filename,
         )
+        if objects is None:
+            return
         self.parse_root_file(filename,
                              path,
                              version,
@@ -1266,6 +1291,8 @@ class RougailConvert(ParserVariable):
         filename: str,
     ) -> None:
         """version is mandatory in YAML file"""
+        if obj is None:
+            obj = {}
         for name in ["_version", "version"]:
             if name not in obj:
                 continue

src/rougail/error.py

@@ -79,3 +79,15 @@ class UpgradeError(Exception):
 class NotFoundError(Exception):
     "not found error"
     pass
+    
+## ---- specific exceptions ----
+
+class VariableCalculationDependencyError(Exception):
+    """When an attribute is set, and 
+    the target of this attribute doesn't exists.
+    """
+    def __init__(self, msg, errno, xmlfiles):
+        if xmlfiles:
+            msg = _(f"{msg} in {display_xmlfiles(xmlfiles)}")
+        super().__init__(msg)
+        self.errno = errno

src/rougail/object_model.py

@@ -31,7 +31,7 @@ from pydantic import (
 )
 from tiramisu import undefined
 from .utils import get_jinja_variable_to_param, get_realpath
-from .error import DictConsistencyError
+from .error import DictConsistencyError, VariableCalculationDependencyError
 
 BASETYPE = Union[StrictBool, StrictInt, StrictFloat, StrictStr, None]
 PROPERTY_ATTRIBUTE = ["frozen", "hidden", "disabled", "mandatory"]
@@ -46,7 +46,7 @@ def convert_boolean(value: str) -> bool:
         return True
     elif value == "false":
         return False
-    elif value in ['', None]:
+    elif value in ["", None]:
         return None
     raise Exception(f'unknown boolean value "{value}"')
 
@@ -61,36 +61,48 @@ CONVERT_OPTION = {
     "unix_filename": dict(opttype="FilenameOption", example="/tmp/myfile.txt"),
     "date": dict(opttype="DateOption", example="2000-01-01"),
     "unix_user": dict(opttype="UsernameOption", example="username"),
-    "ip": dict(opttype="IPOption", initkwargs={"allow_reserved": True}, example="1.1.1.1"),
+    "ip": dict(
+        opttype="IPOption", initkwargs={"allow_reserved": True}, example="1.1.1.1"
+    ),
     "cidr": dict(opttype="IPOption", initkwargs={"cidr": True}, example="1.1.1.0/24"),
     "netmask": dict(opttype="NetmaskOption", example="255.255.255.0"),
     "network": dict(opttype="NetworkOption", example="1.1.1.0"),
-    "network_cidr": dict(opttype="NetworkOption", initkwargs={"cidr": True}, example="1.1.1.0/24"),
+    "network_cidr": dict(
+        opttype="NetworkOption", initkwargs={"cidr": True}, example="1.1.1.0/24"
+    ),
     "broadcast": dict(opttype="BroadcastOption", example="1.1.1.255"),
     "netbios": dict(
         opttype="DomainnameOption",
         initkwargs={"type": "netbios", "warnings_only": True},
-        example="example"
+        example="example",
     ),
     "domainname": dict(
-        opttype="DomainnameOption", initkwargs={"type": "domainname", "allow_ip": False},
-        example="example.net"
+        opttype="DomainnameOption",
+        initkwargs={"type": "domainname", "allow_ip": False},
+        example="example.net",
     ),
     "hostname": dict(
-        opttype="DomainnameOption", initkwargs={"type": "hostname", "allow_ip": False},
-        example="example"
+        opttype="DomainnameOption",
+        initkwargs={"type": "hostname", "allow_ip": False},
+        example="example",
     ),
     "web_address": dict(
-        opttype="URLOption", initkwargs={"allow_ip": False, "allow_without_dot": True},
-        example="https://example.net"
+        opttype="URLOption",
+        initkwargs={"allow_ip": False, "allow_without_dot": True},
+        example="https://example.net",
+    ),
+    "port": dict(
+        opttype="PortOption", initkwargs={"allow_private": True}, example="111"
     ),
-    "port": dict(opttype="PortOption", initkwargs={"allow_private": True}, example="111"),
     "mac": dict(opttype="MACOption", example="00:00:00:00:00"),
     "unix_permissions": dict(
-        opttype="PermissionsOption", initkwargs={"warnings_only": True}, func=int,
-        example="644"
+        opttype="PermissionsOption",
+        initkwargs={"warnings_only": True},
+        func=int,
+        example="644",
     ),
     "choice": dict(opttype="ChoiceOption", example="a_choice"),
+    "regexp": dict(opttype="RegexpOption"),
     #
     "symlink": dict(opttype="SymLinkOption"),
 }
@@ -100,7 +112,8 @@ class Param(BaseModel):
     key: str
     model_config = ConfigDict(extra="forbid")
 
-    def __init__(self,
+    def __init__(
+        self,
         path,
         attribute,
         family_is_dynamic,
@@ -120,6 +133,7 @@ class VariableParam(Param):
     type: str
     variable: str
     propertyerror: bool = True
+    whole: bool = False
     optional: bool = False
 
 
@@ -127,12 +141,13 @@ class SuffixParam(Param):
     type: str
     suffix: Optional[int] = None
 
-    def __init__(self,
+    def __init__(
+        self,
         **kwargs,
     ) -> None:
-        if not kwargs['family_is_dynamic']:
+        if not kwargs["family_is_dynamic"]:
             msg = f'suffix parameter for "{kwargs["attribute"]}" in "{kwargs["path"]}" cannot be set none dynamic family'
-            raise DictConsistencyError(msg, 10, kwargs['xmlfiles'])
+            raise DictConsistencyError(msg, 10, kwargs["xmlfiles"])
         super().__init__(**kwargs)
 
 
@@ -145,17 +160,17 @@ class InformationParam(Param):
 class IndexParam(Param):
     type: str
 
-    def __init__(self,
+    def __init__(
+        self,
         **kwargs,
     ) -> None:
 
         if not kwargs["is_follower"]:
             msg = f'the variable "{kwargs["path"]}" is not a follower, so cannot have index type for param in "{kwargs["attribute"]}"'
-            raise DictConsistencyError(msg, 25, kwargs['xmlfiles'])
+            raise DictConsistencyError(msg, 25, kwargs["xmlfiles"])
         super().__init__(**kwargs)
 
 
-
 PARAM_TYPES = {
     "any": AnyParam,
     "variable": VariableParam,
@@ -195,7 +210,12 @@ class Calculation(BaseModel):
                 else:
                     path = self.ori_path
                 variable, suffix = objectspace.paths.get_with_dynamic(
-                    param["variable"], self.path_prefix, path, self.version, self.namespace, self.xmlfiles
+                    param["variable"],
+                    self.path_prefix,
+                    path,
+                    self.version,
+                    self.namespace,
+                    self.xmlfiles,
                 )
                 if not variable:
                     if not param.get("optional"):
@@ -214,7 +234,12 @@ class Calculation(BaseModel):
                     else:
                         path = self.ori_path
                     variable, suffix = objectspace.paths.get_with_dynamic(
-                        param["variable"], self.path_prefix, path, self.version, self.namespace, self.xmlfiles
+                        param["variable"],
+                        self.path_prefix,
+                        path,
+                        self.version,
+                        self.namespace,
+                        self.xmlfiles,
                     )
                     if not variable:
                         msg = f'cannot find variable "{param["variable"]}" defined in "{self.attribute_name}" for "{self.path}"'
@@ -231,7 +256,14 @@ class Calculation(BaseModel):
 
 class JinjaCalculation(Calculation):
     attribute_name: Literal[
-        "frozen", "hidden", "mandatory", "disabled", "default", "validators", "choices", "dynamic"
+        "frozen",
+        "hidden",
+        "mandatory",
+        "disabled",
+        "default",
+        "validators",
+        "choices",
+        "dynamic",
     ]
     jinja: StrictStr
     params: Optional[List[Param]] = None
@@ -264,7 +296,7 @@ class JinjaCalculation(Calculation):
             },
         }
         if self.default_values:
-            default["params"]['__default_value'] = self.default_values
+            default["params"]["__default_value"] = self.default_values
         if add_help:
             default["help"] = function + "_help"
         if self.params:
@@ -340,7 +372,7 @@ class JinjaCalculation(Calculation):
                 False,
                 objectspace,
                 add_help=True,
-                params={None: [self.attribute_name], 'when': True, 'inverse': False},
+                params={None: [self.attribute_name], "when": True, "inverse": False},
             )
         elif self.attribute_name == "choices":
             return_type = self.return_type
@@ -362,31 +394,42 @@ class JinjaCalculation(Calculation):
         raise Exception("hu?")
 
 
-class VariableCalculation(Calculation):
-    attribute_name: Literal[
-        "default", "choices", "dynamic"
-    ]
+class _VariableCalculation(Calculation):
     variable: StrictStr
     propertyerror: bool = True
     allow_none: bool = False
 
-    def get_params(self,
+    def get_variable(self,
                      objectspace,
-                   needs_multi: Optional[bool] = None,
-                   ):
+                     ) -> "Variable":
         if self.ori_path is None:
             path = self.path
         else:
             path = self.ori_path
         variable, suffix = objectspace.paths.get_with_dynamic(
-            self.variable, self.path_prefix, path, self.version, self.namespace, self.xmlfiles
+            self.variable,
+            self.path_prefix,
+            path,
+            self.version,
+            self.namespace,
+            self.xmlfiles,
         )
+        if variable and not isinstance(variable, objectspace.variable):
+            # FIXME remove the pfff
+            raise Exception("pfff it's a family")
+        return variable, suffix
+
+    def get_params(
+        self,
+        objectspace,
+        variable: "Variable",
+        suffix: Optional[str],
+        *,
+        needs_multi: Optional[bool] = None,
+    ):
         if not variable:
             msg = f'Variable not found "{self.variable}" for attribut "{self.attribute_name}" for variable "{self.path}"'
             raise DictConsistencyError(msg, 88, self.xmlfiles)
-        if not isinstance(variable, objectspace.variable):
-            # FIXME remove the pfff
-            raise Exception("pfff it's a family")
         param = {
             "type": "variable",
             "variable": variable,
@@ -396,7 +439,7 @@ class VariableCalculation(Calculation):
             param["suffix"] = suffix
         params = {None: [param]}
         if self.default_values:
-            params['__default_value'] = self.default_values
+            params["__default_value"] = self.default_values
         if self.allow_none:
             params["allow_none"] = True
         if needs_multi is None:
@@ -406,11 +449,15 @@ class VariableCalculation(Calculation):
                 needs_multi = self.path in objectspace.multis
         calc_variable_is_multi = variable.path in objectspace.multis
         if not calc_variable_is_multi:
-            if variable.path in objectspace.paths._dynamics and (suffix is None or suffix[-1] is None):
+            if variable.path in objectspace.paths._dynamics and (
+                suffix is None or suffix[-1] is None
+            ):
                 self_dyn_path = objectspace.paths._dynamics.get(self.path)
                 if self_dyn_path is not None:
                     var_dyn_path = objectspace.paths._dynamics[variable.path]
-                    if self_dyn_path != var_dyn_path and not self_dyn_path.startswith(f'{var_dyn_path}.'):
+                    if self_dyn_path != var_dyn_path and not self_dyn_path.startswith(
+                        f"{var_dyn_path}."
+                    ):
                         calc_variable_is_multi = True
                 else:
                     calc_variable_is_multi = True
@@ -430,18 +477,33 @@ class VariableCalculation(Calculation):
             raise DictConsistencyError(msg, 21, self.xmlfiles)
         return params
 
+
+class VariableCalculation(_VariableCalculation):
+    attribute_name: Literal["default", "choices", "dynamic"]
+    optional: bool = False
+
     def to_function(
         self,
         objectspace,
     ) -> dict:
-        params = self.get_params(objectspace)
+        if self.attribute_name != "default" and self.optional is True:
+            msg = f'"{self.attribute_name}" variable shall not have an "optional" attribute for variable "{self.variable}"'
+            raise DictConsistencyError(msg, 33, self.xmlfiles)
+        variable, suffix = self.get_variable(objectspace)
+        if not variable and self.optional:
+            msg = f'the dependent variable was not found "{self.optional}" for attribute "{self.attribute_name}" in variable "{self.path}"'
+            raise VariableCalculationDependencyError(msg, 90, self.xmlfiles)
+        params = self.get_params(objectspace,
+                                 variable,
+                                 suffix,
+                                 )
         return {
             "function": "calc_value",
             "params": params,
         }
 
 
-class VariablePropertyCalculation(VariableCalculation):
+class VariablePropertyCalculation(_VariableCalculation):
     attribute_name: Literal[*PROPERTY_ATTRIBUTE]
     when: Any = undefined
     when_not: Any = undefined
@@ -450,10 +512,14 @@ class VariablePropertyCalculation(VariableCalculation):
         self,
         objectspace,
     ) -> dict:
-        params = self.get_params(objectspace, False)
+        variable, suffix = self.get_variable(objectspace)
+        params = self.get_params(objectspace,
+                                 variable,
+                                 suffix,
+                                 needs_multi=False,)
         variable = params[None][0]["variable"]
         if self.when is not undefined:
-            if self.version == '1.0':
+            if self.version == "1.0":
                 msg = f'when is not allowed in format version 1.0 for attribute "{self.attribute_name}" for variable "{self.path}"'
                 raise DictConsistencyError(msg, 103, variable.xmlfiles)
             if self.when_not is not undefined:
@@ -462,7 +528,7 @@ class VariablePropertyCalculation(VariableCalculation):
             when = self.when
             inverse = False
         elif self.when_not is not undefined:
-            if self.version == '1.0':
+            if self.version == "1.0":
                 msg = f'when_not is not allowed in format version 1.0 for attribute "{self.attribute_name}" for variable "{self.path}"'
                 raise DictConsistencyError(msg, 104, variable.xmlfiles)
             when = self.when_not
@@ -473,9 +539,10 @@ class VariablePropertyCalculation(VariableCalculation):
             when = True
             inverse = False
         params[None].insert(0, self.attribute_name)
-        params['when'] = when
-        params['inverse'] = inverse
-        return {"function": "variable_to_property",
+        params["when"] = when
+        params["inverse"] = inverse
+        return {
+            "function": "variable_to_property",
             "params": params,
             "help": "variable_to_property",
         }
@@ -490,10 +557,13 @@ class InformationCalculation(Calculation):
         self,
         objectspace,
     ) -> dict:
-        params = {None: [{
+        params = {
+            None: [
+                {
                     "type": "information",
                     "information": self.information,
-            }]
+                }
+            ]
         }
         if self.variable:
             if self.ori_path is None:
@@ -501,33 +571,79 @@ class InformationCalculation(Calculation):
             else:
                 path = self.ori_path
             variable, suffix = objectspace.paths.get_with_dynamic(
-                self.variable, self.path_prefix, path, self.version, self.namespace, self.xmlfiles
+                self.variable,
+                self.path_prefix,
+                path,
+                self.version,
+                self.namespace,
+                self.xmlfiles,
             )
             if variable is None or suffix is not None:
                 raise Exception("pfff")
             params[None][0]["variable"] = variable
         if self.default_values:
-            params['__default_value'] = self.default_values
+            params["__default_value"] = self.default_values
         return {
             "function": "calc_value",
             "params": params,
         }
 
 
-class SuffixCalculation(Calculation):
-    attribute_name: Literal["default", "choice", "dynamic"]
+class _SuffixCalculation(Calculation):
     suffix: Optional[int] = None
 
+    def get_suffix(self) -> dict:
+        suffix = {"type": "suffix"}
+        if self.suffix is not None:
+            suffix["suffix"] = self.suffix
+        return suffix
+
+
+class SuffixCalculation(_SuffixCalculation):
+    attribute_name: Literal["default", "choice", "dynamic"]
+
     def to_function(
         self,
         objectspace,
     ) -> dict:
-        suffix = {"type": "suffix"}
-        if self.suffix is not None:
-            suffix['suffix'] = self.suffix
         return {
             "function": "calc_value",
-            "params": {None: [suffix]},
+            "params": {None: [self.get_suffix()]},
+        }
+
+
+class SuffixPropertyCalculation(_SuffixCalculation):
+    attribute_name: Literal[*PROPERTY_ATTRIBUTE]
+    when: Any = undefined
+    when_not: Any = undefined
+
+    def to_function(
+        self,
+        objectspace,
+    ) -> dict:
+        if self.version == "1.0":
+            msg = f'when is not allowed in format version 1.0 for attribute "{self.attribute_name}"'
+            raise DictConsistencyError(msg, 105, variable.xmlfiles)
+        if self.when is not undefined:
+            if self.when_not is not undefined:
+                msg = f'the suffix has an invalid attribute "{self.attribute_name}", when and when_not cannot set together'
+                raise DictConsistencyError(msg, 35, variable.xmlfiles)
+            when = self.when
+            inverse = False
+        elif self.when_not is not undefined:
+            when = self.when_not
+            inverse = True
+        else:
+            msg = f'the suffix has an invalid attribute "{self.attribute_name}", when and when_not cannot set together'
+            raise DictConsistencyError
+        params = {None: [self.attribute_name, self.get_suffix()],
+                  "when": when,
+                  "inverse": inverse,
+                  }
+        return {
+            "function": "variable_to_property",
+            "params": params,
+            "help": "variable_to_property",
         }
 
 
@@ -558,7 +674,7 @@ CALCULATION_PROPERTY_TYPES = {
     "jinja": JinjaCalculation,
     "variable": VariablePropertyCalculation,
     "information": InformationCalculation,
-    "suffix": SuffixCalculation,
+    "suffix": SuffixPropertyCalculation,
     "index": IndexCalculation,
 }
 BASETYPE_CALC = Union[StrictBool, StrictInt, StrictFloat, StrictStr, Calculation, None]
@@ -593,6 +709,7 @@ class Variable(BaseModel):
     description: Optional[str] = None
     default: Union[List[BASETYPE_CALC], BASETYPE_CALC] = None
     choices: Optional[Union[List[BASETYPE_CALC], Calculation]] = None
+    regexp: Optional[str] = None
     params: Optional[List[Param]] = None
     validators: Optional[List[Calculation]] = None
     multi: Optional[bool] = None
@@ -604,6 +721,7 @@ class Variable(BaseModel):
     auto_save: bool = False
     mode: Optional[str] = None
     test: Optional[list] = None
+    examples: Optional[list] = None
     path: str
     namespace: Optional[str]
     version: str
@@ -612,11 +730,6 @@ class Variable(BaseModel):
     model_config = ConfigDict(extra="forbid", arbitrary_types_allowed=True)
 
 
-#class Choice(Variable):
-#    type: Literal["choice"] = "choice"
-#    choices: Union[List[BASETYPE_CALC], Calculation]
-
-
 class SymLink(BaseModel):
     type: Literal["symlink"] = "symlink"
     name: str

src/rougail/structural_commandline/annotator.py

@@ -20,34 +20,70 @@ along with this program; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 """
 from rougail.annotator.variable import Walk
+from rougail.utils import _
+from rougail.error import DictConsistencyError
 
 class Annotator(Walk):
     """Annotate value"""
-    level = 5
+    level = 80
 
     def __init__(self, objectspace, *args) -> None:
         if not objectspace.paths:
             return
+        self.alternative_names = {}
         self.objectspace = objectspace
-        self.manage_alternative_name()
-        self.not_for_commandline()
-
-    def manage_alternative_name(self) -> None:
+        not_for_commandlines = []
+        for family in self.get_families():
+            if family.commandline:
+                continue
+            self.not_for_commandline(family)
+            not_for_commandlines.append(family.path + '.')
         for variable in self.get_variables():
             if variable.type == 'symlink':
                 continue
+            variable_path = variable.path
+            for family_path in not_for_commandlines:
+                if variable_path.startswith(family_path):
+                    break
+            else:
+                if not variable.commandline:
+                    self.not_for_commandline(variable)
+                else:
+                    self.manage_alternative_name(variable)
+                    self.manage_negative_description(variable)
+
+    def not_for_commandline(self, variable) -> None:
+        self.objectspace.properties.add(variable.path, 'not_for_commandline', True)
+
+    def manage_alternative_name(self, variable) -> None:
         if not variable.alternative_name:
-                continue
+            return
         alternative_name = variable.alternative_name
         variable_path = variable.path
+        all_letters = ''
+        for letter in alternative_name:
+            all_letters += letter
+            if all_letters == 'h':
+                msg = _(f'alternative_name "{alternative_name}" conflict with "--help"')
+                raise DictConsistencyError(msg, 202, variable.xmlfiles)
+            if all_letters in self.alternative_names:
+                msg = _(f'conflict alternative_name "{alternative_name}": "{variable_path}" and "{self.alternative_names[all_letters]}"')
+                raise DictConsistencyError(msg, 202, variable.xmlfiles)
+
+        self.alternative_names[alternative_name] = variable_path
         if '.' not in variable_path:
             path = alternative_name
         else:
             path = variable_path.rsplit('.', 1)[0] + '.' + alternative_name
         self.objectspace.add_variable(alternative_name, {'type': 'symlink', 'path': path, 'opt': variable}, variable.xmlfiles, False, False, variable.version)
 
-    def not_for_commandline(self) -> None:
-        for variable in self.get_variables():
-            if not hasattr(variable, 'commandline') or variable.commandline:
-                continue
-            self.objectspace.properties.add(variable.path, 'not_for_commandline', True)
+    def manage_negative_description(self, variable) -> None:
+        if not variable.negative_description:
+            if variable.type == 'boolean' and not self.objectspace.add_extra_options:
+                raise DictConsistencyError(_(f'negative_description is mandatory for boolean variable, but "{variable.path}" hasn\'t'), 200, variable.xmlfiles)
+            return
+        if variable.type != 'boolean':
+            raise DictConsistencyError(_(f'negative_description is only available for boolean variable, but "{variable.path}" is "{variable.type}"'), 201, variable.xmlfiles)
+        self.objectspace.informations.add(
+            variable.path, "negative_description", variable.negative_description
+        )

src/rougail/structural_commandline/config.py

@@ -0,0 +1,42 @@
+"""
+Config file for Rougail-structural_commandline
+
+Silique (https://www.silique.fr)
+Copyright (C) 2024
+
+distribued with GPL-2 or later license
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+"""
+def get_rougail_config(*,
+                       backward_compatibility=True,
+                       ) -> dict:
+    options = """
+structural_commandline:
+  description: Configuration rougail-structural_commandline
+  commandline: false
+  add_extra_options:
+    description: Add extra options to tiramisu-cmdline-parser
+    default: true
+"""
+    return {'name': 'exporter',
+            'process': 'structural',
+            'options': options,
+            'level': 20,
+            }
+
+
+__all__ = ('get_rougail_config')
+

src/rougail/structural_commandline/object_model.py

@@ -26,6 +26,11 @@ from pydantic import BaseModel
 class Variable(BaseModel):
     alternative_name: Optional[str]=None
     commandline: bool=True
+    negative_description: Optional[str]=None
 
 
-__all__ = ('Variable',)
+class Family(BaseModel):
+    commandline: bool=True
+
+
+__all__ = ('Variable', 'Family')

src/rougail/tiramisu.py

@@ -41,10 +41,9 @@ from .utils import normalize_family
 
 
 global func
-func = {}
 dict_env = {}
 ENV = SandboxedEnvironment(loader=DictLoader(dict_env), undefined=StrictUndefined)
-ENV.filters = func
+func = ENV.filters
 ENV.compile_templates('jinja_caches', zip=None)
 
 

src/rougail/tiramisureflector.py

@@ -33,7 +33,7 @@ from json import dumps
 from os.path import isfile, basename
 
 from .i18n import _
-from .error import DictConsistencyError
+from .error import DictConsistencyError, VariableCalculationDependencyError
 from .utils import normalize_family
 from .object_model import Calculation, CONVERT_OPTION
 
@@ -74,11 +74,14 @@ class TiramisuReflector:
                 [
                     "from tiramisu import *",
                     "from tiramisu.setting import ALLOWED_LEADER_PROPERTIES",
+                    "from re import compile as re_compile",
                 ]
             )
         if self.objectspace.export_with_import:
             self.text["header"].extend(
-                ["from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription"]
+                [
+                    "from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription"
+                ]
             )
         if funcs_paths:
             for funcs_path in sorted(funcs_paths, key=sorted_func_name):
@@ -105,7 +108,7 @@ class TiramisuReflector:
         baseelt = BaseElt()
         self.objectspace.reflector_names[
             baseelt.path
-        ] = f'option_0{self.objectspace.suffix}'
+        ] = f"option_0{self.objectspace.suffix}"
         basefamily = Family(
             baseelt,
             self,
@@ -201,7 +204,9 @@ class Common:
             self.populate_attrib()
             if self.informations:
                 for information in self.informations:
-                    self.tiramisu.text['option'].append(f'{information}.set_option({self.option_name})')
+                    self.tiramisu.text["option"].append(
+                        f"{information}.set_option({self.option_name})"
+                    )
         return self.option_name
 
     def populate_attrib(self):
@@ -275,7 +280,7 @@ class Common:
         informations = self.objectspace.informations.get(self.elt.path)
         if not informations:
             return
-        keys['informations'] = informations
+        keys["informations"] = informations
 
     def populate_param(
         self,
@@ -299,14 +304,20 @@ class Common:
                 if param["variable"].path == self.elt.path:
                     return f'ParamSelfInformation("{param["information"]}", {default})'
                 information_variable_path = param["variable"].path
-                information_variable = self.tiramisu.reflector_objects[information_variable_path]
+                information_variable = self.tiramisu.reflector_objects[
+                    information_variable_path
+                ]
                 if information_variable_path not in self.calls:
                     option_name = information_variable.get(self.calls, self.elt.path)
                     return f'ParamInformation("{param["information"]}", {default}, option={option_name})'
                 else:
-                    information = f'ParamInformation("{param["information"]}", {default})'
+                    information = (
+                        f'ParamInformation("{param["information"]}", {default})'
+                    )
                     information_name = self.tiramisu.get_information_name()
-                    self.tiramisu.text["option"].append(f'{information_name} = {information}')
+                    self.tiramisu.text["option"].append(
+                        f"{information_name} = {information}"
+                    )
                     information_variable.informations.append(information_name)
                     return information_name
             return f'ParamInformation("{param["information"]}", {default})'
@@ -322,6 +333,7 @@ class Common:
                 param.get("propertyerror", True),
                 param.get("suffix"),
                 param.get("dynamic"),
+                param.get('whole', False),
             )
         if param["type"] == "any":
             if isinstance(param["value"], str):
@@ -333,15 +345,19 @@ class Common:
 
     def build_option_param(
         self,
-        param,
+        variable,
         propertyerror,
         suffix: Optional[str],
         dynamic,
+        whole: bool,
     ) -> str:
         """build variable parameters"""
-        if param.path == self.elt.path:
-            return "ParamSelfOption(whole=False)"
-        option_name = self.tiramisu.reflector_objects[param.path].get(
+        if variable.path == self.elt.path:
+            return f"ParamSelfOption(whole={whole})"
+        if whole:
+            msg = f'variable param "{variable.path}" has whole attribute but it\'s not allowed for external variable'
+            raise DictConsistencyError(msg, 34, self.elt.xmlfiles)
+        option_name = self.tiramisu.reflector_objects[variable.path].get(
             self.calls, self.elt.path
         )
         params = [f"{option_name}"]
@@ -385,7 +401,8 @@ class Common:
         ret = ret + ")"
         return ret
 
-    def populate_calculation(self,
+    def populate_calculation(
+        self,
         datas: Union[Calculation, str, list],
         return_a_tuple: bool = False,
     ) -> str:
@@ -398,15 +415,18 @@ class Common:
         params = []
         for idx, data in enumerate(datas):
             if isinstance(data, Calculation):
+                try:
                     params.append(self.calculation_value(data))
+                except VariableCalculationDependencyError:
+                    pass
             elif isinstance(data, str):
                 params.append(self.convert_str(data))
             else:
                 params.append(str(data))
         if return_a_tuple:
-            ret = '('
+            ret = "("
         else:
-            ret = '['
+            ret = "["
         ret += ", ".join(params)
         if return_a_tuple:
             if len(params) <= 1:
@@ -441,18 +461,35 @@ class Variable(Common):
             )
             return
         if self.elt.type == "choice":
-            keys["values"] = self.populate_calculation(self.elt.choices, return_a_tuple=True)
+            keys["values"] = self.populate_calculation(
+                self.elt.choices, return_a_tuple=True
+            )
+        if self.elt.type == 'regexp':
+            self.object_type = 'Regexp_' + self.option_name
+            self.tiramisu.text['header'].append(f'''class {self.object_type}(RegexpOption):
+    __slots__ = tuple()
+    _type = 'value'
+{self.object_type}._regexp = re_compile(r"{self.elt.regexp}")
+''')
         if self.elt.path in self.objectspace.multis:
             keys["multi"] = self.objectspace.multis[self.elt.path]
-        if not hasattr(self.elt, "default"):
-            print('FIXME CA EXISTE!!!')
         if hasattr(self.elt, "default") and self.elt.default is not None:
+            try:
                 keys["default"] = self.populate_calculation(self.elt.default)
+            except VariableCalculationDependencyError:
+                pass
         if self.elt.path in self.objectspace.default_multi:
-            keys["default_multi"] = self.populate_calculation(self.objectspace.default_multi[self.elt.path])
+            try:
+                keys["default_multi"] = self.populate_calculation(
+                    self.objectspace.default_multi[self.elt.path]
+                )
+            except VariableCalculationDependencyError:
+                pass
         if self.elt.validators:
             keys["validators"] = self.populate_calculation(self.elt.validators)
-        for key, value in CONVERT_OPTION.get(self.elt.type, {}).get("initkwargs", {}).items():
+        for key, value in (
+            CONVERT_OPTION.get(self.elt.type, {}).get("initkwargs", {}).items()
+        ):
             if isinstance(value, str):
                 value = self.convert_str(value)
             keys[key] = value

tests/dictionaries/00_0empty/tiramisu/base.py

@@ -1,5 +1,6 @@
 from tiramisu import *
 from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
+from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
 ALLOWED_LEADER_PROPERTIES.add("basic")

tests/dictionaries/00_0empty/tiramisu/multi.py

@@ -1,5 +1,6 @@
 from tiramisu import *
 from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
+from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
 ALLOWED_LEADER_PROPERTIES.add("basic")

tests/dictionaries/00_0empty/tiramisu/no_namespace.py

@@ -1,5 +1,6 @@
 from tiramisu import *
 from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
+from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
 ALLOWED_LEADER_PROPERTIES.add("basic")

tests/dictionaries/00_0version_underscore/tiramisu/base.py

@@ -1,5 +1,6 @@
 from tiramisu import *
 from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
+from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
 ALLOWED_LEADER_PROPERTIES.add("basic")

tests/dictionaries/00_0version_underscore/tiramisu/multi.py

@@ -1,5 +1,6 @@
 from tiramisu import *
 from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
+from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
 ALLOWED_LEADER_PROPERTIES.add("basic")

tests/dictionaries/00_0version_underscore/tiramisu/no_namespace.py

@@ -1,5 +1,6 @@
 from tiramisu import *
 from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
+from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
 ALLOWED_LEADER_PROPERTIES.add("basic")

tests/dictionaries/00_1empty_variable/tiramisu/base.py

@@ -1,5 +1,6 @@
 from tiramisu import *
 from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
+from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
 ALLOWED_LEADER_PROPERTIES.add("basic")

tests/dictionaries/00_1empty_variable/tiramisu/multi.py

@@ -1,5 +1,6 @@
 from tiramisu import *
 from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
+from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
 ALLOWED_LEADER_PROPERTIES.add("basic")

tests/dictionaries/00_1empty_variable/tiramisu/no_namespace.py

@@ -1,5 +1,6 @@
 from tiramisu import *
 from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
+from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
 ALLOWED_LEADER_PROPERTIES.add("basic")

tests/dictionaries/00_2default_calculated/dictionaries/rougail/00-base.yml

@@ -5,7 +5,6 @@ var2:
   description: a second variable
   multi: true
   default:
-    type: jinja
     jinja: |
       {{ _.var1 }}
     description: the value of var1

tests/dictionaries/00_2default_calculated/tiramisu/base.py

@@ -1,5 +1,6 @@
 from tiramisu import *
 from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
+from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
 ALLOWED_LEADER_PROPERTIES.add("basic")

tests/dictionaries/00_2default_calculated/tiramisu/multi.py

@@ -1,5 +1,6 @@
 from tiramisu import *
 from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
+from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
 ALLOWED_LEADER_PROPERTIES.add("basic")

tests/dictionaries/00_2default_calculated/tiramisu/no_namespace.py

@@ -1,5 +1,6 @@
 from tiramisu import *
 from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
+from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
 ALLOWED_LEADER_PROPERTIES.add("basic")

tests/dictionaries/00_2default_calculated_multi/dictionaries/rougail/00-base.yml

@@ -8,7 +8,6 @@ var2:
   description: a second variable
   multi: true
   default:
-    type: jinja
     jinja: |
       {% for val in _.var1 %}
       {{ val }}

tests/dictionaries/00_2default_calculated_multi/tiramisu/base.py

@@ -1,5 +1,6 @@
 from tiramisu import *
 from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
+from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
 ALLOWED_LEADER_PROPERTIES.add("basic")

tests/dictionaries/00_2default_calculated_multi/tiramisu/multi.py

@@ -1,5 +1,6 @@
 from tiramisu import *
 from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
+from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
 ALLOWED_LEADER_PROPERTIES.add("basic")

tests/dictionaries/00_2default_calculated_multi/tiramisu/no_namespace.py

@@ -1,5 +1,6 @@
 from tiramisu import *
 from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
+from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
 ALLOWED_LEADER_PROPERTIES.add("basic")

tests/dictionaries/00_2default_calculated_variable_transitive/dictionaries/rougail/00-base.yml

@@ -0,0 +1,13 @@
+---
+version: 1.1
+var1:
+  description: a first variable
+  multi: true
+  type: domainname
+  params:
+    allow_ip: true
+var2:
+  description: a second variable
+  default:
+    type: variable
+    variable: _.var1

tests/dictionaries/00_2default_calculated_variable_transitive/makedict/after.json

@@ -0,0 +1,10 @@
+{
+    "rougail.var1": {
+        "owner": "default",
+        "value": []
+    },
+    "rougail.var2": {
+        "owner": "default",
+        "value": []
+    }
+}

tests/dictionaries/00_2default_calculated_variable_transitive/makedict/base.json

@@ -0,0 +1,4 @@
+{
+    "rougail.var1": [],
+    "rougail.var2": []
+}

tests/dictionaries/00_2default_calculated_variable_transitive/makedict/before.json

@@ -0,0 +1,10 @@
+{
+    "rougail.var1": {
+        "owner": "default",
+        "value": []
+    },
+    "rougail.var2": {
+        "owner": "default",
+        "value": []
+    }
+}

tests/dictionaries/00_2default_calculated_variable_transitive/makedict/mandatory.json

@@ -0,0 +1 @@
+["rougail.var1", "rougail.var2"]

tests/dictionaries/00_2default_calculated_variable_transitive/tiramisu/base.py

@@ -0,0 +1,11 @@
+from tiramisu import *
+from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
+from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
+load_functions('tests/dictionaries/../eosfunc/test.py')
+ALLOWED_LEADER_PROPERTIES.add("basic")
+ALLOWED_LEADER_PROPERTIES.add("standard")
+ALLOWED_LEADER_PROPERTIES.add("advanced")
+option_2 = DomainnameOption(name="var1", doc="a first variable", multi=True, type="domainname", allow_ip=True, properties=frozenset({"basic", "mandatory", "notempty"}), informations={'type': 'domainname'})
+option_3 = DomainnameOption(name="var2", doc="a second variable", multi=True, default=Calculation(func['calc_value'], Params((ParamOption(option_2)))), type="domainname", allow_ip=True, properties=frozenset({"mandatory", "notempty", "standard"}), informations={'type': 'domainname'})
+optiondescription_1 = OptionDescription(name="rougail", doc="Rougail", children=[option_2, option_3], properties=frozenset({"basic"}))
+option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1])

tests/dictionaries/00_2default_calculated_variable_transitive/tiramisu/multi.py

@@ -0,0 +1,16 @@
+from tiramisu import *
+from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
+from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
+load_functions('tests/dictionaries/../eosfunc/test.py')
+ALLOWED_LEADER_PROPERTIES.add("basic")
+ALLOWED_LEADER_PROPERTIES.add("standard")
+ALLOWED_LEADER_PROPERTIES.add("advanced")
+option_3 = DomainnameOption(name="var1", doc="a first variable", multi=True, type="domainname", allow_ip=True, properties=frozenset({"basic", "mandatory", "notempty"}), informations={'type': 'domainname'})
+option_4 = DomainnameOption(name="var2", doc="a second variable", multi=True, default=Calculation(func['calc_value'], Params((ParamOption(option_3)))), type="domainname", allow_ip=True, properties=frozenset({"mandatory", "notempty", "standard"}), informations={'type': 'domainname'})
+optiondescription_2 = OptionDescription(name="rougail", doc="Rougail", children=[option_3, option_4], properties=frozenset({"basic"}))
+optiondescription_1 = OptionDescription(name="1", doc="1", children=[optiondescription_2], properties=frozenset({"basic"}))
+option_7 = DomainnameOption(name="var1", doc="a first variable", multi=True, type="domainname", allow_ip=True, properties=frozenset({"basic", "mandatory", "notempty"}), informations={'type': 'domainname'})
+option_8 = DomainnameOption(name="var2", doc="a second variable", multi=True, default=Calculation(func['calc_value'], Params((ParamOption(option_7)))), type="domainname", allow_ip=True, properties=frozenset({"mandatory", "notempty", "standard"}), informations={'type': 'domainname'})
+optiondescription_6 = OptionDescription(name="rougail", doc="Rougail", children=[option_7, option_8], properties=frozenset({"basic"}))
+optiondescription_5 = OptionDescription(name="2", doc="2", children=[optiondescription_6], properties=frozenset({"basic"}))
+option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1, optiondescription_5])

tests/dictionaries/00_2default_calculated_variable_transitive/tiramisu/no_namespace.py

@@ -0,0 +1,10 @@
+from tiramisu import *
+from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
+from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
+load_functions('tests/dictionaries/../eosfunc/test.py')
+ALLOWED_LEADER_PROPERTIES.add("basic")
+ALLOWED_LEADER_PROPERTIES.add("standard")
+ALLOWED_LEADER_PROPERTIES.add("advanced")
+option_1 = DomainnameOption(name="var1", doc="a first variable", multi=True, type="domainname", allow_ip=True, properties=frozenset({"basic", "mandatory", "notempty"}), informations={'type': 'domainname'})
+option_2 = DomainnameOption(name="var2", doc="a second variable", multi=True, default=Calculation(func['calc_value'], Params((ParamOption(option_1)))), type="domainname", allow_ip=True, properties=frozenset({"mandatory", "notempty", "standard"}), informations={'type': 'domainname'})
+option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[option_1, option_2])

tests/dictionaries/00_4load_subfolder/tiramisu/base.py

@@ -1,5 +1,6 @@
 from tiramisu import *
 from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
+from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
 ALLOWED_LEADER_PROPERTIES.add("basic")

tests/dictionaries/00_4load_subfolder/tiramisu/multi.py

@@ -1,5 +1,6 @@
 from tiramisu import *
 from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
+from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
 ALLOWED_LEADER_PROPERTIES.add("basic")

tests/dictionaries/00_4load_subfolder/tiramisu/no_namespace.py

@@ -1,5 +1,6 @@
 from tiramisu import *
 from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
+from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
 ALLOWED_LEADER_PROPERTIES.add("basic")

tests/dictionaries/00_5load_notype/tiramisu/base.py

@@ -1,5 +1,6 @@
 from tiramisu import *
 from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
+from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
 ALLOWED_LEADER_PROPERTIES.add("basic")

tests/dictionaries/00_5load_notype/tiramisu/multi.py

@@ -1,5 +1,6 @@
 from tiramisu import *
 from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
+from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
 ALLOWED_LEADER_PROPERTIES.add("basic")

tests/dictionaries/00_5load_notype/tiramisu/no_namespace.py

@@ -1,5 +1,6 @@
 from tiramisu import *
 from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
+from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
 ALLOWED_LEADER_PROPERTIES.add("basic")

tests/dictionaries/00_6boolean/tiramisu/base.py

@@ -1,5 +1,6 @@
 from tiramisu import *
 from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
+from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
 ALLOWED_LEADER_PROPERTIES.add("basic")

tests/dictionaries/00_6boolean/tiramisu/multi.py

@@ -1,5 +1,6 @@
 from tiramisu import *
 from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
+from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
 ALLOWED_LEADER_PROPERTIES.add("basic")

tests/dictionaries/00_6boolean/tiramisu/no_namespace.py

@@ -1,5 +1,6 @@
 from tiramisu import *
 from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
+from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
 ALLOWED_LEADER_PROPERTIES.add("basic")

tests/dictionaries/00_6boolean_no_mandatory/tiramisu/base.py

@@ -1,5 +1,6 @@
 from tiramisu import *
 from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
+from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
 ALLOWED_LEADER_PROPERTIES.add("basic")

tests/dictionaries/00_6boolean_no_mandatory/tiramisu/multi.py

@@ -1,5 +1,6 @@
 from tiramisu import *
 from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
+from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
 ALLOWED_LEADER_PROPERTIES.add("basic")

tests/dictionaries/00_6boolean_no_mandatory/tiramisu/no_namespace.py

@@ -1,5 +1,6 @@
 from tiramisu import *
 from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
+from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
 ALLOWED_LEADER_PROPERTIES.add("basic")

tests/dictionaries/00_6choice/tiramisu/base.py

@@ -1,5 +1,6 @@
 from tiramisu import *
 from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
+from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
 ALLOWED_LEADER_PROPERTIES.add("basic")

tests/dictionaries/00_6choice/tiramisu/multi.py

@@ -1,5 +1,6 @@
 from tiramisu import *
 from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
+from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
 ALLOWED_LEADER_PROPERTIES.add("basic")

tests/dictionaries/00_6choice/tiramisu/no_namespace.py

@@ -1,5 +1,6 @@
 from tiramisu import *
 from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
+from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
 ALLOWED_LEADER_PROPERTIES.add("basic")

tests/dictionaries/00_6choice_calculation/dictionaries/rougail/00-base.yml

@@ -4,7 +4,6 @@ var:
   description: a variable
   default: 9
   choices:
-    type: jinja
     jinja: |
       {% for n in trange(0, 10) %}
       {{ n }}

tests/dictionaries/00_6choice_calculation/tiramisu/base.py

@@ -1,5 +1,6 @@
 from tiramisu import *
 from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
+from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
 ALLOWED_LEADER_PROPERTIES.add("basic")

tests/dictionaries/00_6choice_calculation/tiramisu/multi.py

@@ -1,5 +1,6 @@
 from tiramisu import *
 from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
+from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
 ALLOWED_LEADER_PROPERTIES.add("basic")

tests/dictionaries/00_6choice_calculation/tiramisu/no_namespace.py

@@ -1,5 +1,6 @@
 from tiramisu import *
 from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
+from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
 ALLOWED_LEADER_PROPERTIES.add("basic")

tests/dictionaries/00_6choice_variable/dictionaries/rougail/00-base.yml

@@ -8,5 +8,4 @@ var2:
   description: a first variable
   default: a
   choices:
-    type: variable
     variable: _.var1

tests/dictionaries/00_6choice_variable/tiramisu/base.py

@@ -1,5 +1,6 @@
 from tiramisu import *
 from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
+from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
 ALLOWED_LEADER_PROPERTIES.add("basic")

tests/dictionaries/00_6choice_variable/tiramisu/multi.py

@@ -1,5 +1,6 @@
 from tiramisu import *
 from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
+from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
 ALLOWED_LEADER_PROPERTIES.add("basic")

tests/dictionaries/00_6choice_variable/tiramisu/no_namespace.py

@@ -1,5 +1,6 @@
 from tiramisu import *
 from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
+from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
 ALLOWED_LEADER_PROPERTIES.add("basic")

tests/dictionaries/00_6custom/tiramisu/base.py

@@ -1,5 +1,6 @@
 from tiramisu import *
 from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
+from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
 ALLOWED_LEADER_PROPERTIES.add("basic")

tests/dictionaries/00_6custom/tiramisu/multi.py

@@ -1,5 +1,6 @@
 from tiramisu import *
 from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
+from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
 ALLOWED_LEADER_PROPERTIES.add("basic")

tests/dictionaries/00_6custom/tiramisu/no_namespace.py

@@ -1,5 +1,6 @@
 from tiramisu import *
 from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
+from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
 ALLOWED_LEADER_PROPERTIES.add("basic")

tests/dictionaries/00_6domainname/tiramisu/base.py

@@ -1,5 +1,6 @@
 from tiramisu import *
 from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
+from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
 ALLOWED_LEADER_PROPERTIES.add("basic")

tests/dictionaries/00_6domainname/tiramisu/multi.py

@@ -1,5 +1,6 @@
 from tiramisu import *
 from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
+from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
 ALLOWED_LEADER_PROPERTIES.add("basic")

tests/dictionaries/00_6domainname/tiramisu/no_namespace.py

@@ -1,5 +1,6 @@
 from tiramisu import *
 from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
+from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
 ALLOWED_LEADER_PROPERTIES.add("basic")

tests/dictionaries/00_6domainname_params/tiramisu/base.py

@@ -1,5 +1,6 @@
 from tiramisu import *
 from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
+from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
 ALLOWED_LEADER_PROPERTIES.add("basic")

tests/dictionaries/00_6domainname_params/tiramisu/multi.py

@@ -1,5 +1,6 @@
 from tiramisu import *
 from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
+from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
 ALLOWED_LEADER_PROPERTIES.add("basic")

tests/dictionaries/00_6domainname_params/tiramisu/no_namespace.py

@@ -1,5 +1,6 @@
 from tiramisu import *
 from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
+from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
 ALLOWED_LEADER_PROPERTIES.add("basic")

tests/dictionaries/00_6float/tiramisu/base.py

@@ -1,5 +1,6 @@
 from tiramisu import *
 from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
+from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
 ALLOWED_LEADER_PROPERTIES.add("basic")

tests/dictionaries/00_6float/tiramisu/multi.py

@@ -1,5 +1,6 @@
 from tiramisu import *
 from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
+from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
 ALLOWED_LEADER_PROPERTIES.add("basic")

tests/dictionaries/00_6float/tiramisu/no_namespace.py

@@ -1,5 +1,6 @@
 from tiramisu import *
 from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
+from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
 ALLOWED_LEADER_PROPERTIES.add("basic")

tests/dictionaries/00_6number/tiramisu/base.py

@@ -1,5 +1,6 @@
 from tiramisu import *
 from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
+from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
 ALLOWED_LEADER_PROPERTIES.add("basic")

tests/dictionaries/00_6number/tiramisu/multi.py

@@ -1,5 +1,6 @@
 from tiramisu import *
 from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
+from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
 ALLOWED_LEADER_PROPERTIES.add("basic")

tests/dictionaries/00_6number/tiramisu/no_namespace.py

@@ -1,5 +1,6 @@
 from tiramisu import *
 from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
+from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
 ALLOWED_LEADER_PROPERTIES.add("basic")

tests/dictionaries/00_6regexp/dictionaries/rougail/00-base.yml

@@ -0,0 +1,6 @@
+---
+version: '1.1'
+var:
+  description: a first variable
+  regexp: "^#(?:[0-9a-f]{3}){1,2}$"
+  default: "#a1a1a1"

tests/dictionaries/00_6regexp/makedict/after.json

@@ -0,0 +1,6 @@
+{
+    "rougail.var": {
+        "owner": "default",
+        "value": "#a1a1a1"
+    }
+}

tests/dictionaries/00_6regexp/makedict/base.json

@@ -0,0 +1,3 @@
+{
+    "rougail.var": "#a1a1a1"
+}

tests/dictionaries/00_6regexp/makedict/before.json

@@ -0,0 +1,6 @@
+{
+    "rougail.var": {
+        "owner": "default",
+        "value": "#a1a1a1"
+    }
+}

tests/dictionaries/00_6regexp/makedict/mandatory.json

@@ -0,0 +1 @@
+[]

tests/dictionaries/00_6regexp/tiramisu/base.py

@@ -0,0 +1,16 @@
+from tiramisu import *
+from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
+from re import compile as re_compile
+from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
+load_functions('tests/dictionaries/../eosfunc/test.py')
+ALLOWED_LEADER_PROPERTIES.add("basic")
+ALLOWED_LEADER_PROPERTIES.add("standard")
+ALLOWED_LEADER_PROPERTIES.add("advanced")
+class Regexp_option_2(RegexpOption):
+    __slots__ = tuple()
+    _type = 'value'
+Regexp_option_2._regexp = re_compile(r"^#(?:[0-9a-f]{3}){1,2}$")
+
+option_2 = Regexp_option_2(name="var", doc="a first variable", default="#a1a1a1", properties=frozenset({"mandatory", "standard"}), informations={'type': 'regexp'})
+optiondescription_1 = OptionDescription(name="rougail", doc="Rougail", children=[option_2], properties=frozenset({"standard"}))
+option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1])

tests/dictionaries/00_6regexp/tiramisu/multi.py

@@ -0,0 +1,25 @@
+from tiramisu import *
+from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
+from re import compile as re_compile
+from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
+load_functions('tests/dictionaries/../eosfunc/test.py')
+ALLOWED_LEADER_PROPERTIES.add("basic")
+ALLOWED_LEADER_PROPERTIES.add("standard")
+ALLOWED_LEADER_PROPERTIES.add("advanced")
+class Regexp_option_3(RegexpOption):
+    __slots__ = tuple()
+    _type = 'value'
+Regexp_option_3._regexp = re_compile(r"^#(?:[0-9a-f]{3}){1,2}$")
+
+class Regexp_option_6(RegexpOption):
+    __slots__ = tuple()
+    _type = 'value'
+Regexp_option_6._regexp = re_compile(r"^#(?:[0-9a-f]{3}){1,2}$")
+
+option_3 = Regexp_option_3(name="var", doc="a first variable", default="#a1a1a1", properties=frozenset({"mandatory", "standard"}), informations={'type': 'regexp'})
+optiondescription_2 = OptionDescription(name="rougail", doc="Rougail", children=[option_3], properties=frozenset({"standard"}))
+optiondescription_1 = OptionDescription(name="1", doc="1", children=[optiondescription_2], properties=frozenset({"standard"}))
+option_6 = Regexp_option_6(name="var", doc="a first variable", default="#a1a1a1", properties=frozenset({"mandatory", "standard"}), informations={'type': 'regexp'})
+optiondescription_5 = OptionDescription(name="rougail", doc="Rougail", children=[option_6], properties=frozenset({"standard"}))
+optiondescription_4 = OptionDescription(name="2", doc="2", children=[optiondescription_5], properties=frozenset({"standard"}))
+option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1, optiondescription_4])

tests/dictionaries/00_6regexp/tiramisu/no_namespace.py

@@ -0,0 +1,15 @@
+from tiramisu import *
+from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
+from re import compile as re_compile
+from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
+load_functions('tests/dictionaries/../eosfunc/test.py')
+ALLOWED_LEADER_PROPERTIES.add("basic")
+ALLOWED_LEADER_PROPERTIES.add("standard")
+ALLOWED_LEADER_PROPERTIES.add("advanced")
+class Regexp_option_1(RegexpOption):
+    __slots__ = tuple()
+    _type = 'value'
+Regexp_option_1._regexp = re_compile(r"^#(?:[0-9a-f]{3}){1,2}$")
+
+option_1 = Regexp_option_1(name="var", doc="a first variable", default="#a1a1a1", properties=frozenset({"mandatory", "standard"}), informations={'type': 'regexp'})
+option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[option_1])

tests/dictionaries/00_6string/tiramisu/base.py

@@ -1,5 +1,6 @@
 from tiramisu import *
 from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
+from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
 ALLOWED_LEADER_PROPERTIES.add("basic")

tests/dictionaries/00_6string/tiramisu/multi.py

@@ -1,5 +1,6 @@
 from tiramisu import *
 from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
+from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
 ALLOWED_LEADER_PROPERTIES.add("basic")

tests/dictionaries/00_6string/tiramisu/no_namespace.py

@@ -1,5 +1,6 @@
 from tiramisu import *
 from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
+from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
 ALLOWED_LEADER_PROPERTIES.add("basic")

tests/dictionaries/00_7choice_quote/tiramisu/base.py

@@ -1,5 +1,6 @@
 from tiramisu import *
 from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
+from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
 ALLOWED_LEADER_PROPERTIES.add("basic")

tests/dictionaries/00_7choice_quote/tiramisu/multi.py

@@ -1,5 +1,6 @@
 from tiramisu import *
 from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
+from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
 ALLOWED_LEADER_PROPERTIES.add("basic")

tests/dictionaries/00_7choice_quote/tiramisu/no_namespace.py

@@ -1,5 +1,6 @@
 from tiramisu import *
 from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
+from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
 ALLOWED_LEADER_PROPERTIES.add("basic")

tests/dictionaries/00_7help_quote/tiramisu/base.py

@@ -1,5 +1,6 @@
 from tiramisu import *
 from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
+from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
 ALLOWED_LEADER_PROPERTIES.add("basic")

tests/dictionaries/00_7help_quote/tiramisu/multi.py

@@ -1,5 +1,6 @@
 from tiramisu import *
 from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
+from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
 ALLOWED_LEADER_PROPERTIES.add("basic")

tests/dictionaries/00_7help_quote/tiramisu/no_namespace.py

@@ -1,5 +1,6 @@
 from tiramisu import *
 from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
+from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
 ALLOWED_LEADER_PROPERTIES.add("basic")

tests/dictionaries/00_7value_doublequote/tiramisu/base.py

@@ -1,5 +1,6 @@
 from tiramisu import *
 from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
+from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
 ALLOWED_LEADER_PROPERTIES.add("basic")

tests/dictionaries/00_7value_doublequote/tiramisu/multi.py

@@ -1,5 +1,6 @@
 from tiramisu import *
 from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
+from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
 ALLOWED_LEADER_PROPERTIES.add("basic")

tests/dictionaries/00_7value_doublequote/tiramisu/no_namespace.py

@@ -1,5 +1,6 @@
 from tiramisu import *
 from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
+from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
 ALLOWED_LEADER_PROPERTIES.add("basic")

tests/dictionaries/00_7value_doublequote2/tiramisu/base.py

@@ -1,5 +1,6 @@
 from tiramisu import *
 from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
+from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
 ALLOWED_LEADER_PROPERTIES.add("basic")

tests/dictionaries/00_7value_doublequote2/tiramisu/multi.py

@@ -1,5 +1,6 @@
 from tiramisu import *
 from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
+from re import compile as re_compile
 from rougail.tiramisu import func, dict_env, load_functions, ConvertDynOptionDescription
 load_functions('tests/dictionaries/../eosfunc/test.py')
 ALLOWED_LEADER_PROPERTIES.add("basic")