specitems 1.2.2__tar.gz → 1.4.0__tar.gz

{specitems-1.2.2 → specitems-1.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: specitems
-Version: 1.2.2
+Version: 1.4.0
 Summary: Provides interfaces to work with specification items.
 Keywords: certification,documentation,markdown,qualification,requirements-management,traceability
 Author: The specitems Authors

{specitems-1.2.2 → specitems-1.4.0}/pyproject.toml

@@ -4,7 +4,7 @@
 
 [project]
 name = "specitems"
-version = "1.2.2"
+version = "1.4.0"
 description = "Provides interfaces to work with specification items."
 authors = [
     {name = "The specitems Authors", email = "specthings@embedded-brains.de"}

{specitems-1.2.2 → specitems-1.4.0}/src/specitems/itemmapper.py

@@ -203,13 +203,7 @@ class ItemGetValueContext:
 
         If the context arguments are not present, then return the value.
         """
-        if self.args is None:
-            return value
-
-        def _substitute(text: str) -> str:
-            return self.mapper.substitute(text, self.item, self.path)
-
-        return self.mapper.transform(value, self.args, _substitute)
+        return self.mapper.transform(self, value)
 
     def substitute_and_transform(self, value: Any) -> Any:
         """
@@ -269,15 +263,10 @@ class ItemMapper(abc.ABC):
         value = ctx.value[ctx.key]
         if ctx.index >= 0:
             value = value[ctx.index]
-        if not ctx.remaining_path:
-            value = self.substitute_data(value, ctx.item, ctx.path)
-            if ctx.args is not None:
-
-                def _substitute(text: str) -> str:
-                    return self.substitute(text, ctx.item, ctx.path)
-
-                value = self.transform(value, ctx.args, _substitute)
-        return value
+        if ctx.remaining_path:
+            return value
+        return self.transform(ctx,
+                              self.substitute_data(value, ctx.item, ctx.path))
 
     def _add_get_value_map_for_subtypes(
             self, spec_type: ItemType, type_path: str, path_key: str,
@@ -340,28 +329,42 @@ class ItemMapper(abc.ABC):
         """
         Associate the name with the value transformer.
 
+        The get value context is passed as the first argument to the
+        transformer.
+
         The transformer is used to transform a mapped value.  The mapped value
-        is passed as the first argument to the transformer.
+        is passed as the second argument to the transformer.
         """
         self._transformers[name] = transformer
 
-    def transform(self, value: Any, name_and_args: str,
-                  substitute: Callable[[str], str]) -> Any:
+    def transform(self, ctx: ItemGetValueContext, value: Any) -> Any:
         """
-        Transform the value using the transformer specified by the name and
-        optional arguments.
+        Transform the value using the transformer specified by the get value
+        context arguments.
+
+        The get value context is passed as the first argument to the
+        transformer.
 
-        The value is passed as the first argument to the transformer.
+        The value is passed as the second argument to the transformer.
+
+        If the get value context arguments are not present, then return the
+        value.
 
-        The name and arguments string parameter specifies the name of the
-        transformer and optional additional positional and keyword arguments.
-        The transformer name is the start of the string up to the first space
-        character or the end of the string.  Arguments following the space
-        character are unpacked and passed to the transformer.
+        The get value context arguments specify the name of the transformer and
+        optional additional positional and keyword arguments.  The transformer
+        name is the start of the string up to the first space character or the
+        end of the string.  Arguments following the space character are
+        unpacked and passed to the transformer.
         """
-        name, _, args_string = name_and_args.partition(" ")
-        args, kwargs = unpack_args(args_string, substitute)
-        return self._transformers[name](value, *args, **kwargs)
+        if ctx.args is None:
+            return value
+
+        def _substitute(value_2: str) -> str:
+            return self.substitute(value_2, ctx.item, ctx.path)
+
+        name, _, args_string = ctx.args.partition(" ")
+        args, kwargs = unpack_args(args_string, _substitute)
+        return self._transformers[name](ctx, value, *args, **kwargs)
 
     @contextlib.contextmanager
     def scope(self, item: Item) -> Iterator[None]:
@@ -510,6 +513,43 @@ class ItemMapper(abc.ABC):
             return new_dict
         return data
 
+    def substitute_flexible_list(self,
+                                 flexible_list: list,
+                                 is_enabled_method: Callable[[Any], bool],
+                                 item: Optional[Item] = None,
+                                 prefix: str = "") -> list[str]:
+        """
+        Create a new list containing the substituted elements of the flexible
+        list.
+
+        Where an element is a dictionary, when its enabled-by expression
+        evaluates to true, the data substitution of the element value is added
+        to the new list.
+        """
+        new_list: list[str] = []
+        for index, element in enumerate(flexible_list):
+            prefix_2 = f"{prefix}[{index}]"
+            if isinstance(element, dict):
+                if not is_enabled_method(
+                        self.substitute_data(element["enabled-by"], item,
+                                             prefix_2)):
+                    continue
+                element = self.substitute_data(element["value"], item,
+                                               prefix_2)
+            elif isinstance(element, str):
+                if _SINGLE_SUBSTITUTION.search(element):
+                    element = self.map(element[2:-1], item, prefix_2)[2]
+                else:
+                    element = self.substitute(element, item, prefix_2)
+            else:
+                element = self.substitute_data(element, item, prefix_2)
+            if isinstance(element, list):
+                new_list.extend(element)
+            else:
+                assert isinstance(element, str)
+                new_list.append(element)
+        return new_list
+
     def add_value_provider(self, provider: "ItemValueProvider") -> None:
         """ Add the value provider to the mapper. """
         self._value_providers.append(provider)

{specitems-1.2.2 → specitems-1.4.0}/src/specitems/items.py

@@ -157,23 +157,23 @@ def is_enabled(enabled_set: EnabledSet, enabled_by: Any) -> bool:
     return enabled_by in enabled_set
 
 
-def _ops_is_enabled_op_and(enabled_set: EnabledSet, enabled_by: Any,
-                           ops: dict) -> bool:
+def _ops_is_enabled_op_and(ops: dict, enabled_set: EnabledSet,
+                           enabled_by: Any) -> bool:
     for next_enabled_by in enabled_by:
-        if not is_enabled_with_ops(enabled_set, next_enabled_by, ops):
+        if not is_enabled_with_ops(ops, enabled_set, next_enabled_by):
             return False
     return True
 
 
-def _ops_is_enabled_op_not(enabled_set: EnabledSet, enabled_by: Any,
-                           ops: dict) -> bool:
-    return not is_enabled_with_ops(enabled_set, enabled_by, ops)
+def _ops_is_enabled_op_not(ops: dict, enabled_set: EnabledSet,
+                           enabled_by: Any) -> bool:
+    return not is_enabled_with_ops(ops, enabled_set, enabled_by)
 
 
-def _ops_is_enabled_op_or(enabled_set: EnabledSet, enabled_by: Any,
-                          ops: dict) -> bool:
+def _ops_is_enabled_op_or(ops: dict, enabled_set: EnabledSet,
+                          enabled_by: Any) -> bool:
     for next_enabled_by in enabled_by:
-        if is_enabled_with_ops(enabled_set, next_enabled_by, ops):
+        if is_enabled_with_ops(ops, enabled_set, next_enabled_by):
             return True
     return False
 
@@ -185,8 +185,8 @@ IS_ENABLED_OPS = {
 }
 
 
-def is_enabled_with_ops(enabled_set: EnabledSet, enabled_by: Any,
-                        ops: dict) -> bool:
+def is_enabled_with_ops(ops: dict, enabled_set: EnabledSet,
+                        enabled_by: Any) -> bool:
     """
     Evaluate the enabled-by expression using the enabled set with custom
     operations.
@@ -194,10 +194,10 @@ def is_enabled_with_ops(enabled_set: EnabledSet, enabled_by: Any,
     if isinstance(enabled_by, bool):
         return enabled_by
     if isinstance(enabled_by, list):
-        return _ops_is_enabled_op_or(enabled_set, enabled_by, ops)
+        return _ops_is_enabled_op_or(ops, enabled_set, enabled_by)
     if isinstance(enabled_by, dict):
         key, value = next(iter(enabled_by.items()))
-        return ops[key](enabled_set, value, ops)
+        return ops[key](ops, enabled_set, value)
     return enabled_by in enabled_set