etassia 0.1.0

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

@@ -0,0 +1,257 @@
+# frozen_string_literal: true
+
+require_relative "../../../ir"
+
+module Etassia
+  module Notation
+    module Mermaid
+      module IRAdapters
+        # Maps Mermaid's private Class Diagram model to a neutral graph.
+        module ClassDiagram
+          MARKERS = {
+            "inheritance" => "triangle",
+            "composition" => "filled_diamond",
+            "aggregation" => "hollow_diamond",
+            "dependency" => "arrow",
+            "realization" => "triangle",
+          }.freeze
+          private_constant :MARKERS
+
+          module_function
+
+          def call(diagram)
+            occupied = []
+            entities = entity_records(diagram.entities, occupied)
+            nodes, edges = graph_contents(diagram, entities, occupied)
+            IR::Graph.new(**graph_attributes(diagram, nodes, edges, occupied))
+          end
+
+          def graph_contents(diagram, entities, occupied)
+            nodes = entities.flat_map do |entity, id|
+              entity_record(entity, id, occupied)
+            end
+            relationship_nodes, edges = relationship_records(
+              Array(diagram.relationships), entities, occupied
+            )
+            nodes += relationship_nodes + note_nodes(diagram, occupied) +
+              namespace_nodes(diagram, occupied) +
+              settings_nodes(diagram, occupied)
+            [nodes, edges]
+          end
+
+          def graph_attributes(diagram, nodes, edges, occupied)
+            {
+              id: reserve_id(diagram.id || "class_diagram", occupied),
+              label: diagram.title, role: "class_graph",
+              nodes: nodes, edges: edges
+            }
+          end
+
+          def entity_records(entities, occupied)
+            entities.each_with_index.map do |entity, index|
+              preferred = entity.id.to_s.empty? ? "class_#{index}" : entity.id
+              [entity, reserve_id(preferred, occupied)]
+            end
+          end
+
+          def entity_record(entity, id, occupied)
+            node = IR::Node.new(id: id, label: entity.name, role: "class")
+            fields = semantic_nodes(
+              id,
+              [["original_identifier", entity.id],
+               ["stereotype", entity.stereotype]],
+              occupied,
+            )
+            members = member_records(entity, id, occupied)
+            [node, *fields, *members]
+          end
+
+          def member_records(entity, parent_id, occupied)
+            attributes = records_for(
+              entity.attributes, parent_id, "attribute", occupied
+            )
+            methods = records_for(
+              entity.class_methods, parent_id, "operation", occupied
+            )
+            attributes + methods
+          end
+
+          def records_for(members, parent_id, role, occupied)
+            members.flat_map.with_index do |member, index|
+              member_record(member, parent_id, role, index, occupied)
+            end
+          end
+
+          def member_record(member, parent_id, role, index, occupied)
+            id = reserve_id("#{parent_id}_#{role}_#{index}", occupied)
+            node = IR::Node.new(
+              id: id, label: member.display_text, role: role,
+              parent_id: parent_id
+            )
+            [node, *semantic_nodes(id, member_values(member, role), occupied)]
+          end
+
+          def member_values(member, role)
+            return attribute_values(member) if role == "attribute"
+
+            operation_values(member)
+          end
+
+          def attribute_values(attribute)
+            [["name", attribute.name], ["type", attribute.type],
+             ["visibility", attribute.visibility],
+             ["source_text", attribute.text]]
+          end
+
+          def operation_values(operation)
+            [["name", operation.name], ["parameters", operation.parameters],
+             ["return_type", operation.return_type],
+             ["visibility", operation.visibility],
+             ["source_text", operation.text]]
+          end
+
+          def relationship_records(relationships, entities, occupied)
+            endpoints = endpoint_index(entities)
+            records = relationships.map.with_index do |relationship, index|
+              relationship_record(
+                relationship, index, endpoints, occupied
+              )
+            end
+            [records.flat_map(&:first), records.map(&:last)]
+          end
+
+          def endpoint_index(entities)
+            entities.each_with_object({}) do |(entity, id), index|
+              index[entity.id] ||= id
+            end
+          end
+
+          def relationship_record(relationship, index, endpoints, occupied)
+            detail_id = reserve_id("relationship_details_#{index}", occupied)
+            details = relationship_details(relationship, detail_id, occupied)
+            edge = relationship_edge(
+              relationship, index, detail_id, endpoints, occupied
+            )
+            [details, edge]
+          end
+
+          def relationship_edge(relationship, index, detail_id, endpoints,
+                                occupied)
+            IR::Edge.new(
+              id: reserve_id("relationship_#{index}", occupied),
+              label: relationship.label, role: "class_relationship",
+              parent_id: detail_id,
+              source_id: endpoints[relationship.from_id],
+              target_id: endpoints[relationship.to_id],
+              properties: relationship_properties(relationship)
+            )
+          end
+
+          def relationship_details(relationship, id, occupied)
+            node = IR::Node.new(id: id, role: "relationship_details")
+            values = [
+              ["relationship_type", relationship.relationship_type],
+              ["source_cardinality", relationship.source_cardinality],
+              ["target_cardinality", relationship.target_cardinality],
+              ["source_marker", relationship.start_marker],
+              ["target_marker", relationship.end_marker],
+              ["dashed", relationship.dashed],
+              ["written_reversed", relationship.written_reversed],
+            ]
+            [node, *semantic_nodes(id, values, occupied)]
+          end
+
+          def relationship_properties(relationship)
+            source, target = explicit_markers(relationship)
+            if source.nil? && target.nil?
+              source, target = implied_markers(relationship.relationship_type)
+            end
+            IR::PropertySet.new(source_marker: source, target_marker: target)
+          end
+
+          def explicit_markers(relationship)
+            [MARKERS[relationship.start_marker],
+             MARKERS[relationship.end_marker]]
+          end
+
+          def implied_markers(type)
+            marker = MARKERS[type]
+            return [marker, nil] if %w[composition aggregation].include?(type)
+
+            [nil, marker]
+          end
+
+          def note_nodes(diagram, occupied)
+            Array(diagram.notes).flat_map.with_index do |note, index|
+              id = reserve_id("note_#{index}", occupied)
+              node = IR::Node.new(id: id, label: note.text, role: "note")
+              [node, *semantic_nodes(id, [["target", note.target_id]],
+                                     occupied)]
+            end
+          end
+
+          def namespace_nodes(diagram, occupied)
+            Array(diagram.namespaces).flat_map do |namespace|
+              id = reserve_id("namespace_#{namespace.name}", occupied)
+              node = IR::Node.new(id: id, label: namespace.name,
+                                  role: "namespace")
+              members = namespace.class_ids.map { |value| ["member", value] }
+              [node, *semantic_nodes(id, members, occupied)]
+            end
+          end
+
+          def settings_nodes(diagram, occupied)
+            id = reserve_id("diagram_settings", occupied)
+            values = [
+              ["diagram_identifier", diagram.id],
+              ["layout_direction", diagram.direction],
+              ["theme", diagram.theme],
+              ["font_family", diagram.font_family],
+            ]
+            [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 reserve_id(preferred, occupied)
+            preferred = preferred.to_s
+            preferred = "item" if preferred.empty?
+            candidate = unique_id(preferred, occupied)
+            occupied << candidate
+            candidate
+          end
+
+          def unique_id(preferred, occupied)
+            return preferred unless occupied.include?(preferred)
+
+            suffix = 2
+            suffix += 1 while occupied.include?("#{preferred}_#{suffix}")
+            "#{preferred}_#{suffix}"
+          end
+          private_class_method :graph_contents, :graph_attributes,
+                               :entity_records, :entity_record,
+                               :member_records, :records_for, :member_record,
+                               :member_values,
+                               :attribute_values, :operation_values,
+                               :relationship_records, :endpoint_index,
+                               :relationship_record, :relationship_edge,
+                               :relationship_details,
+                               :relationship_properties, :explicit_markers,
+                               :implied_markers, :note_nodes, :namespace_nodes,
+                               :settings_nodes,
+                               :semantic_nodes, :reserve_id, :unique_id
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,220 @@
+# frozen_string_literal: true
+
+require_relative "../../../ir"
+
+module Etassia
+  module Notation
+    module Mermaid
+      module IRAdapters
+        # Maps the private ER diagram model to a notation-neutral graph.
+        module ErDiagram
+          module_function
+
+          def call(diagram)
+            occupied = []
+            nodes, edges = graph_contents(diagram, occupied)
+            IR::Graph.new(**graph_attributes(
+              diagram, nodes, edges, occupied
+            ))
+          end
+
+          def graph_contents(diagram, occupied)
+            identities = entity_identities(diagram.entities, occupied)
+            entities = entity_nodes(diagram.entities, identities, occupied)
+            details, edges = relationship_records(
+              diagram.relationships, identities, occupied
+            )
+            styles = style_nodes(class_definitions(diagram), occupied)
+            settings = settings_nodes(diagram, occupied)
+            [entities + details + styles + settings, edges]
+          end
+
+          def class_definitions(diagram)
+            # The accessor initializes an ivar; query a copy to remain pure.
+            diagram.dup.class_defs
+          end
+
+          def entity_identities(entities, occupied)
+            entities.each_with_index
+              .with_object({}.compare_by_identity) do |entry, identities|
+              entity, index = entry
+              preferred = entity.id.to_s.empty? ? "entity_#{index}" : entity.id
+              identities[entity] = reserve_id(preferred, occupied)
+            end
+          end
+
+          def entity_nodes(entities, identities, occupied)
+            entities.flat_map.with_index do |entity, index|
+              entity_record(entity, index, identities.fetch(entity), occupied)
+            end
+          end
+
+          def entity_record(entity, index, id, occupied)
+            node = IR::Node.new(id: id, label: entity.name, role: "entity")
+            values = [["original_identifier", entity.id],
+                      ["sequence_index", index]]
+            semantics = semantic_nodes(id, values, occupied)
+            classes = semantic_values(
+              id, "style_reference", entity.classes, occupied
+            )
+            attributes = attribute_nodes(entity.attributes, id, occupied)
+            [node, *semantics, *classes, *attributes]
+          end
+
+          def attribute_nodes(attributes, parent_id, occupied)
+            attributes.map.with_index.flat_map do |attribute, index|
+              attribute_record(attribute, index, parent_id, occupied)
+            end
+          end
+
+          def attribute_record(attribute, index, parent_id, occupied)
+            id = reserve_id("#{parent_id}_attribute_#{index}", occupied)
+            node = IR::Node.new(
+              id: id, label: attribute.name, role: "attribute",
+              parent_id: parent_id
+            )
+            values = [
+              ["attribute_type", attribute.attribute_type],
+              ["key_type", attribute.key_type], ["note", attribute.note],
+              ["sequence_index", index]
+            ]
+            [node, *semantic_nodes(id, values, occupied)]
+          end
+
+          def relationship_records(relationships, identities, occupied)
+            endpoints = source_index(identities)
+            records = relationships.filter_map.with_index do |relation, index|
+              relationship_record(relation, index, endpoints, occupied)
+            end
+            [records.flat_map(&:first), records.map(&:last)]
+          end
+
+          def relationship_record(relation, index, endpoints, occupied)
+            ids = [endpoints[relation.from_id], endpoints[relation.to_id]]
+            return unless ids.all?
+
+            detail_id = reserve_id("relationship_#{index}_details", occupied)
+            details = relationship_details(relation, index, detail_id, occupied)
+            edge = relationship_edge(relation, index, detail_id, ids, occupied)
+            [details, edge]
+          end
+
+          def relationship_details(relationship, index, id, occupied)
+            values = [
+              ["relationship_type", relationship.relationship_type],
+              ["source_cardinality", relationship.cardinality_from],
+              ["target_cardinality", relationship.cardinality_to],
+              ["sequence_index", index],
+            ]
+            [IR::Node.new(id: id, role: "relationship_details"),
+             *semantic_nodes(id, values, occupied)]
+          end
+
+          def relationship_edge(relationship, index, details_id, endpoints,
+                                occupied)
+            IR::Edge.new(
+              id: reserve_id("relationship_#{index}", occupied),
+              label: relationship.label, role: relationship_role(relationship),
+              parent_id: details_id, source_id: endpoints.first,
+              target_id: endpoints.last,
+              properties: relationship_properties(relationship)
+            )
+          end
+
+          def relationship_properties(relationship)
+            IR::PropertySet.new(
+              source_marker: relationship.cardinality_from,
+              target_marker: relationship.cardinality_to,
+            )
+          end
+
+          def relationship_role(relationship)
+            return "identifying_relationship" if relationship.identifying?
+
+            "non_identifying_relationship"
+          end
+
+          def style_nodes(class_defs, occupied)
+            class_defs.flat_map.with_index do |(name, declaration), index|
+              id = reserve_id("style_class_#{index}", occupied)
+              node = IR::Node.new(id: id, label: name, role: "style_class")
+              values = [["style_declaration", declaration],
+                        ["sequence_index", index]]
+              [node, *semantic_nodes(id, values, occupied)]
+            end
+          end
+
+          def settings_nodes(diagram, occupied)
+            id = reserve_id("diagram_settings", occupied)
+            values = [
+              ["diagram_identifier", diagram.id],
+              ["layout_direction", diagram.direction],
+              ["theme_reference", 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?
+
+              semantic_node(parent_id, role, value, occupied)
+            end
+          end
+
+          def semantic_values(parent_id, role, values, occupied)
+            values.map do |value|
+              semantic_node(parent_id, role, value, occupied)
+            end
+          end
+
+          def semantic_node(parent_id, role, value, occupied)
+            IR::Node.new(
+              id: reserve_id("#{parent_id}_#{role}", occupied),
+              label: value.to_s, role: role, parent_id: parent_id
+            )
+          end
+
+          def source_index(identities)
+            identities.each_with_object({}) do |(entity, id), index|
+              index[entity.id] ||= id
+            end
+          end
+
+          def graph_attributes(diagram, nodes, edges, occupied)
+            {
+              id: reserve_id(diagram.id || "er_diagram", occupied),
+              label: diagram.title, role: "entity_relationship_graph",
+              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 :graph_contents, :class_definitions,
+                               :entity_identities,
+                               :entity_nodes,
+                               :entity_record, :attribute_nodes,
+                               :attribute_record, :relationship_records,
+                               :relationship_record, :relationship_details,
+                               :relationship_edge, :relationship_properties,
+                               :relationship_role,
+                               :style_nodes, :settings_nodes, :semantic_nodes,
+                               :semantic_values, :semantic_node, :source_index,
+                               :graph_attributes, :reserve_id
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative "../../../ir"
+
+module Etassia
+  module Notation
+    module Mermaid
+      module IRAdapters
+        # Maps Mermaid's private Error model to notation-neutral data.
+        module Error
+          module_function
+
+          def call(diagram)
+            root_id = diagram.id || "error"
+            IR::Data.new(
+              id: root_id, label: diagram.title, role: "error_panel",
+              items: [IR::Item.new(
+                id: message_id(root_id), label: diagram.message,
+                role: "message"
+              )]
+            )
+          end
+
+          def message_id(root_id)
+            root_id == "message" ? "message_2" : "message"
+          end
+          private_class_method :message_id
+        end
+      end
+    end
+  end
+end