Class diagram can be rendered as object diagram textual syntax, and parsed back, without information loss
This commit is contained in:
parent
f45872d3f7
commit
175edb64d9
14 changed files with 505 additions and 249 deletions
218
concrete_syntax/plantuml.py
Normal file
218
concrete_syntax/plantuml.py
Normal file
|
|
@ -0,0 +1,218 @@
|
|||
from services import scd, od
|
||||
from services.bottom.V0 import Bottom
|
||||
from transformation import ramify
|
||||
import json
|
||||
from uuid import UUID
|
||||
|
||||
def render_class_diagram(state, model, prefix_ids=""):
|
||||
bottom = Bottom(state)
|
||||
model_scd = scd.SCD(model, state)
|
||||
model_od = od.OD(od.get_scd_mm(bottom), model, state)
|
||||
|
||||
def make_id(uuid) -> str:
|
||||
return prefix_ids+str(uuid).replace('-','_')
|
||||
|
||||
output = ""
|
||||
|
||||
# Render classes
|
||||
for name, class_node in model_scd.get_classes().items():
|
||||
is_abstract = False
|
||||
slot = model_od.get_slot(class_node, "abstract")
|
||||
if slot != None:
|
||||
is_abstract = od.read_primitive_value(bottom, slot, model_od.type_model)
|
||||
|
||||
if is_abstract:
|
||||
output += f"\nabstract class \"{name}\" as {make_id(class_node)}"
|
||||
else:
|
||||
output += f"\nclass \"{name}\" as {make_id(class_node)}"
|
||||
|
||||
# Render attributes
|
||||
output += " {"
|
||||
for attr_name, attr_edge in od.get_attributes(bottom, class_node):
|
||||
tgt_name = model_scd.get_class_name(bottom.read_edge_target(attr_edge))
|
||||
output += f"\n {attr_name} : {tgt_name}"
|
||||
output += "\n}"
|
||||
|
||||
output += "\n"
|
||||
|
||||
# Render inheritance links
|
||||
for inh_node in model_scd.get_inheritances().values():
|
||||
src_node = bottom.read_edge_source(inh_node)
|
||||
tgt_node = 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_node = bottom.read_edge_source(assoc_edge)
|
||||
tgt_node = 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:
|
||||
src_upper_card = "*"
|
||||
if tgt_lower_card == None:
|
||||
tgt_lower_card = 0
|
||||
if tgt_upper_card == None:
|
||||
tgt_upper_card = "*"
|
||||
|
||||
src_card = f"{src_lower_card} .. {src_upper_card}"
|
||||
tgt_card = f"{tgt_lower_card} .. {tgt_upper_card}"
|
||||
|
||||
if src_card == "0 .. *":
|
||||
src_card = " " # hide cardinality
|
||||
if tgt_card == "1 .. 1":
|
||||
tgt_card = " " # hide cardinality
|
||||
|
||||
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, render_attributes=True, prefix_ids=""):
|
||||
bottom = Bottom(state)
|
||||
mm_scd = scd.SCD(mm, state)
|
||||
m_od = od.OD(mm, m, state)
|
||||
|
||||
def make_id(uuid) -> str:
|
||||
return prefix_ids+str(uuid).replace('-','_')
|
||||
|
||||
output = ""
|
||||
|
||||
# Render objects
|
||||
for class_name, class_node in mm_scd.get_classes().items():
|
||||
if render_attributes:
|
||||
attributes = od.get_attributes(bottom, class_node)
|
||||
|
||||
for obj_name, obj_node in m_od.get_objects(class_node).items():
|
||||
output += f"\nmap \"{obj_name} : {class_name}\" as {make_id(obj_node)} {{"
|
||||
|
||||
if render_attributes:
|
||||
for attr_name, attr_edge in attributes:
|
||||
slot = m_od.get_slot(obj_node, attr_name)
|
||||
if slot != None:
|
||||
output += f"\n{attr_name} => {json.dumps(od.read_primitive_value(bottom, slot, mm))}"
|
||||
output += '\n}'
|
||||
|
||||
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
|
||||
|
||||
def render_package(name, contents):
|
||||
output = ""
|
||||
output += f'\npackage "{name}" {{'
|
||||
output += contents
|
||||
output += '\n}'
|
||||
return output
|
||||
|
||||
def render_trace_ramifies(state, mm, ramified_mm, render_attributes=True, prefix_ram_ids="", prefix_orig_ids=""):
|
||||
bottom = Bottom(state)
|
||||
|
||||
mm_scd = scd.SCD(mm, state)
|
||||
ramified_mm_scd = scd.SCD(ramified_mm, state)
|
||||
|
||||
def make_ram_id(uuid) -> str:
|
||||
return prefix_ram_ids+str(uuid).replace('-','_')
|
||||
def make_orig_id(uuid) -> str:
|
||||
return prefix_orig_ids+str(uuid).replace('-','_')
|
||||
|
||||
output = ""
|
||||
|
||||
# Render RAMifies-edges between classes
|
||||
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{make_ram_id(ram_class_node)} ..> {make_orig_id(original_class)} #line:green;text:green : RAMifies"
|
||||
|
||||
if render_attributes:
|
||||
# and between attributes
|
||||
for (ram_attr_name, ram_attr_edge) in od.get_attributes(bottom, ram_class_node):
|
||||
orig_attr_edge, = bottom.read_outgoing_elements(ram_attr_edge, ramify.RAMIFIES_LABEL)
|
||||
orig_class_node = bottom.read_edge_source(orig_attr_edge)
|
||||
# dirty AF:
|
||||
orig_attr_name = mm_scd.get_class_name(orig_attr_edge)[len(original_name)+1:]
|
||||
output += f"\n{make_ram_id(ram_class_node)}::{ram_attr_name} ..> {make_orig_id(orig_class_node)}::{orig_attr_name} #line:green;text:green : RAMifies"
|
||||
|
||||
return output
|
||||
|
||||
|
||||
def render_trace_conformance(state, m, mm, render_attributes=True, prefix_inst_ids="", prefix_type_ids=""):
|
||||
bottom = Bottom(state)
|
||||
mm_scd = scd.SCD(mm, state)
|
||||
m_od = od.OD(mm, m, state)
|
||||
|
||||
def make_inst_id(uuid) -> str:
|
||||
return prefix_inst_ids+str(uuid).replace('-','_')
|
||||
def make_type_id(uuid) -> str:
|
||||
return prefix_type_ids+str(uuid).replace('-','_')
|
||||
|
||||
output = ""
|
||||
|
||||
# Render objects
|
||||
for class_name, class_node in mm_scd.get_classes().items():
|
||||
|
||||
if render_attributes:
|
||||
attributes = od.get_attributes(bottom, class_node)
|
||||
|
||||
for obj_name, obj_node in m_od.get_objects(class_node).items():
|
||||
output += f"\n{make_inst_id(obj_node)} ..> {make_type_id(class_node)} #line:blue;text:blue : instanceOf"
|
||||
|
||||
if render_attributes:
|
||||
for attr_name, attr_edge in attributes:
|
||||
slot = m_od.get_slot(obj_node, attr_name)
|
||||
if slot != None:
|
||||
output += f"\n{make_inst_id(obj_node)}::{attr_name} ..> {make_type_id(class_node)}::{attr_name} #line:blue;text:blue : instanceOf"
|
||||
|
||||
output += '\n'
|
||||
|
||||
return output
|
||||
|
||||
def render_trace_match(state, name_mapping: dict, pattern_m: UUID, host_m: UUID, color="grey", prefix_pattern_ids="", prefix_host_ids=""):
|
||||
bottom = Bottom(state)
|
||||
class_type = od.get_scd_mm_class_node(bottom)
|
||||
attr_link_type = od.get_scd_mm_attributelink_node(bottom)
|
||||
|
||||
def make_pattern_id(uuid) -> str:
|
||||
return prefix_pattern_ids+str(uuid).replace('-','_')
|
||||
def make_host_id(uuid) -> str:
|
||||
return prefix_host_ids+str(uuid).replace('-','_')
|
||||
|
||||
output = ""
|
||||
|
||||
render_suffix = f"#line:{color};line.dotted;text:{color} : matchedWith"
|
||||
|
||||
for pattern_el_name, host_el_name in name_mapping.items():
|
||||
# print(pattern_el_name, host_el_name)
|
||||
try:
|
||||
pattern_el, = bottom.read_outgoing_elements(pattern_m, pattern_el_name)
|
||||
host_el, = bottom.read_outgoing_elements(host_m, host_el_name)
|
||||
except:
|
||||
continue
|
||||
# only render 'match'-edges between objects (= those elements where the type of the type is 'Class'):
|
||||
pattern_el_type = od.get_type(bottom, pattern_el)
|
||||
pattern_el_type_type = od.get_type(bottom, pattern_el_type)
|
||||
if pattern_el_type_type == class_type:
|
||||
output += f"\n{make_pattern_id(pattern_el)} ..> {make_host_id(host_el)} {render_suffix}"
|
||||
elif pattern_el_type_type == attr_link_type:
|
||||
pattern_obj = bottom.read_edge_source(pattern_el)
|
||||
pattern_attr_name = od.get_attr_name(bottom, pattern_el_type)
|
||||
host_obj = bottom.read_edge_source(host_el)
|
||||
host_el_type = od.get_type(bottom, host_el)
|
||||
host_attr_name = od.get_attr_name(bottom, host_el_type)
|
||||
output += f"\n{make_pattern_id(pattern_obj)}::{pattern_attr_name} ..> {make_host_id(host_obj)}::{host_attr_name} {render_suffix}"
|
||||
return output
|
||||
|
||||
121
concrete_syntax/textual_od/parser.py
Normal file
121
concrete_syntax/textual_od/parser.py
Normal file
|
|
@ -0,0 +1,121 @@
|
|||
# Parser for Object Diagrams textual concrete syntax
|
||||
|
||||
from lark import Lark, logger, Transformer
|
||||
from lark.indenter import Indenter
|
||||
from services.od import OD
|
||||
from services.scd import SCD
|
||||
from uuid import UUID
|
||||
|
||||
grammar = r"""
|
||||
%import common.WS_INLINE
|
||||
%ignore WS_INLINE
|
||||
%ignore COMMENT
|
||||
|
||||
%declare _INDENT _DEDENT
|
||||
|
||||
?start: (_NL | object )*
|
||||
|
||||
IDENTIFIER: /[A-Za-z_][A-Za-z_0-9]*/
|
||||
COMMENT: /#.*/
|
||||
|
||||
# newline
|
||||
_NL: /(\r?\n[\t ]*)+/
|
||||
|
||||
literal: INT
|
||||
| STR
|
||||
| BOOL
|
||||
|
||||
INT: /[0-9]+/
|
||||
STR: /"[^"]*"/
|
||||
| /'[^']*'/
|
||||
BOOL: "True" | "False"
|
||||
|
||||
object: [IDENTIFIER] ":" IDENTIFIER [link] _NL [_INDENT slot+ _DEDENT]
|
||||
link: "(" IDENTIFIER "->" IDENTIFIER ")"
|
||||
slot: IDENTIFIER "=" literal _NL
|
||||
"""
|
||||
|
||||
|
||||
class TreeIndenter(Indenter):
|
||||
NL_type = '_NL'
|
||||
OPEN_PAREN_types = []
|
||||
CLOSE_PAREN_types = []
|
||||
INDENT_type = '_INDENT'
|
||||
DEDENT_type = '_DEDENT'
|
||||
tab_len = 4
|
||||
|
||||
parser = Lark(grammar, parser='lalr', postlex=TreeIndenter())
|
||||
|
||||
# given a concrete syntax text string, and a meta-model, parses the CS
|
||||
def parse_od(state, cs_text, mm):
|
||||
tree = parser.parse(cs_text)
|
||||
|
||||
m = state.create_node()
|
||||
od = OD(mm, m, state)
|
||||
|
||||
int_mm_id = UUID(state.read_value(state.read_dict(state.read_root(), "Integer")))
|
||||
|
||||
class T(Transformer):
|
||||
def __init__(self, visit_tokens):
|
||||
super().__init__(visit_tokens)
|
||||
self.obj_counter = 0
|
||||
|
||||
def IDENTIFIER(self, token):
|
||||
return str(token)
|
||||
|
||||
def INT(self, token):
|
||||
return int(token)
|
||||
|
||||
def BOOL(self, token):
|
||||
return token == "True"
|
||||
|
||||
def STR(self, token):
|
||||
return str(token[1:-1]) # strip the ""
|
||||
|
||||
def literal(self, el):
|
||||
return el[0]
|
||||
|
||||
def link(self, el):
|
||||
[src, tgt] = el
|
||||
return (src, tgt)
|
||||
|
||||
def slot(self, el):
|
||||
[attr_name, value] = el
|
||||
return (attr_name, value)
|
||||
|
||||
def object(self, el):
|
||||
[obj_name, type_name, link] = el[0:3]
|
||||
if obj_name == None:
|
||||
# object/link names are optional
|
||||
# generate a unique name if no name given
|
||||
obj_name = f"__o{self.obj_counter}"
|
||||
self.obj_counter += 1
|
||||
if link == None:
|
||||
obj_node = od.create_object(obj_name, type_name)
|
||||
else:
|
||||
src, tgt = link
|
||||
if tgt == "Integer":
|
||||
if state.read_dict(m, "Integer") == None:
|
||||
scd = SCD(m, state)
|
||||
scd.create_model_ref("Integer", int_mm_id)
|
||||
od.create_link(obj_name, type_name, src, tgt)
|
||||
# Create slots
|
||||
slots = el[3:]
|
||||
for attr_name, value in slots:
|
||||
value_name = f"{obj_name}.{attr_name}"
|
||||
# watch out: in Python, 'bool' is subtype of 'int'
|
||||
# so we must check for 'bool' first
|
||||
if isinstance(value, bool):
|
||||
tgt = od.create_boolean_value(value_name, value)
|
||||
elif isinstance(value, int):
|
||||
tgt = od.create_integer_value(value_name, value)
|
||||
elif isinstance(value, str):
|
||||
tgt = od.create_string_value(value_name, value)
|
||||
else:
|
||||
raise Exception("Unimplemented type "+value)
|
||||
od.create_slot(attr_name, obj_name, tgt)
|
||||
return obj_name
|
||||
|
||||
t = T(visit_tokens=True).transform(tree)
|
||||
|
||||
return m
|
||||
1
concrete_syntax/textual_od/readme.txt
Normal file
1
concrete_syntax/textual_od/readme.txt
Normal file
|
|
@ -0,0 +1 @@
|
|||
This directory contains the parser and renderer for the textual concrete syntax for Object Diagrams.
|
||||
43
concrete_syntax/textual_od/renderer.py
Normal file
43
concrete_syntax/textual_od/renderer.py
Normal file
|
|
@ -0,0 +1,43 @@
|
|||
# Renderer for Object Diagrams textual concrete syntax
|
||||
|
||||
from services import od
|
||||
from services.bottom.V0 import Bottom
|
||||
import json
|
||||
|
||||
def display_value(val: any):
|
||||
if isinstance(val, str):
|
||||
return '"'+val+'"'
|
||||
elif isinstance(val, int) or isinstance(val, bool):
|
||||
return str(val)
|
||||
else:
|
||||
raise Exception("don't know how to display value" + str(val))
|
||||
|
||||
def render_od(state, m_id, mm_id, hide_names=True):
|
||||
bottom = Bottom(state)
|
||||
output = ""
|
||||
|
||||
m_od = od.OD(mm_id, m_id, state)
|
||||
|
||||
def display_name(name: str):
|
||||
# object names that start with "__" are hidden
|
||||
return name if (name[0:2] != "__" or not hide_names) else ""
|
||||
|
||||
def write_attributes(object_node):
|
||||
o = ""
|
||||
for attr_name, slot_node in m_od.get_slots(object_node):
|
||||
value = m_od.read_slot(slot_node)
|
||||
o += f" {attr_name} = {display_value(value)}\n"
|
||||
return o
|
||||
|
||||
for class_name, objects in m_od.get_all_objects().items():
|
||||
for object_name, object_node in objects.items():
|
||||
output += f"{display_name(object_name)}:{class_name}\n"
|
||||
output += write_attributes(object_node)
|
||||
|
||||
for assoc_name, links in m_od.get_all_links().items():
|
||||
for link_name, (link_edge, src_name, tgt_name) in links.items():
|
||||
output += f"{display_name(link_name)}:{assoc_name} ({src_name} -> {tgt_name})\n"
|
||||
# links can also have slots:
|
||||
output += write_attributes(link_edge)
|
||||
|
||||
return output
|
||||
Loading…
Add table
Add a link
Reference in a new issue