Class diagram can be rendered as object diagram textual syntax, and parsed back, without information loss

concrete_syntax/textual_od/parser.py

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

concrete_syntax/textual_od/readme.txt

@@ -0,0 +1 @@
+This directory contains the parser and renderer for the textual concrete syntax for Object Diagrams.

concrete_syntax/textual_od/renderer.py

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