Extend PlantUML generator with object diagrams and conformance + match links

experiments/exp_scd.py

@@ -153,12 +153,14 @@ def main():
     matcher = MatcherVF2(host, guest, mvs_adapter.RAMCompare(Bottom(state), dsl_m_od))
     for m in matcher.match():
         print("\nMATCH:\n", m)
-        name_to_matched = {}
+        name_mapping = {}
+        id_mapping = {}
         for guest_vtx, host_vtx in m.mapping_vtxs.items():
             if isinstance(guest_vtx, mvs_adapter.NamedNode) and isinstance(host_vtx, mvs_adapter.NamedNode):
-                name_to_matched[guest_vtx.name] = host_vtx.name
+                id_mapping[guest_vtx.node_id] = host_vtx.node_id
-        print(name_to_matched)
+                name_mapping[guest_vtx.name] = host_vtx.name
-        rewriter.rewrite(state, lhs_id, rhs_id, ramified_mm_id, name_to_matched, dsl_m_id, dsl_mm_id)
+        print(name_mapping)
+        #rewriter.rewrite(state, lhs_id, rhs_id, ramified_mm_id, name_mapping, dsl_m_id, dsl_mm_id)
         break
     print("DONE")
 
@@ -166,7 +168,28 @@ def main():
     print("Updated model conforms?", conf5.check_nominal(log=True))
 
 
-    print(plantuml.render_ramification(state, dsl_mm_id, ramified_mm_id))
+
+
+    # Render original and RAMified meta-models
+    print(plantuml.render_package("Meta-Model", plantuml.render_class_diagram(state, dsl_mm_id)))
+    print(plantuml.render_package("RAMified Meta-Model", plantuml.render_class_diagram(state, ramified_mm_id)))
+    
+    # Render ramification traceability links
+    print(plantuml.render_trace_ramifies(state, dsl_mm_id, ramified_mm_id))
+
+    # Render host graph
+    print(plantuml.render_package("Model", plantuml.render_object_diagram(state, dsl_m_id, dsl_mm_id)))
+
+    # Render conformance host -> MM
+    print(plantuml.render_trace_conformance(state, dsl_m_id, dsl_mm_id))
+
+    # Render pattern
+    print(plantuml.render_package("LHS", plantuml.render_object_diagram(state, lhs_id, ramified_mm_id)))
+
+    # Render pattern -> RAM-MM
+    print(plantuml.render_trace_conformance(state, lhs_id, ramified_mm_id))
+
+    print(plantuml.render_trace_match(state, id_mapping))
 
 if __name__ == "__main__":
     main()

renderer/plantuml.py

@@ -12,9 +12,9 @@ def render_class_diagram(state, model):
     # Render classes
     for name, class_node in model_scd.get_classes().items():
         if model_od.read_slot_boolean(class_node, "abstract"):
-            output += f"\nabstract class {name}"
+            output += f"\nabstract class \"{name}\" as {make_id(class_node)}"
         else:
-            output += f"\nclass {name}"
+            output += f"\nclass \"{name}\" as {make_id(class_node)}"
 
         # Render attributes
         output += " {"
@@ -27,17 +27,24 @@ def render_class_diagram(state, model):
 
     # Render inheritance links
     for inh_node in model_scd.get_inheritances().values():
-        src_name = model_scd.get_class_name(bottom.read_edge_source(inh_node))
+        src_node = bottom.read_edge_source(inh_node)
-        tgt_name = model_scd.get_class_name(bottom.read_edge_target(inh_node))
+        tgt_node = bottom.read_edge_target(inh_node)
-        output += f"\n{tgt_name} <|-- {src_name}"
+        # src_name = model_scd.get_class_name(bottom.read_edge_source(inh_node))
+        # tgt_name = model_scd.get_class_name(bottom.read_edge_target(inh_node))
+        output += f"\n{make_id(tgt_node)} <|-- {make_id(src_node)}"
 
     output += "\n"
 
+    # Render associations
     for assoc_name, assoc_edge in model_scd.get_associations().items():
-        src_name = model_scd.get_class_name(bottom.read_edge_source(assoc_edge))
+        src_node = bottom.read_edge_source(assoc_edge)
-        tgt_name = model_scd.get_class_name(bottom.read_edge_target(assoc_edge))
+        tgt_node = bottom.read_edge_target(assoc_edge)
+        # src_name = model_scd.get_class_name(bottom.read_edge_source(assoc_edge))
+        # tgt_name = model_scd.get_class_name(bottom.read_edge_target(assoc_edge))
 
         src_lower_card, src_upper_card, tgt_lower_card, tgt_upper_card = model_scd.get_assoc_cardinalities(assoc_edge)
+
+        # default cardinalities
         if src_lower_card == None:
             src_lower_card = 0
         if src_upper_card == None:
@@ -55,7 +62,34 @@ def render_class_diagram(state, model):
         if tgt_card == "1 .. 1":
             tgt_card = " " # hide cardinality
         
-        output += f'\n{src_name} "{src_card}" --> "{tgt_card}" {tgt_name} : {assoc_name}'
+        output += f'\n{make_id(src_node)} "{src_card}" --> "{tgt_card}" {make_id(tgt_node)} : {assoc_name}'
+
+    return output
+
+
+def render_object_diagram(state, m, mm):
+    bottom = Bottom(state)
+    mm_scd = scd.SCD(mm, state)
+    m_od = od.OD(mm, m, state)
+
+    output = ""
+
+    # Render objects
+    for class_name, class_node in mm_scd.get_classes().items():
+        for obj_name, obj_node in m_od.get_objects(class_node).items():
+            output += f"\nobject \"{obj_name} : {class_name}\" as {make_id(obj_node)}"
+
+    output += '\n'
+
+    # Render links
+    for assoc_name, assoc_edge in mm_scd.get_associations().items():
+        for link_name, link_edge in m_od.get_objects(assoc_edge).items():
+            src_obj = bottom.read_edge_source(link_edge)
+            tgt_obj = bottom.read_edge_target(link_edge)
+            src_name = m_od.get_object_name(src_obj)
+            tgt_name = m_od.get_object_name(tgt_obj)
+
+            output += f"\n{make_id(src_obj)} -> {make_id(tgt_obj)} : {assoc_name}"
 
     return output
 
@@ -66,23 +100,57 @@ def render_package(name, contents):
     output += '\n}'
     return output
 
-def render_ramification(state, mm, ramified_mm):
+def render_trace_ramifies(state, mm, ramified_mm):
     bottom = Bottom(state)
 
-    output = (
-          render_package("original", render_class_diagram(state, mm))
-        + '\n'
-        + render_package("RAMified", render_class_diagram(state, ramified_mm))
-    )
-
     mm_scd = scd.SCD(mm, state)
     ramified_mm_scd = scd.SCD(ramified_mm, state)
 
-    output += "\n"
+    # output = (
+    #       render_package("original", render_class_diagram(state, mm))
+    #     + '\n'
+    #     + render_package("RAMified", render_class_diagram(state, ramified_mm))
+    # )
+
+    output = ""
+
+    # output += "\n"
 
     for ram_name, ram_class_node in ramified_mm_scd.get_classes().items():
         original_class, = bottom.read_outgoing_elements(ram_class_node, ramify.RAMIFIES_LABEL)
         original_name = mm_scd.get_class_name(original_class)
-        output += f"\n{ram_name} ..> {original_name} : RAMifies"
+        output += f"\n{make_id(ram_class_node)} ..> {make_id(original_class)} #line:green;text:green : RAMifies "
 
     return output
+
+
+def render_trace_conformance(state, m, mm):
+    bottom = Bottom(state)
+    mm_scd = scd.SCD(mm, state)
+    m_od = od.OD(mm, m, state)
+
+    output = ""
+
+    # Render objects
+    for class_name, class_node in mm_scd.get_classes().items():
+        for obj_name, obj_node in m_od.get_objects(class_node).items():
+            output += f"\n{make_id(obj_node)} ..> {make_id(class_node)} #line:blue;text:blue : instanceOf"
+
+    output += '\n'
+
+    return output
+
+def render_trace_match(state, mapping):
+    bottom = Bottom(state)
+
+    output = ""
+
+    for pattern_el, host_el in mapping.items():
+        # only render 'match'-edges between objects (= those elements where the type of the type is 'Class'):
+        if od.get_type(bottom, od.get_type(bottom, pattern_el)) == od.get_scd_mm_class_node(bottom):
+            output += f"\n{make_id(pattern_el)} ..> {make_id(host_el)} #line:grey;text:grey : matchedWith"
+
+    return output
+
+def make_id(uuid) -> str:
+    return (str(uuid).replace('-','_'))

services/od.py

@@ -139,6 +139,15 @@ class OD:
         self.bottom.create_edge(link_edge, type_edge, "Morphism")
         return link_edge
 
+    def get_objects(self, class_node):
+        return get_typed_by(self.bottom, self.model, class_node)
+
+    def get_object_name(self, obj: UUID):
+        for key in self.bottom.read_keys(self.model):
+            for el in self.bottom.read_outgoing_elements(self.model, key):
+                if el == obj:
+                    return key
+
 def get_types(bottom: Bottom, obj: UUID):
     return bottom.read_outgoing_elements(obj, "Morphism")
 
@@ -155,6 +164,16 @@ def is_typed_by(bottom, el: UUID, typ: UUID):
             return True
     return False
 
+def get_typed_by(bottom, model, type_node: UUID):
+    name_to_instance = {}
+    for key in bottom.read_keys(model):
+        element, = bottom.read_outgoing_elements(model, key)
+        element_types = bottom.read_outgoing_elements(element, "Morphism")
+        if type_node in element_types:
+            name_to_instance[key] = element
+    # mapping from instance name to UUID
+    return name_to_instance
+
 def get_scd_mm(bottom):
     scd_metamodel_id = bottom.state.read_dict(bottom.state.read_root(), "SCD")
     scd_metamodel = UUID(bottom.state.read_value(scd_metamodel_id))