docs: update architecture (eclipse-score#807)

- Include Module View
- Adapt Plotting Scripts
- Adapt Example

Author: hoe-jo

.vscode/restructuredtext.code-snippets

@@ -40,8 +40,10 @@
     gen_link_text,
     gen_struct_element,
     get_impl_comp_from_real_iface,
-    get_interface,
+    get_interface_from_component,
+    get_interface_from_int,
     get_logical_interface_real,
+    get_module,
     get_real_interface_logical,
 )
 
@@ -81,12 +83,83 @@ def scripts_directory_hash():
 #       ╰──────────────────────────────────────────────────────────────────────────────╯
 
 
-def draw_component(
-    need: dict,
-    all_needs: dict,
-    proc_real_interfaces: dict[str, str] | None = None,
-    proc_logical_interfaces: dict[str, str] | None = None,
-) -> tuple[str, str, dict[str, str], dict[str, str]]:
+def draw_comp_incl_impl_int(
+    need: dict[str, str],
+    all_needs: dict[str, dict],
+    proc_impl_interfaces: dict[str, str],
+    proc_used_interfaces: dict[str, list],
+) -> tuple[str, str, dict[str, str], dict[str, list]]:
+    # Draw outer component
+    structure_text = f"{gen_struct_element('component', need)}  {{\n"
+    linkage_text = ""
+
+    # Draw inner (sub)components recursively
+    for need_inc in need.get("includes", []):
+        curr_need = all_needs.get(need_inc, {})
+
+        # check for misspelled include
+        if not curr_need:
+            logger.info(f"{need}: include {need_inc} could not be found")
+            continue
+
+        if curr_need["type"] != "comp_arc_sta":
+            continue
+
+        sub_structure, sub_linkage, proc_impl_interfaces, proc_used_interfaces = (
+            draw_comp_incl_impl_int(
+                curr_need, all_needs, proc_impl_interfaces, proc_used_interfaces
+            )
+        )
+
+        structure_text += sub_structure
+        linkage_text += sub_linkage
+
+    # close outer component
+    structure_text += f"}} /' {need['title']} '/ \n\n"
+
+    # Find implemented real interfaces inside the module/component
+    local_impl_interfaces = get_interface_from_component(need, "implements", all_needs)
+    local_used_interfaces = get_interface_from_component(need, "uses", all_needs)
+
+    # Add all interfaces which are implemented by component to global list
+    # and provide implementation
+    for iface in local_impl_interfaces:
+        # check for misspelled implements
+        if not all_needs.get(iface, []):
+            logger.info(f"{need}: implements {iface} could not be found")
+            continue
+
+        if not (interface := proc_impl_interfaces.get(iface, [])):
+            structure_text += gen_interface_element(iface, all_needs, True)
+            linkage_text += f"{
+                gen_link_text(
+                    need,
+                    '-u->',
+                    all_needs[iface],
+                    'implements',
+                )
+            } \n"
+            proc_impl_interfaces[iface] = need["id"]
+
+    # Add all elements which are used by component to global list
+    for iface in local_used_interfaces:
+        # check for misspelled used
+        if not all_needs.get(iface, []):
+            logger.info(f"{need}: uses {iface} could not be found")
+            continue
+
+        if not (interface := proc_used_interfaces.get(iface, [])):
+            proc_used_interfaces[iface] = [need["id"]]
+        else:
+            proc_used_interfaces[iface].append(need["id"])
+
+    return structure_text, linkage_text, proc_impl_interfaces, proc_used_interfaces
+
+
+def draw_module(
+    need: dict[str, str],
+    all_needs: dict[str, dict],
+) -> tuple[str, str]:
     """
     Drawing and parsing function of a component.
 
@@ -139,76 +212,99 @@ def draw_component(
         (Structure Text, Linkage Text, Processed (Real Interfaces),
         Processed Logical Interfaces)
     """
-    proc_real_interfaces = proc_real_interfaces or dict()
-    proc_logical_interfaces = proc_logical_interfaces or dict()
+    # Store all Elements which have already been processed
+    proc_impl_interfaces = dict()
+    proc_used_interfaces = dict()
+    proc_logical_interfaces = dict()
+
     linkage_text = ""
 
-    # Draw outer component
-    structure_text = f"{gen_struct_element('component', need)}  {{\n"
+    # Draw outer module
+    structure_text = f"{gen_struct_element('package', need)}  {{\n"
 
-    # Process includes: Draw inner (sub)components recursively
+    # Draw inner components recursively
     for need_inc in need.get("includes", []):
-        curr_need = all_needs[need_inc]
+        curr_need = all_needs.get(need_inc, {})
 
-        if "comp_arc_sta" in curr_need["type"]:
-            sub_structure, sub_links, proc_real_interfaces, proc_logical_interfaces = (
-                draw_component(
-                    curr_need, all_needs, proc_real_interfaces, proc_logical_interfaces
-                )
-            )
-        else:
+        # check for misspelled include
+        if not curr_need:
+            logger.info(f"{need}: include {need_inc} could not be found")
             continue
 
+        if curr_need["type"] not in ["comp_arc_sta", "mod_view_sta"]:
+            continue
+
+        sub_structure, sub_linkage, proc_impl_interfaces, proc_used_interfaces = (
+            draw_comp_incl_impl_int(
+                curr_need, all_needs, proc_impl_interfaces, proc_used_interfaces
+            )
+        )
+
         structure_text += sub_structure
-        linkage_text += sub_links
+        linkage_text += sub_linkage
 
-    # close component
+    # close outer component
     structure_text += f"}} /' {need['title']} '/ \n\n"
 
-    local_interfaces = dict()
-    # Fill proc_real_interfaces with relation to implements and uses
-    for interface in need.get("implements", []):
-        iface = get_interface(interface, all_needs)
-        if iface not in local_interfaces:
-            local_interfaces[iface] = "implements"
-
-    for interface in need.get("uses", []):
-        iface = get_interface(interface, all_needs)
-        if iface not in local_interfaces:
-            local_interfaces[iface] = "uses"
-
-    for iface in local_interfaces:
-        # Draw interfaces
-        if iface not in proc_real_interfaces:
-            structure_text += gen_interface_element(iface, all_needs, True)
-            proc_logical_interfaces[iface] = get_logical_interface_real(
-                iface, all_needs
-            )
-            proc_real_interfaces[iface] = local_interfaces[iface]
+    # Add logical interfaces only to implemented interfaces
+    for iface, component in proc_impl_interfaces.items():
+        if not (proc_logical_interfaces.get(iface, [])):
+            # Currently only one Logical Interface per Real Interface supported
+            logical_iface_tmp = get_logical_interface_real(iface, all_needs)
+            assert (
+                len(logical_iface_tmp) == 1
+            ), "only one logical interface per real interface supported"
+            if logical_iface_tmp:
+                logical_iface = logical_iface_tmp[0]
+                proc_logical_interfaces[logical_iface] = iface
+
+                structure_text += gen_interface_element(logical_iface, all_needs, True)
+
+                linkage_text += f"{
+                    gen_link_text(
+                        all_needs[iface],
+                        '-u->',
+                        all_needs[logical_iface],
+                        'implements',
+                    )
+                } \n"
+            else:
+                print(f"{iface}: Not connected to any virtual interface")
 
-        # Draw connection between real components and interfaces
-        linkage_text += f"{
-            gen_link_text(
-                need['title'], '-->', all_needs[iface]['title'], local_interfaces[iface]
-            )
-        } \n"
+    # Add all interfaces which are used by component
+    for iface, comps in proc_used_interfaces.items():
+        if iface not in proc_impl_interfaces:
+            # Add implementing components and modules
+            impl_comp_str = get_impl_comp_from_real_iface(iface, all_needs)
 
-        # Draw connection between real interfaces and logical interfaces
-        # if link exists
-        if interfaces := proc_logical_interfaces[iface]:
-            linkage_text += f"{
-                gen_link_text(
-                    all_needs[iface]['title'],
-                    '-->',
-                    all_needs[interfaces]['title'],
-                    'implements',
-                )
-            } \n"
+            impl_comp = all_needs.get(impl_comp_str, {}) if impl_comp_str else ""
+
+            if impl_comp:
+                retval = get_module(impl_comp_str, all_needs)
+                structure_text += retval[2]  # module open
+                structure_text += retval[0]  # rest open
+
+                structure_text += retval[1]  # rest close
+                structure_text += gen_interface_element(iface, all_needs, True)
+                structure_text += retval[3]  # module close
+
+                # Draw connection between implementing components and interface
+                linkage_text += f"{gen_link_text(impl_comp, '-u->', all_needs[iface], 'implements')} \n"
+
+            else:
+                # Add only interface if component not defined
+                print(f"{iface}: No implementing component defined")
+                structure_text += gen_interface_element(iface, all_needs, True)
+
+        # Interface can be used by multiple components
+        for comp in comps:
+            # Draw connection between used interfaces and components
+            linkage_text += f"{gen_link_text(all_needs[comp], '-d[#green]->', all_needs[iface], 'uses')} \n"
 
     # Remove duplicate links
     linkage_text = "\n".join(set(linkage_text.split("\n"))) + "\n"
 
-    return structure_text, linkage_text, proc_real_interfaces, proc_logical_interfaces
+    return structure_text, linkage_text
 
 
 #       ╭──────────────────────────────────────────────────────────────────────────────╮
@@ -224,49 +320,55 @@ def __call__(self, need, all_needs: dict) -> str:
         interfacelist = []
         impl_comp = dict()
 
-        structure_text = "allowmixing\n"
-        structure_text += f'actor "Feature User" as {gen_alias("Feature User")} \n'
+        structure_text = (
+            f'actor "Feature User" as {gen_alias({"id": "Feature_User"})} \n'
+        )
 
         # Define Feature as a package
-        structure_text += f"{gen_struct_element('package', need)} {{\n"
+        # structure_text += f"{gen_struct_element('package', need)} {{\n"
 
         # Add logical Interfaces / Interface Operations (aka includes)
         for need_inc in need.get("includes", []):
             # Generate list of interfaces since both interfaces
             # and interface operations can be included
-            iface = get_interface(need_inc, all_needs)
-            interfacelist.append(iface) if iface not in interfacelist else None
+            iface = get_interface_from_int(need_inc, all_needs)
+            if iface not in interfacelist:
+                interfacelist.append(iface)
 
         for iface in interfacelist:
             structure_text += gen_interface_element(iface, all_needs, True)
 
             # Determine Components which implement the interfaces
             real_iface = get_real_interface_logical(iface, all_needs)
-            impl_comp[iface] = get_impl_comp_from_real_iface(real_iface[0], all_needs)
+            if real_iface:
+                comps = get_impl_comp_from_real_iface(real_iface[0], all_needs)
 
-            if imcomp := impl_comp[iface]:
+                if comps:
+                    impl_comp[iface] = comps
+
+            if imcomp := impl_comp.get(iface):
                 structure_text += (
-                    f"{gen_struct_element('component', all_needs[imcomp[0]])}\n"
+                    f"{gen_struct_element('component', all_needs[imcomp])}\n"
                 )
 
         # Close Package
-        structure_text += f"}} /' {need['title']}  '/ \n\n"
+        # structure_text += f"}} /' {need['title']}  '/ \n\n"
 
         link_text = ""
 
         for iface in interfacelist:
             # Add relation between Actor and Interfaces
             link_text += f"{
-                gen_link_text('Feature User', '-d->', all_needs[iface]['title'], 'use')
+                gen_link_text({'id': 'Feature_User'}, '-d->', all_needs[iface], 'use')
             } \n"
 
             # Add relation between interface and component
-            if imcomp := impl_comp[iface]:
+            if imcomp := impl_comp.get(iface):
                 link_text += f"{
                     gen_link_text(
-                        all_needs[imcomp[0]]['title'],
-                        '-->',
-                        all_needs[iface]['title'],
+                        all_needs[imcomp],
+                        '-u->',
+                        all_needs[iface],
                         'implements',
                     )
                 } \n"
@@ -276,20 +378,25 @@ def __call__(self, need, all_needs: dict) -> str:
         return gen_header() + structure_text + link_text
 
 
+class draw_full_module:
+    def __repr__(self):
+        return "draw_full_module" + " in " + scripts_directory_hash()
+
+    def __call__(self, need, all_needs) -> str:
+        structure_text, linkage_text = draw_module(need, all_needs)
+
+        return gen_header() + structure_text + linkage_text
+
+
 class draw_full_component:
     def __repr__(self):
         return "draw_full_component" + " in " + scripts_directory_hash()
 
     def __call__(self, need, all_needs) -> str:
         structure_text, linkage_text, processed_interfaces, logical_interfacelist = (
-            draw_component(need, all_needs, dict(), dict())
+            draw_comp_incl_impl_int(need, all_needs, dict(), dict())
         )
 
-        # Draw Logical Interfaces
-        for iface in logical_interfacelist:
-            if log_int := logical_interfacelist[iface]:
-                structure_text += gen_interface_element(log_int, all_needs, True)
-
         return gen_header() + structure_text + linkage_text
 
 
@@ -305,6 +412,7 @@ def __call__(self, need, all_needs) -> str:
 
 draw_uml_function_context = {
     "draw_interface": draw_full_interface(),
+    "draw_module": draw_full_module(),
     "draw_component": draw_full_component(),
     "draw_feature": draw_full_feature(),
 }