etassia 0.1.0

data/lib/etassia/notation/mermaid/ir_adapters/architecture.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+require_relative "../../../ir"
+
+module Etassia
+  module Notation
+    module Mermaid
+      module IRAdapters
+        # Maps Mermaid's private Architecture model to a notation-neutral graph.
+        module Architecture
+          module_function
+
+          def call(diagram)
+            occupied = []
+            identities = entity_identities(diagram, occupied)
+            entities = entity_nodes(diagram, identities, occupied)
+            details, edges = connection_records(diagram, identities, occupied)
+            settings = settings_nodes(diagram, occupied)
+            nodes = entities + details + settings
+            IR::Graph.new(
+              **graph_attributes(diagram, nodes, edges, occupied),
+            )
+          end
+
+          def entity_identities(diagram, occupied)
+            {
+              groups: identity_map(diagram.groups, occupied, "group"),
+              services: identity_map(diagram.services, occupied, "service"),
+              junctions: identity_map(diagram.junctions, occupied, "junction"),
+            }
+          end
+
+          def identity_map(items, occupied, fallback)
+            items.each_with_index.to_h do |item, index|
+              preferred = item.id.to_s.empty? ? "#{fallback}_#{index}" : item.id
+              [item, reserve_id(preferred, occupied)]
+            end
+          end
+
+          def entity_nodes(diagram, identities, occupied)
+            group_index = source_index(diagram.groups, identities[:groups])
+            group_nodes(diagram, identities, group_index, occupied) +
+              member_nodes(diagram.services, "service", identities[:services],
+                           group_index, occupied) +
+              member_nodes(diagram.junctions, "junction",
+                           identities[:junctions], group_index, occupied)
+          end
+
+          def group_nodes(diagram, identities, group_index, occupied)
+            diagram.groups.flat_map do |group|
+              group_node(group, identities[:groups], group_index, occupied)
+            end
+          end
+
+          def member_nodes(members, role, identities, group_index, occupied)
+            members.flat_map do |member|
+              member_node(member, role, identities, group_index, occupied)
+            end
+          end
+
+          def source_index(items, identities)
+            items.each_with_object({}) do |item, index|
+              index[item.id] ||= identities.fetch(item)
+            end
+          end
+
+          def group_node(group, identities, group_index, occupied)
+            id = identities.fetch(group)
+            node = IR::Node.new(
+              id: id, label: group.label, role: "group",
+              parent_id: group_index[group.parent_id]
+            )
+            values = [
+              ["original_identifier", group.id], ["icon", group.icon],
+              ["parent_identifier", group.parent_id]
+            ]
+            [node, *semantic_nodes(id, values, occupied)]
+          end
+
+          def member_node(member, role, identities, group_index, occupied)
+            id = identities.fetch(member)
+            group_id = member.group_id
+            node = IR::Node.new(
+              id: id, label: member.respond_to?(:label) ? member.label : nil,
+              role: role, parent_id: group_index[group_id]
+            )
+            values = [["original_identifier", member.id],
+                      ["group_identifier", group_id]]
+            values << ["icon", member.icon] if member.respond_to?(:icon)
+            [node, *semantic_nodes(id, values, occupied)]
+          end
+
+          def connection_records(diagram, identities, occupied)
+            endpoints = endpoint_index(diagram, identities)
+            records = diagram.edges.filter_map.with_index do |edge, index|
+              connection_record(edge, index, endpoints, occupied)
+            end
+            [records.flat_map(&:first), records.map(&:last)]
+          end
+
+          def endpoint_index(diagram, identities)
+            nodes = diagram.services + diagram.junctions
+            ids = identities[:services].merge(identities[:junctions])
+            source_index(nodes, ids)
+          end
+
+          def connection_record(edge, index, endpoints, occupied)
+            source_id = endpoints[edge.from_id]
+            target_id = endpoints[edge.to_id]
+            return unless source_id && target_id
+
+            details_id = reserve_id("connection_details_#{index}", occupied)
+            details = connection_details(edge, details_id, occupied)
+            connection = IR::Edge.new(**connection_attributes(
+              edge, index, details_id, [source_id, target_id], occupied
+            ))
+            [details, connection]
+          end
+
+          def connection_attributes(edge, index, details_id, endpoint_ids,
+                                    occupied)
+            source_id, target_id = endpoint_ids
+            {
+              id: reserve_id("connection_#{index}", occupied),
+              label: edge.label, role: "directed_connection",
+              parent_id: details_id, source_id: source_id,
+              target_id: target_id,
+              properties: IR::PropertySet.new(target_marker: "arrow")
+            }
+          end
+
+          def connection_details(edge, details_id, occupied)
+            node = IR::Node.new(id: details_id, role: "connection_details")
+            values = [
+              ["source_position", edge.from_position],
+              ["target_position", edge.to_position],
+            ]
+            [node, *semantic_nodes(details_id, values, occupied)]
+          end
+
+          def settings_nodes(diagram, occupied)
+            id = reserve_id("diagram_settings", occupied)
+            values = [
+              ["diagram_identifier", diagram.id],
+              ["layout_direction", diagram.direction],
+              ["theme", diagram.theme],
+            ]
+            [IR::Node.new(id: id, role: "diagram_settings"),
+             *semantic_nodes(id, values, occupied)]
+          end
+
+          def semantic_nodes(parent_id, values, occupied)
+            values.filter_map do |role, value|
+              next if value.nil?
+
+              IR::Node.new(
+                id: reserve_id("#{parent_id}_#{role}", occupied),
+                label: value.to_s, role: role, parent_id: parent_id
+              )
+            end
+          end
+
+          def graph_attributes(diagram, nodes, edges, occupied)
+            {
+              id: reserve_id(diagram.id || "architecture", occupied),
+              label: diagram.title, role: "architecture_graph",
+              accessibility_title: diagram.acc_title,
+              accessibility_description: diagram.acc_descr,
+              nodes: nodes, edges: edges
+            }
+          end
+
+          def reserve_id(preferred, occupied)
+            preferred = preferred.to_s
+            preferred = "item" if preferred.empty?
+            candidate = preferred
+            suffix = 2
+            while occupied.include?(candidate)
+              candidate = "#{preferred}_#{suffix}"
+              suffix += 1
+            end
+            occupied << candidate
+            candidate
+          end
+          private_class_method :entity_identities, :identity_map,
+                               :entity_nodes, :group_nodes, :member_nodes,
+                               :source_index, :group_node, :member_node,
+                               :connection_records, :endpoint_index,
+                               :connection_record, :connection_attributes,
+                               :connection_details, :settings_nodes,
+                               :semantic_nodes, :graph_attributes, :reserve_id
+        end
+      end
+    end
+  end
+end

data/lib/etassia/notation/mermaid/ir_adapters/block.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require_relative "../../../ir"
+
+module Etassia
+  module Notation
+    module Mermaid
+      module IRAdapters
+        # Maps Mermaid's private Block model to a notation-neutral grid.
+        module Block
+          module_function
+
+          def call(diagram)
+            entries = flatten(diagram.blocks)
+            occupied = []
+            ids = ids_for(entries, occupied)
+            build_document(diagram, entries, ids, occupied)
+          end
+
+          def ids_for(entries, occupied)
+            entries.each_with_object({}.compare_by_identity) do |entry, ids|
+              block, _parent, index = entry
+              preferred = block.id || "block_#{index}"
+              ids[block] = reserve_id(preferred, occupied)
+            end
+          end
+
+          def build_document(diagram, entries, ids, occupied)
+            root_id = reserve_id(diagram.id || "block", occupied)
+            settings = settings_item(diagram.columns, occupied)
+            IR::Prepositioned.new(
+              id: root_id, label: diagram.title, role: "column_grid",
+              items: [settings, *block_items(entries, ids)].compact,
+              connections: connections(
+                diagram.connections, entries, ids, occupied
+              )
+            )
+          end
+
+          def block_items(entries, ids)
+            entries.map do |block, parent, index|
+              block_item(block, parent, index, ids)
+            end
+          end
+
+          def flatten(blocks, parent = nil, entries = [])
+            blocks.each do |block|
+              entries << [block, parent, entries.length]
+              flatten(block.children, block, entries)
+            end
+            entries
+          end
+
+          def settings_item(columns, occupied)
+            return if columns.nil?
+
+            IR::PrepositionedItem.new(
+              id: reserve_id("layout_settings", occupied),
+              role: "layout_settings",
+              placements: [placement("column_count", 0, number: columns)],
+            )
+          end
+
+          def block_item(block, parent, index, ids)
+            IR::PrepositionedItem.new(
+              id: ids.fetch(block), label: block.label,
+              role: block.block_type || "block",
+              parent_id: parent && ids.fetch(parent),
+              placements: block_placements(block, index)
+            )
+          end
+
+          def block_placements(block, index)
+            placements = [
+              placement("source_order", 0, number: index),
+              placement("column_span", 1, number: block.width || 1),
+              placement("compound", 2, boolean: block.compound?),
+            ]
+            if block.shape
+              placements << placement("shape", 3, text: block.shape)
+            end
+            if block.direction
+              placements << placement("direction", 4, text: block.direction)
+            end
+            placements
+          end
+
+          def connections(source, entries, ids, occupied)
+            ids_by_source = source_ids(entries, ids)
+            source.filter_map.with_index do |connection, index|
+              source_id = ids_by_source[connection.from]
+              target_id = ids_by_source[connection.to]
+              next unless source_id && target_id
+
+              edge(connection, index, source_id, target_id, occupied)
+            end
+          end
+
+          def source_ids(entries, ids)
+            entries.to_h do |block, _parent, _index|
+              [block.id, ids.fetch(block)]
+            end
+          end
+
+          def edge(connection, index, source_id, target_id, occupied)
+            IR::Edge.new(
+              id: reserve_id("edge_#{index}", occupied),
+              label: connection.label, role: connection.connection_type,
+              source_id: source_id, target_id: target_id
+            )
+          end
+
+          def placement(dimension, ordinal, **scalar)
+            IR::Placement.new(
+              dimension: dimension, ordinal: ordinal,
+              value: IR::Scalar.new(scalar)
+            )
+          end
+
+          def reserve_id(preferred, occupied)
+            candidate = preferred
+            suffix = 2
+            while occupied.include?(candidate)
+              candidate = "#{preferred}_#{suffix}"
+              suffix += 1
+            end
+            occupied << candidate
+            candidate
+          end
+          private_class_method :ids_for, :build_document, :block_items,
+                               :flatten, :settings_item, :block_item,
+                               :block_placements, :connections, :source_ids,
+                               :edge, :placement, :reserve_id
+        end
+      end
+    end
+  end
+end

data/lib/etassia/notation/mermaid/ir_adapters/c4.rb

@@ -0,0 +1,258 @@
+# frozen_string_literal: true
+
+require_relative "../../../ir"
+
+module Etassia
+  module Notation
+    module Mermaid
+      module IRAdapters
+        # Maps Mermaid's private C4 model to a notation-neutral graph.
+        module C4
+          ELEMENT_ROLES = {
+            "Person" => "person",
+            "System" => "system",
+            "SystemDb" => "system_database",
+            "SystemQueue" => "system_queue",
+            "Container" => "container",
+            "ContainerDb" => "container_database",
+            "ContainerQueue" => "container_queue",
+            "Component" => "component",
+          }.freeze
+          BOUNDARY_ROLES = {
+            "Enterprise_Boundary" => "enterprise_boundary",
+            "System_Boundary" => "system_boundary",
+            "Boundary" => "boundary",
+          }.freeze
+          private_constant :ELEMENT_ROLES, :BOUNDARY_ROLES
+
+          module_function
+
+          def call(diagram)
+            occupied = []
+            boundary_ids = identity_map(diagram.boundaries, occupied,
+                                        "boundary")
+            element_ids = identity_map(diagram.elements, occupied, "element")
+            nodes, edges = graph_contents(
+              diagram, boundary_ids, element_ids, occupied
+            )
+            IR::Graph.new(**graph_attributes(diagram, nodes, edges, occupied))
+          end
+
+          def graph_contents(diagram, boundary_ids, element_ids, occupied)
+            nodes = entity_nodes(diagram, boundary_ids, element_ids, occupied)
+            relationship_nodes, edges = relationships(
+              diagram, element_ids, occupied
+            )
+            nodes.concat(relationship_nodes)
+            nodes.concat(settings_nodes(diagram, occupied))
+            [nodes, edges]
+          end
+
+          def graph_attributes(diagram, nodes, edges, occupied)
+            {
+              id: reserve_id(diagram.id || "c4", occupied),
+              label: diagram.title, role: "architecture_graph",
+              nodes: nodes, edges: edges
+            }
+          end
+
+          def identity_map(items, occupied, fallback)
+            items.each_with_index.to_h do |item, index|
+              preferred = item.id.to_s.empty? ? "#{fallback}_#{index}" : item.id
+              [item, reserve_id(preferred, occupied)]
+            end
+          end
+
+          def entity_nodes(diagram, boundary_ids, element_ids, occupied)
+            boundary_index = source_index(diagram.boundaries, boundary_ids)
+            boundaries = boundary_nodes(
+              diagram.boundaries, boundary_ids, boundary_index, occupied
+            )
+            elements = element_nodes(
+              diagram.elements, element_ids, boundary_index, occupied
+            )
+            boundaries + elements
+          end
+
+          def boundary_nodes(boundaries, identities, parent_index, occupied)
+            boundaries.flat_map do |boundary|
+              boundary_node(boundary, identities, parent_index, occupied)
+            end
+          end
+
+          def element_nodes(elements, identities, parent_index, occupied)
+            elements.flat_map do |element|
+              element_node(element, identities, parent_index, occupied)
+            end
+          end
+
+          def source_index(items, identities)
+            items.each_with_object({}) do |item, index|
+              index[item.id] ||= identities.fetch(item)
+            end
+          end
+
+          def boundary_node(boundary, identities, parent_index, occupied)
+            id = identities.fetch(boundary)
+            node = IR::Node.new(
+              id: id, label: boundary.label, role: boundary_role(boundary),
+              parent_id: parent_index[boundary.parent_id]
+            )
+            details = semantic_nodes(
+              id, boundary_values(boundary), occupied
+            )
+            [node, *details]
+          end
+
+          def boundary_values(boundary)
+            [["original_identifier", boundary.id],
+             ["boundary_type", boundary.boundary_type],
+             ["parent_identifier", boundary.parent_id],
+             ["type_label", boundary.type_param], ["link", boundary.link],
+             ["tags", boundary.tags]]
+          end
+
+          def element_node(element, identities, boundary_index, occupied)
+            id = identities.fetch(element)
+            node = IR::Node.new(
+              id: id, label: element.label, role: element_role(element),
+              parent_id: boundary_index[element.boundary_id]
+            )
+            details = semantic_nodes(id, element_values(element), occupied)
+            [node, *details]
+          end
+
+          def element_values(element)
+            [["original_identifier", element.id],
+             ["element_type", element.element_type],
+             ["boundary_identifier", element.boundary_id],
+             ["description", element.description],
+             ["technology", element.technology], ["sprite", element.sprite],
+             ["link", element.link], ["tags", element.tags],
+             ["external", element.external]]
+          end
+
+          def relationships(diagram, identities, occupied)
+            element_index = source_index(diagram.elements, identities)
+            records = diagram.relationships.map.with_index do |relation, index|
+              relationship_record(
+                relation, index, element_index, occupied
+              )
+            end
+            [records.flat_map(&:first), records.map(&:last)]
+          end
+
+          def relationship_record(relation, index, element_index, occupied)
+            detail_id = reserve_id("relationship_details_#{index}", occupied)
+            details = relationship_details(relation, detail_id, occupied)
+            edge = relationship_edge(
+              relation, index, detail_id, element_index, occupied
+            )
+            [details, edge]
+          end
+
+          def relationship_details(relation, detail_id, occupied)
+            node = IR::Node.new(
+              id: detail_id, role: "relationship_details",
+            )
+            values = relationship_values(relation)
+            [node, *semantic_nodes(detail_id, values, occupied)]
+          end
+
+          def relationship_values(relationship)
+            [["relationship_type", relationship.rel_type],
+             ["technology", relationship.technology]]
+          end
+
+          def relationship_edge(relationship, index, detail_id, elements,
+                                occupied)
+            attributes = relationship_attributes(
+              relationship, index, detail_id, elements, occupied
+            )
+            IR::Edge.new(**attributes)
+          end
+
+          def relationship_attributes(relationship, index, detail_id,
+                                      elements, occupied)
+            bidirectional = relationship.bidirectional?
+            {
+              id: reserve_id("relationship_#{index}", occupied),
+              label: relationship.label,
+              role: relationship_role(bidirectional),
+              parent_id: detail_id, source_id: elements[relationship.from_id],
+              target_id: elements[relationship.to_id],
+              properties: relationship_properties(bidirectional)
+            }
+          end
+
+          def relationship_properties(bidirectional)
+            IR::PropertySet.new(
+              source_marker: bidirectional ? "arrow" : nil,
+              target_marker: "arrow",
+            )
+          end
+
+          def relationship_role(bidirectional)
+            return "bidirectional_relationship" if bidirectional
+
+            "relationship"
+          end
+
+          def settings_nodes(diagram, occupied)
+            id = reserve_id("diagram_settings", occupied)
+            values = [
+              ["diagram_identifier", diagram.id], ["level", diagram.level],
+              ["layout_intent", diagram.layout_config]
+            ]
+            [IR::Node.new(id: id, role: "diagram_settings"),
+             *semantic_nodes(id, values, occupied)]
+          end
+
+          def semantic_nodes(parent_id, values, occupied)
+            values.filter_map do |role, value|
+              next if value.nil?
+
+              IR::Node.new(
+                id: reserve_id("#{parent_id}_#{role}", occupied),
+                label: value.to_s, role: role, parent_id: parent_id
+              )
+            end
+          end
+
+          def element_role(element)
+            ELEMENT_ROLES.fetch(element.base_type, "element")
+          end
+
+          def boundary_role(boundary)
+            BOUNDARY_ROLES.fetch(boundary.boundary_type, "boundary")
+          end
+
+          def reserve_id(preferred, occupied)
+            preferred = preferred.to_s
+            preferred = "item" if preferred.empty?
+            candidate = preferred
+            suffix = 2
+            while occupied.include?(candidate)
+              candidate = "#{preferred}_#{suffix}"
+              suffix += 1
+            end
+            occupied << candidate
+            candidate
+          end
+          private_class_method :graph_contents, :graph_attributes,
+                               :identity_map, :entity_nodes, :boundary_nodes,
+                               :element_nodes, :source_index, :boundary_node,
+                               :boundary_values, :element_node,
+                               :element_values, :relationships,
+                               :relationship_record, :relationship_values,
+                               :relationship_details, :relationship_edge,
+                               :relationship_attributes,
+                               :relationship_properties, :relationship_role,
+                               :settings_nodes,
+                               :semantic_nodes, :element_role, :boundary_role,
+                               :reserve_id
+        end
+      end
+    end
+  end
+end