fix: type is not always mandatory

src/rougail/annotator/family.py

@@ -244,9 +244,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/config.py

@@ -216,19 +216,16 @@ extra_dictionaries:
   description: Extra namespaces
   type: leadership
   disabled:
-    type: jinja
+    variable: main_namespace
-    jinja: |
+    when: null
-      {% if not main_namespace %}
-      main_namespace not available
-      {% endif %}
   names:
     description: 'Extra namespace name'
-    alternative_name: x
+    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
@@ -238,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

src/rougail/convert.py

@@ -590,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:
@@ -999,11 +1010,16 @@ class ParserVariable:
             calculations = calculations[0]
         else:
             calculations = calculations[1]
-        return (
+        if not isinstance(value, dict) or attribute not in calculations:
-            attribute in calculations
+            return False
-            and isinstance(value, dict)
+        if 'type' in value:
-            and value.get("type") in CALCULATION_TYPES
+            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,
@@ -1036,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 = {
@@ -1214,6 +1235,8 @@ class RougailConvert(ParserVariable):
             objects,
             filename,
         )
+        if objects is None:
+            return
         self.parse_root_file(filename,
                              path,
                              version,
@@ -1268,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/object_model.py

@@ -102,6 +102,7 @@ CONVERT_OPTION = {
         example="644",
     ),
     "choice": dict(opttype="ChoiceOption", example="a_choice"),
+    "regexp": dict(opttype="RegexpOption"),
     #
     "symlink": dict(opttype="SymLinkOption"),
 }
@@ -588,20 +589,61 @@ class InformationCalculation(Calculation):
         }
 
 
-class SuffixCalculation(Calculation):
+class _SuffixCalculation(Calculation):
-    attribute_name: Literal["default", "choice", "dynamic"]
     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",
         }
 
 
@@ -632,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]
@@ -667,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
@@ -678,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

src/rougail/structural_commandline/annotator.py

@@ -30,6 +30,7 @@ class Annotator(Walk):
     def __init__(self, objectspace, *args) -> None:
         if not objectspace.paths:
             return
+        self.alternative_names = {}
         self.objectspace = objectspace
         not_for_commandlines = []
         for family in self.get_families():
@@ -59,6 +60,17 @@ class Annotator(Walk):
             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:
@@ -71,7 +83,7 @@ class Annotator(Walk):
                 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}"'), 200, variable.xmlfiles)
+            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
         )