Feat custom diagram

capellambse_context_diagrams/collectors/custom.py

@@ -49,10 +49,7 @@ def __init__(
 
         self.data = makers.make_diagram(diagram)
         self.params = params
-        self.instructions = self.diagram._collect
-        self.repeat_instructions: dict[str, t.Any] = {}
-        self.repeat_depth: int = 0
-        self.visited: set[str] = set()
+        self.collection = self.diagram._collect
         self.boxes: dict[str, _elkjs.ELKInputChild] = {}
         self.edges: dict[str, _elkjs.ELKInputEdge] = {}
         self.ports: dict[str, _elkjs.ELKInputPort] = {}
@@ -74,15 +71,18 @@ def __call__(self) -> _elkjs.ELKInputData:
             self._make_port_and_owner(self.target)
         else:
             self._make_target(self.target)
+
         if target_edge := self.edges.get(self.target.uuid):
             target_edge.layoutOptions = copy.deepcopy(
                 _elkjs.EDGE_STRAIGHTENING_LAYOUT_OPTIONS
             )
-        if not self.instructions:
-            return self._get_data()
+
         if self.diagram._unify_edge_direction == "UNIFORM":
             self.directions[self.boxable_target.uuid] = False
-        self._perform_instructions(self.target, self.instructions)
+
+        for elem in self.collection:
+            self._make_target(elem)
+
         if self.diagram._display_parent_relation:
             current = self.boxable_target
             while (
@@ -92,7 +92,9 @@ def __call__(self) -> _elkjs.ELKInputData:
                 and not isinstance(current.owner, generic.PackageTypes)
             ):
                 self.common_owners.discard(current.uuid)
-                current = self._make_owner_box(current)
+                current = generic.make_owner_box(
+                    current, self._make_box, self.boxes, self.boxes_to_delete
+                )
                 self.common_owners.discard(current.uuid)
             for edge_uuid, box_uuid in self.edge_owners.items():
                 if box := self.boxes.get(box_uuid):
@@ -118,152 +120,6 @@ def _fix_box_heights(self) -> None:
                 box = self.boxes[uuid]
                 box.height = max([box.height] + list(min_heights.values()))
 
-    def _safely_eval_filter(self, obj: m.ModelElement, filter: str) -> bool:
-        if not filter.startswith("lambda"):
-            raise ValueError(f"Filter '{filter}' is not a lambda expression.")
-
-        safe_builtins = {
-            "abs",
-            "all",
-            "any",
-            "ascii",
-            "bin",
-            "bool",
-            "bytearray",
-            "bytes",
-            "callable",
-            "chr",
-            "classmethod",
-            "complex",
-            "dict",
-            "divmod",
-            "enumerate",
-            "filter",
-            "float",
-            "format",
-            "frozenset",
-            "getattr",
-            "hasattr",
-            "hash",
-            "hex",
-            "id",
-            "int",
-            "isinstance",
-            "issubclass",
-            "iter",
-            "len",
-            "list",
-            "map",
-            "max",
-            "memoryview",
-            "min",
-            "next",
-            "object",
-            "oct",
-            "ord",
-            "pow",
-            "print",
-            "property",
-            "range",
-            "repr",
-            "reversed",
-            "round",
-            "set",
-            "slice",
-            "sorted",
-            "staticmethod",
-            "str",
-            "sum",
-            "tuple",
-            "type",
-            "vars",
-            "zip",
-        }
-        allowed_builtins = {
-            name: getattr(builtins, name) for name in safe_builtins
-        }
-        allowed_builtins.update(
-            {
-                "True": True,
-                "False": False,
-                "capellambse": capellambse,
-            }
-        )
-
-        try:
-            # pylint: disable=eval-used
-            result = eval(filter, {"__builtins__": allowed_builtins})(obj)
-        except Exception as e:
-            raise ValueError(
-                f"Filter '{filter}' raised an exception: {e}"
-            ) from e
-
-        if not isinstance(result, bool):
-            raise ValueError(
-                f"Filter '{filter}' did not return a boolean value."
-            )
-
-        return result
-
-    def _matches_filters(
-        self, obj: m.ModelElement, filters: dict[str, t.Any] | str
-    ) -> bool:
-        if isinstance(filters, str):
-            return self._safely_eval_filter(obj, filters)
-        for key, value in filters.items():
-            if getattr(obj, key) != value:
-                return False
-        return True
-
-    def _perform_instructions(
-        self, obj: m.ModelElement, instructions: dict[str, t.Any]
-    ) -> None:
-        if max_depth := instructions.pop("repeat", None):
-            self.repeat_instructions = instructions
-            self.repeat_depth = max_depth
-        if get_targets := instructions.get("get"):
-            self._perform_get_or_include(obj, get_targets, False)
-        if include_targets := instructions.get("include"):
-            self._perform_get_or_include(obj, include_targets, True)
-        if not get_targets and not include_targets:
-            if self.repeat_depth != 0:
-                self.repeat_depth -= 1
-                self._perform_instructions(obj, self.repeat_instructions)
-
-    def _perform_get_or_include(
-        self,
-        obj: m.ModelElement,
-        targets: dict[str, t.Any] | list[dict[str, t.Any]],
-        create: bool,
-    ) -> None:
-        if isinstance(targets, dict):
-            targets = [targets]
-        assert isinstance(targets, list)
-        if self.repeat_depth > 0:
-            self.repeat_depth += len(targets)
-        for i in targets:
-            attr = i.get("name")
-            assert attr, "Attribute name is required."
-            target = getattr(obj, attr, None)
-            if isinstance(target, cabc.Iterable):
-                filters = i.get("filter", {})
-                for item in target:
-                    if item.uuid in self.visited:
-                        continue
-                    self.visited.add(item.uuid)
-                    if not self._matches_filters(item, filters):
-                        continue
-                    if create:
-                        self._make_target(item)
-                    self._perform_instructions(item, i)
-            elif isinstance(target, m.ModelElement):
-                if target.uuid in self.visited:
-                    continue
-                self.visited.add(target.uuid)
-                if create:
-                    self._make_target(target)
-                self._perform_instructions(target, i)
-
     def _make_target(
         self, obj: m.ModelElement
     ) -> _elkjs.ELKInputChild | _elkjs.ELKInputEdge | None:
@@ -293,34 +149,15 @@ def _make_box(
         if self.diagram._display_parent_relation:
             self.common_owners.add(
                 generic.make_owner_boxes(
-                    obj, self.diagram_target_owners, self._make_owner_box
+                    obj,
+                    self.diagram_target_owners,
+                    self._make_box,
+                    self.boxes,
+                    self.boxes_to_delete,
                 )
             )
         return box
 
-    def _make_owner_box(
-        self,
-        obj: t.Any,
-    ) -> t.Any:
-        parent_box = self._make_box(
-            obj.owner,
-            layout_options=makers.DEFAULT_LABEL_LAYOUT_OPTIONS,
-        )
-        assert (obj_box := self.boxes.get(obj.uuid))
-        for box in (children := parent_box.children):
-            if box.id == obj.uuid:
-                break
-        else:
-            children.append(obj_box)
-            obj_box.width = max(
-                obj_box.width,
-                parent_box.width,
-            )
-            for label in parent_box.labels:
-                label.layoutOptions = makers.DEFAULT_LABEL_LAYOUT_OPTIONS
-        self.boxes_to_delete.add(obj.uuid)
-        return obj.owner
-
     def _make_edge_and_ports(
         self,
         edge_obj: m.ModelElement,

capellambse_context_diagrams/collectors/default.py

@@ -67,7 +67,6 @@ def process_context(self):
         ):
             box = self._make_box(
                 self.diagram.target.owner,
-                no_symbol=self.diagram._display_symbols_as_boxes,
                 layout_options=makers.DEFAULT_LABEL_LAYOUT_OPTIONS,
             )
             box.children = [self.centerbox]
@@ -83,8 +82,11 @@ def process_context(self):
                 and hasattr(current, "owner")
                 and not isinstance(current.owner, generic.PackageTypes)
             ):
-                current = self._make_owner_box(
+                current = generic.make_owner_box(
                     current,
+                    self._make_box,
+                    self.global_boxes,
+                    self.boxes_to_delete,
                 )
                 self.common_owners.discard(current.uuid)
 
@@ -248,7 +250,6 @@ def _process_ports(self) -> None:
                 box = self._make_box(
                     owner,
                     height=height,
-                    no_symbol=self.diagram._display_symbols_as_boxes,
                 )
                 box.ports = local_port_objs
 
@@ -257,7 +258,11 @@ def _process_ports(self) -> None:
             if self.diagram._display_parent_relation:
                 self.common_owners.add(
                     generic.make_owner_boxes(
-                        owner, self.diagram_target_owners, self._make_owner_box
+                        owner,
+                        self.diagram_target_owners,
+                        self._make_box,
+                        self.global_boxes,
+                        self.boxes_to_delete,
                     )
                 )
 
@@ -284,33 +289,13 @@ def _make_box(
             return box
         box = makers.make_box(
             obj,
+            no_symbol=self.diagram._display_symbols_as_boxes,
             **kwargs,
         )
         self.global_boxes[obj.uuid] = box
         self.made_boxes[obj.uuid] = box
         return box
 
-    def _make_owner_box(
-        self,
-        obj: t.Any,
-    ) -> t.Any:
-        parent_box = self._make_box(
-            obj.owner,
-            no_symbol=self.diagram._display_symbols_as_boxes,
-            layout_options=makers.DEFAULT_LABEL_LAYOUT_OPTIONS,
-        )
-        assert (obj_box := self.global_boxes.get(obj.uuid))
-        for box in (children := parent_box.children):
-            if box.id == obj.uuid:
-                break
-        else:
-            children.append(obj_box)
-            for label in parent_box.labels:
-                label.layoutOptions = makers.DEFAULT_LABEL_LAYOUT_OPTIONS
-
-        self.boxes_to_delete.add(obj.uuid)
-        return obj.owner
-
 
 def collector(
     diagram: context.ContextDiagram, params: dict[str, t.Any] | None = None

capellambse_context_diagrams/collectors/generic.py

@@ -269,8 +269,38 @@ def get_all_owners(obj: m.ModelElement) -> cabc.Iterator[str]:
         current = getattr(current, "owner", None)
 
 
+def make_owner_box(
+    obj: t.Any,
+    make_box_func: t.Callable,
+    boxes: dict[str, _elkjs.ELKInputChild],
+    boxes_to_delete: set[str],
+) -> t.Any:
+    parent_box = make_box_func(
+        obj.owner,
+        layout_options=makers.DEFAULT_LABEL_LAYOUT_OPTIONS,
+    )
+    assert (obj_box := boxes.get(obj.uuid))
+    for box in (children := parent_box.children):
+        if box.id == obj.uuid:
+            break
+    else:
+        children.append(obj_box)
+        obj_box.width = max(
+            obj_box.width,
+            parent_box.width,
+        )
+        for label in parent_box.labels:
+            label.layoutOptions = makers.DEFAULT_LABEL_LAYOUT_OPTIONS
+    boxes_to_delete.add(obj.uuid)
+    return obj.owner
+
+
 def make_owner_boxes(
-    obj: m.ModelElement, excluded: list[str], make_func: t.Callable
+    obj: m.ModelElement,
+    excluded: list[str],
+    make_box_func: t.Callable,
+    boxes: dict[str, _elkjs.ELKInputChild],
+    boxes_to_delete: set[str],
 ) -> str:
     """Create owner boxes for all owners of ``obj``."""
     current = obj
@@ -280,5 +310,7 @@ def make_owner_boxes(
         and getattr(current, "owner", None) is not None
         and not isinstance(current.owner, PackageTypes)
     ):
-        current = make_func(current)
+        current = make_owner_box(
+            current, make_box_func, boxes, boxes_to_delete
+        )
     return current.uuid