etassia 0.1.0

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

@@ -0,0 +1,237 @@
+# frozen_string_literal: true
+
+require_relative "../../../ir"
+
+module Etassia
+  module Notation
+    module Mermaid
+      module IRAdapters
+        # Maps Mermaid's private Requirement model to a notation-neutral graph.
+        module Requirement
+          REQUIREMENT_TYPES = {
+            "requirement" => "requirement",
+            "functionalRequirement" => "functional_requirement",
+            "interfaceRequirement" => "interface_requirement",
+            "performanceRequirement" => "performance_requirement",
+            "physicalRequirement" => "physical_requirement",
+            "designConstraint" => "design_constraint",
+          }.freeze
+          private_constant :REQUIREMENT_TYPES
+
+          module_function
+
+          def call(diagram)
+            occupied = []
+            entities, ids_by_name = entity_nodes(diagram, occupied)
+            semantics = semantic_nodes(diagram, entities, occupied)
+            style_nodes = style_nodes(diagram, occupied)
+            nodes = entities + semantics + style_nodes
+            root_id = reserve_id(diagram.id || "requirement_graph", occupied)
+            edges = relationship_edges(
+              diagram.relationships, ids_by_name, occupied
+            )
+            IR::Graph.new(**graph_attributes(diagram, root_id, nodes, edges))
+          end
+
+          def entity_nodes(diagram, occupied)
+            entries = entity_entries(diagram)
+            nodes = entries.map do |entity, role|
+              entity_node(entity, role, occupied)
+            end
+            [nodes, source_ids(entries, nodes)]
+          end
+
+          def entity_entries(diagram)
+            requirements = diagram.requirements.map do |requirement|
+              [requirement, "requirement"]
+            end
+            elements = diagram.elements.map { |element| [element, "element"] }
+            requirements + elements
+          end
+
+          def entity_node(entity, role, occupied)
+            IR::Node.new(
+              id: reserve_id(entity.name, occupied),
+              label: entity.name, role: role
+            )
+          end
+
+          def source_ids(entries, nodes)
+            entries.zip(nodes).to_h do |(entity, _role), node|
+              [entity.name, node.id]
+            end
+          end
+
+          def semantic_nodes(diagram, entities, occupied)
+            entity_index = 0
+            diagram.requirements.flat_map do |requirement|
+              parent_id = entities.fetch(entity_index).id
+              entity_index += 1
+              requirement_semantics(requirement, parent_id, occupied)
+            end + diagram.elements.flat_map do |element|
+              parent_id = entities.fetch(entity_index).id
+              entity_index += 1
+              element_semantics(element, parent_id, occupied)
+            end
+          end
+
+          def requirement_semantics(requirement, parent_id, occupied)
+            values = [
+              ["requirement_type",
+               normalized_requirement_type(requirement.type)],
+              ["external_identifier", requirement.id],
+              ["description", requirement.text],
+              ["risk", requirement.risk],
+              ["verification_method", requirement.verifymethod],
+            ]
+            semantic_values(values, parent_id, occupied) +
+              style_references(requirement.classes, parent_id, occupied)
+          end
+
+          def element_semantics(element, parent_id, occupied)
+            values = [
+              ["element_type", element.type],
+              ["document_reference", element.docref],
+            ]
+            semantic_values(values, parent_id, occupied) +
+              style_references(element.classes, parent_id, occupied)
+          end
+
+          def semantic_values(values, parent_id, occupied)
+            values.filter_map do |role, value|
+              semantic_node(parent_id, role, value, occupied) unless value.nil?
+            end
+          end
+
+          def style_references(classes, parent_id, occupied)
+            classes.map do |class_name|
+              semantic_node(parent_id, "style_reference", class_name, occupied)
+            end
+          end
+
+          def style_nodes(diagram, occupied)
+            inline_styles(diagram.styles, occupied) +
+              class_definitions(diagram.classes, occupied) +
+              class_assignments(diagram.class_assignments, occupied)
+          end
+
+          def inline_styles(styles, occupied)
+            styles.flat_map.with_index do |style, index|
+              container_id = reserve_id("inline_style_#{index}", occupied)
+              [IR::Node.new(id: container_id, role: "inline_style")] +
+                style_details(style, container_id, occupied)
+            end
+          end
+
+          def class_definitions(classes, occupied)
+            classes.flat_map.with_index do |klass, index|
+              container_id = reserve_id("style_class_#{index}", occupied)
+              [IR::Node.new(
+                id: container_id, label: klass.name, role: "style_class",
+              )] + style_properties(klass, container_id, occupied)
+            end
+          end
+
+          def class_assignments(assignments, occupied)
+            assignments.flat_map.with_index do |assignment, index|
+              container_id = reserve_id("style_assignment_#{index}", occupied)
+              [IR::Node.new(id: container_id, role: "style_assignment")] +
+                assignment_details(assignment, container_id, occupied)
+            end
+          end
+
+          def style_details(style, parent_id, occupied)
+            references(
+              style.target_ids, parent_id, "target_reference", occupied
+            ) +
+              style_properties(style, parent_id, occupied)
+          end
+
+          def style_properties(style, parent_id, occupied)
+            values = [
+              ["fill_color", style.fill],
+              ["stroke_color", style.stroke],
+              ["stroke_width", style.stroke_width],
+            ]
+            semantic_values(values, parent_id, occupied) +
+              references(
+                style.properties, parent_id, "style_property", occupied
+              )
+          end
+
+          def assignment_details(assignment, parent_id, occupied)
+            references(
+              assignment.target_ids, parent_id, "target_reference", occupied
+            ) + references(
+              assignment.class_names, parent_id, "style_reference", occupied
+            )
+          end
+
+          def references(values, parent_id, role, 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, role: role, parent_id: parent_id
+            )
+          end
+
+          def relationship_edges(relationships, ids_by_name, occupied)
+            relationships.filter_map.with_index do |relationship, index|
+              source_id = ids_by_name[relationship.source]
+              target_id = ids_by_name[relationship.target]
+              next unless source_id && target_id
+
+              IR::Edge.new(
+                id: reserve_id("relationship_#{index}", occupied),
+                source_id: source_id, target_id: target_id,
+                role: relationship.type
+              )
+            end
+          end
+
+          def graph_attributes(diagram, root_id, nodes, edges)
+            {
+              id: root_id, label: diagram.title, role: "requirement_graph",
+              accessibility_title: diagram.acc_title,
+              accessibility_description: diagram.acc_description,
+              nodes: nodes, edges: edges
+            }
+          end
+
+          def normalized_requirement_type(type)
+            REQUIREMENT_TYPES.fetch(type, type)
+          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_nodes, :entity_entries, :entity_node,
+                               :source_ids, :semantic_nodes,
+                               :requirement_semantics, :element_semantics,
+                               :semantic_values, :style_references,
+                               :style_nodes, :inline_styles,
+                               :class_definitions, :class_assignments,
+                               :style_details, :style_properties,
+                               :assignment_details, :references,
+                               :semantic_node, :relationship_edges,
+                               :graph_attributes, :normalized_requirement_type,
+                               :reserve_id
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require_relative "../../../ir"
+
+module Etassia
+  module Notation
+    module Mermaid
+      module IRAdapters
+        # Maps Mermaid's private Sankey model to a notation-neutral graph.
+        module Sankey
+          module_function
+
+          def call(diagram)
+            nodes = nodes_for(diagram)
+            occupied = nodes.map(&:id)
+            IR::Graph.new(**graph_attributes(
+              diagram, nodes, edges_for(diagram, occupied), occupied
+            ))
+          end
+
+          def nodes_for(diagram)
+            known = diagram.nodes.map(&:id)
+            missing = diagram.all_node_ids - known
+            private_nodes = diagram.nodes + missing.map do |id|
+              diagram.node_by_id(id)
+            end
+            private_nodes.map do |node|
+              IR::Node.new(
+                id: node.id, label: node.display_label, role: "flow_node",
+              )
+            end
+          end
+
+          def edges_for(diagram, occupied)
+            diagram.flows.map.with_index do |flow, index|
+              IR::Edge.new(
+                id: reserve_id("flow_#{index}", occupied),
+                source_id: flow.source,
+                target_id: flow.target,
+                role: "weighted_flow",
+                properties: IR::PropertySet.new(weight: flow.value),
+              )
+            end
+          end
+
+          def graph_attributes(diagram, nodes, edges, occupied)
+            {
+              id: reserve_id("sankey", occupied),
+              label: diagram.title,
+              role: "flow_network",
+              accessibility_title: diagram.acc_title,
+              accessibility_description: diagram.acc_description,
+              nodes: nodes,
+              edges: edges,
+            }
+          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 :nodes_for, :edges_for, :graph_attributes,
+                               :reserve_id
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,304 @@
+# frozen_string_literal: true
+
+require_relative "../../../ir"
+
+module Etassia
+  module Notation
+    module Mermaid
+      module IRAdapters
+        # Maps Mermaid's private Sequence model to a notation-neutral graph.
+        module Sequence
+          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)
+            participants = participant_identities(diagram, occupied)
+            contents = event_contents(diagram, participants, occupied)
+            nodes = participant_nodes(diagram, participants, occupied)
+            nodes += contents.flat_map(&:first)
+            nodes += settings_nodes(diagram, occupied)
+            [nodes, contents.flat_map(&:last)]
+          end
+
+          def event_contents(diagram, participants, occupied)
+            [messages(diagram, participants, occupied),
+             notes(diagram, participants, occupied),
+             activations(diagram, participants, occupied),
+             frames(diagram, occupied),
+             boxes(diagram, participants, occupied)]
+          end
+
+          def participant_identities(diagram, occupied)
+            participants = Array(diagram.participants)
+            participants.each_with_index.to_h do |participant, index|
+              preferred = participant.id.to_s
+              preferred = "participant_#{index}" if preferred.empty?
+              [participant, reserve_id(preferred, occupied)]
+            end
+          end
+
+          def participant_nodes(diagram, identities, occupied)
+            participants = Array(diagram.participants)
+            participants.flat_map.with_index do |participant, index|
+              id = identities.fetch(participant)
+              entity = IR::Node.new(
+                id: id, label: participant.label,
+                role: participant_role(participant.actor_type)
+              )
+              values = participant_semantics(participant, index)
+              [entity, *semantic_nodes(id, values, occupied)]
+            end
+          end
+
+          def participant_semantics(participant, index)
+            [
+              ["original_identifier", participant.id],
+              ["participant_type", participant.actor_type],
+              ["participant_shape", participant.shape_type],
+              ["participant_created", (true if participant.created)],
+              ["sequence_index", index],
+            ]
+          end
+          private_class_method :participant_semantics
+
+          def participant_role(actor_type)
+            actor_type == "actor" ? "actor" : "participant"
+          end
+
+          def messages(diagram, participant_ids, occupied)
+            endpoints = source_index(Array(diagram.participants),
+                                     participant_ids)
+            records = Array(diagram.messages).map.with_index do |message, index|
+              message_record(message, index, endpoints, occupied)
+            end
+            [records.flat_map(&:first), records.map(&:last)]
+          end
+
+          def source_index(participants, identities)
+            participants.each_with_object({}) do |participant, index|
+              index[participant.id] ||= identities.fetch(participant)
+            end
+          end
+
+          def message_record(message, index, endpoints, occupied)
+            detail_id = reserve_id("message_#{index}_details", occupied)
+            details = message_details(message, index, detail_id, occupied)
+            edge = message_edge(message, index, detail_id, endpoints, occupied)
+            [details, edge]
+          end
+
+          def message_details(message, index, detail_id, occupied)
+            values = [
+              ["line_style", message.line_style],
+              ["head_style", message.head_style],
+              ["head_side", message.head_side],
+              ["sequence_index", index],
+            ]
+            [IR::Node.new(id: detail_id, role: "message_details"),
+             *semantic_nodes(detail_id, values, occupied)]
+          end
+
+          def message_edge(message, index, detail_id, endpoints, occupied)
+            IR::Edge.new(
+              id: reserve_id("message_#{index}", occupied),
+              label: message.message_text, role: "message",
+              parent_id: detail_id,
+              source_id: endpoints[message.from_id],
+              target_id: endpoints[message.to_id]
+            )
+          end
+
+          def notes(diagram, participant_ids, occupied)
+            endpoints = source_index(Array(diagram.participants),
+                                     participant_ids)
+            records = Array(diagram.notes).map.with_index do |note, index|
+              note_record(note, index, endpoints, occupied)
+            end
+            [records.flat_map(&:first), records.flat_map(&:last)]
+          end
+
+          def note_record(note, index, endpoints, occupied)
+            note_id = reserve_id("note_#{index}", occupied)
+            values = [["note_position", note.position],
+                      ["message_index", note.message_index],
+                      ["order", note.order]]
+            nodes = [IR::Node.new(
+              id: note_id, label: note.text, role: "note",
+            ), *semantic_nodes(note_id, values, occupied)]
+            [nodes, note_references(note, index, note_id, endpoints, occupied)]
+          end
+
+          def note_references(note, index, note_id, endpoints, occupied)
+            note.participant_ids.map.with_index do |participant_id, ref_index|
+              reference_edge(
+                "note_reference_#{index}_#{ref_index}", "note_reference",
+                note_id, endpoints[participant_id], occupied
+              )
+            end
+          end
+
+          def activations(diagram, participant_ids, occupied)
+            endpoints = source_index(Array(diagram.participants),
+                                     participant_ids)
+            entries = Array(diagram.activations)
+            records = entries.map.with_index do |activation, index|
+              activation_record(activation, index, endpoints, occupied)
+            end
+            [records.flat_map(&:first), records.map(&:last)]
+          end
+
+          def activation_record(activation, index, endpoints, occupied)
+            activation_id = reserve_id("activation_#{index}", occupied)
+            values = [["start_index", activation.start_index],
+                      ["end_index", activation.end_index]]
+            nodes = [IR::Node.new(id: activation_id, role: "activation"),
+                     *semantic_nodes(activation_id, values, occupied)]
+            edge = reference_edge(
+              "activation_reference_#{index}", "activation_reference",
+              activation_id, endpoints[activation.participant_id], occupied
+            )
+            [nodes, edge]
+          end
+
+          def frames(diagram, occupied)
+            records = Array(diagram.frames).map.with_index do |frame, index|
+              frame_record(frame, index, occupied)
+            end
+            [records.flatten(1), []]
+          end
+
+          def frame_record(frame, index, occupied)
+            id = reserve_id("frame_#{index}", occupied)
+            values = [["frame_kind", frame.kind],
+                      ["start_index", frame.start_index],
+                      ["end_index", frame.end_index],
+                      ["depth", frame.depth],
+                      ["open_order", frame.open_order],
+                      ["close_order", frame.close_order]]
+            nodes = [IR::Node.new(id: id, label: frame.label, role: "frame"),
+                     *semantic_nodes(id, values, occupied)]
+            nodes + section_nodes(frame, id, occupied)
+          end
+
+          def section_nodes(frame, frame_id, occupied)
+            Array(frame.sections).flat_map.with_index do |section, index|
+              id = reserve_id("#{frame_id}_section_#{index}", occupied)
+              values = [["section_kind", section.kind],
+                        ["start_index", section.start_index],
+                        ["order", section.order],
+                        ["owner_frame", frame_id]]
+              [IR::Node.new(id: id, label: section.label,
+                            role: "frame_section"),
+               *semantic_nodes(id, values, occupied)]
+            end
+          end
+
+          def boxes(diagram, participant_ids, occupied)
+            endpoints = source_index(Array(diagram.participants),
+                                     participant_ids)
+            records = Array(diagram.boxes).map.with_index do |box, index|
+              box_record(box, index, endpoints, occupied)
+            end
+            [records.flat_map(&:first), records.flat_map(&:last)]
+          end
+
+          def box_record(box, index, endpoints, occupied)
+            id = reserve_id("box_#{index}", occupied)
+            nodes = [IR::Node.new(id: id, label: box.title, role: "box"),
+                     *semantic_nodes(id, [["box_color", box.color]],
+                                     occupied)]
+            members = box.participant_ids.map.with_index do |member, ref|
+              reference_edge("box_member_#{index}_#{ref}", "box_member",
+                             id, endpoints[member], occupied)
+            end
+            [nodes, members]
+          end
+
+          def reference_edge(preferred, role, source_id, target_id, occupied)
+            IR::Edge.new(
+              id: reserve_id(preferred, occupied), role: role,
+              source_id: source_id, target_id: target_id
+            )
+          end
+
+          def settings_nodes(diagram, occupied)
+            settings_id = reserve_id("diagram_settings", occupied)
+            values = [
+              ["diagram_identifier", diagram.id],
+              ["layout_direction", diagram.direction],
+              ["theme_reference", diagram.theme],
+              ["autonumber", optional_value(diagram, :autonumber)],
+              ["wrap", ("true" if diagram.wrap)],
+            ]
+            [IR::Node.new(id: settings_id, role: "diagram_settings"),
+             *semantic_nodes(settings_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 || "sequence", occupied),
+              label: diagram.title, role: "interaction_graph",
+              accessibility_title: optional_value(diagram, :acc_title),
+              accessibility_description: optional_value(
+                diagram, :acc_description, :acc_descr
+              ),
+              nodes: nodes, edges: edges
+            }
+          end
+
+          def optional_value(source, *names)
+            names.each do |name|
+              next unless source.respond_to?(name)
+
+              value = source.public_send(name)
+              return value unless value.nil?
+            end
+            nil
+          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, :event_contents,
+                               :participant_identities, :participant_nodes,
+                               :participant_role, :messages, :source_index,
+                               :message_record, :message_details,
+                               :message_edge, :notes, :note_record,
+                               :note_references, :activations,
+                               :activation_record, :frames, :frame_record,
+                               :section_nodes, :boxes, :box_record,
+                               :reference_edge, :settings_nodes,
+                               :semantic_nodes, :graph_attributes,
+                               :optional_value, :reserve_id
+        end
+      end
+    end
+  end
+end