teaching/muMLE
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Extend PlantUML generator with object diagrams and conformance + match links

Browse source
This commit is contained in:
Joeri Exelmans 2024-09-12 15:22:55 +02:00
parent 40552b8dcf
commit 0bcee87bc1
3 changed files with 133 additions and 23 deletions
Download patch file Download diff file Expand all files Collapse all files

33
experiments/exp_scd.py
View file

@ -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
print(name_to_matched)
rewriter.rewrite(state, lhs_id, rhs_id, ramified_mm_id, name_to_matched, dsl_m_id, dsl_mm_id)
id_mapping[guest_vtx.node_id] = host_vtx.node_id
name_mapping[guest_vtx.name] = host_vtx.name
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()

104
renderer/plantuml.py
View file

@ -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))
tgt_name = model_scd.get_class_name(bottom.read_edge_target(inh_node))
output += f"\n{tgt_name} <|-- {src_name}"
src_node = bottom.read_edge_source(inh_node)
tgt_node = bottom.read_edge_target(inh_node)
# 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))
tgt_name = model_scd.get_class_name(bottom.read_edge_target(assoc_edge))
src_node = bottom.read_edge_source(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
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('-','_'))

19
services/od.py
View file

@ -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))