etassia 0.1.0

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

@@ -0,0 +1,225 @@
+# frozen_string_literal: true
+
+require_relative "../../../ir"
+
+module Etassia
+  module Notation
+    module Mermaid
+      module IRAdapters
+        # Maps Mermaid's private StateDiagram model to a notation-neutral graph.
+        module StateDiagram
+          STATE_ROLES = {
+            "start" => "initial_state",
+            "end" => "final_state",
+            "choice" => "choice_state",
+            "fork" => "fork_state",
+            "join" => "join_state",
+          }.freeze
+          private_constant :STATE_ROLES
+
+          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)
+            entries = state_entries(diagram.states)
+            identities = state_identities(entries, occupied)
+            states = state_nodes(entries, identities, occupied)
+            notes = note_nodes(diagram.notes, entries, identities, occupied)
+            details, transitions = transition_records(
+              diagram.transitions, entries, identities, occupied
+            )
+            settings = settings_nodes(diagram, occupied)
+            [states + notes + details + settings, transitions]
+          end
+
+          def state_entries(states, parent = nil)
+            Array(states).reject(&:declaration_only).flat_map do |state|
+              [[state, parent], *state_entries(state.children, state)]
+            end
+          end
+
+          def state_identities(entries, occupied)
+            identities = {}.compare_by_identity
+            entries.each_with_index.with_object(identities) do |entry, result|
+              (state, _parent), index = entry
+              preferred = state.id.to_s.empty? ? "state_#{index}" : state.id
+              result[state] = reserve_id(preferred, occupied)
+            end
+          end
+
+          def state_nodes(entries, identities, occupied)
+            entries.flat_map.with_index do |(state, parent), index|
+              state_record(state, parent, index, identities, occupied)
+            end
+          end
+
+          def state_record(state, parent, index, identities, occupied)
+            id = identities.fetch(state)
+            entity = IR::Node.new(
+              id: id, label: state.label, role: state_role(state.state_type),
+              parent_id: identities[parent]
+            )
+            values = state_values(state, index)
+            [entity, *semantic_nodes(id, values, occupied)]
+          end
+
+          def state_values(state, index)
+            values = [["original_identifier", state.id],
+                      ["declared_state_type", state.state_type],
+                      ["latest_description", state.description],
+                      ["sequence_index", index]]
+            values + Array(state.descriptions).map do |description|
+              ["display_text", description]
+            end
+          end
+
+          def state_role(state_type)
+            STATE_ROLES.fetch(state_type, "state")
+          end
+
+          def note_nodes(notes, entries, identities, occupied)
+            endpoints = source_index(entries, identities)
+            Array(notes).flat_map.with_index do |note, index|
+              note_record(note, index, endpoints, occupied)
+            end
+          end
+
+          def note_record(note, index, endpoints, occupied)
+            id = reserve_id(note.id || "state_note_#{index}", occupied)
+            values = [["original_identifier", note.id],
+                      ["placement_side", note.position]]
+            entity = IR::Node.new(
+              id: id, label: note.text, role: "annotation",
+              parent_id: endpoints[note.target_id]
+            )
+            [entity, *semantic_nodes(id, values, occupied)]
+          end
+
+          def transition_records(transitions, entries, identities, occupied)
+            endpoints = source_index(entries, identities)
+            records = Array(transitions).map.with_index do |transition, index|
+              transition_record(transition, index, endpoints, occupied)
+            end
+            [records.flat_map(&:first), records.map(&:last)]
+          end
+
+          def source_index(entries, identities)
+            entries.each_with_object({}) do |(state, _parent), index|
+              index[state.id] ||= identities.fetch(state)
+            end
+          end
+
+          def transition_record(transition, index, endpoints, occupied)
+            details_id = reserve_id("transition_#{index}_details", occupied)
+            details = transition_details(
+              transition, index, details_id, occupied
+            )
+            edge = transition_edge(
+              transition, index, details_id, endpoints, occupied
+            )
+            [details, edge]
+          end
+
+          def transition_details(transition, index, details_id, occupied)
+            values = [
+              ["trigger", transition.trigger],
+              ["guard_condition", transition.guard_condition],
+              ["transition_identifier",
+               "#{transition.from_id}_to_#{transition.to_id}"],
+              ["sequence_index", index],
+            ]
+            [
+              IR::Node.new(id: details_id, role: "transition_details"),
+              *semantic_nodes(details_id, values, occupied),
+            ]
+          end
+
+          def transition_edge(transition, index, details_id, endpoints,
+                              occupied)
+            IR::Edge.new(
+              id: reserve_id("transition_#{index}", occupied),
+              label: transition.label, role: "state_transition",
+              parent_id: details_id,
+              source_id: endpoints[transition.from_id],
+              target_id: endpoints[transition.to_id],
+              properties: IR::PropertySet.new(target_marker: "arrow")
+            )
+          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?
+
+              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 || "state_diagram", occupied),
+              label: diagram.title, role: "state_machine",
+              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, :state_entries,
+                               :state_identities, :state_nodes, :state_record,
+                               :state_values, :state_role,
+                               :note_nodes, :note_record,
+                               :transition_records, :source_index,
+                               :transition_record, :transition_details,
+                               :transition_edge, :settings_nodes,
+                               :semantic_nodes, :graph_attributes,
+                               :optional_value, :reserve_id
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require_relative "../../../ir"
+
+module Etassia
+  module Notation
+    module Mermaid
+      module IRAdapters
+        # Maps Mermaid's private Timeline model to ordered source placements.
+        module Timeline
+          module_function
+
+          def call(diagram)
+            root_id = diagram.id || "timeline"
+            occupied = [root_id]
+            items = section_items(diagram.sections, occupied)
+            items.concat(event_items(diagram.events, nil, occupied))
+            IR::Prepositioned.new(
+              id: root_id, label: diagram.title, role: "chronology",
+              accessibility_title: diagram.acc_title,
+              accessibility_description: diagram.acc_description,
+              items: items
+            )
+          end
+
+          def section_items(sections, occupied)
+            sections.flat_map.with_index do |section, index|
+              section_id = reserve_id("section_#{index}", occupied)
+              section_item = placed_item(
+                id: section_id, label: section.name, role: "section",
+                dimension: "track", ordinal: index,
+                value: IR::Scalar.new(number: index)
+              )
+              [section_item,
+               *event_items(section.events, section_id, occupied)]
+            end
+          end
+
+          def event_items(events, parent_id, occupied)
+            events.flat_map.with_index do |event, index|
+              event_id = reserve_id("event_#{index}", occupied)
+              event_item = placed_item(
+                id: event_id, label: event.time, role: "event",
+                parent_id: parent_id, dimension: "time", ordinal: index,
+                value: IR::Scalar.new(text: event.time)
+              )
+              [event_item,
+               *description_items(event.descriptions, event_id, occupied)]
+            end
+          end
+
+          def description_items(descriptions, parent_id, occupied)
+            descriptions.map.with_index do |description, index|
+              placed_item(
+                id: reserve_id("description_#{index}", occupied),
+                label: description, role: "description",
+                parent_id: parent_id, dimension: "description",
+                ordinal: index, value: IR::Scalar.new(number: index)
+              )
+            end
+          end
+
+          def placed_item(attributes)
+            placement = IR::Placement.new(
+              dimension: attributes.fetch(:dimension),
+              ordinal: attributes.fetch(:ordinal),
+              value: attributes.fetch(:value),
+            )
+            IR::PrepositionedItem.new(
+              id: attributes.fetch(:id), label: attributes[:label],
+              role: attributes.fetch(:role), parent_id: attributes[:parent_id],
+              placements: [placement]
+            )
+          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 :section_items, :event_items,
+                               :description_items, :placed_item,
+                               :reserve_id
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+require_relative "../../../ir"
+
+module Etassia
+  module Notation
+    module Mermaid
+      module IRAdapters
+        # Maps Mermaid's private Treemap hierarchy to notation-neutral data.
+        module Treemap
+          STYLE_PROPERTIES = %i[fill stroke].freeze
+          private_constant :STYLE_PROPERTIES
+
+          module_function
+
+          def call(diagram)
+            entries = entries_for(diagram.root_nodes)
+            series = series_for(entries)
+            build_data(diagram, entries, series)
+          end
+
+          def build_data(diagram, entries, series)
+            occupied = series.map(&:id)
+            dimension = magnitude_dimension(occupied)
+            IR::Data.new(
+              id: reserve_id(diagram.id || "treemap", occupied),
+              label: diagram.title,
+              role: "hierarchical_partition", dimensions: [dimension],
+              series: series,
+              values: values_for(diagram, entries, dimension.id, occupied)
+            )
+          end
+
+          def magnitude_dimension(occupied)
+            IR::Dimension.new(
+              id: reserve_id("magnitude", occupied), role: "magnitude",
+            )
+          end
+
+          def values_for(diagram, entries, dimension_id, occupied)
+            node_values(entries, dimension_id, occupied) +
+              style_definitions(diagram.class_defs, occupied)
+          end
+
+          def entries_for(nodes, parent_id = nil, prefix = [])
+            nodes.flat_map.with_index do |node, index|
+              path = prefix + [index]
+              id = "partition_#{path.join('_')}"
+              [[node, id, parent_id]] + entries_for(node.children, id, path)
+            end
+          end
+
+          def series_for(entries)
+            entries.map do |node, id, parent_id|
+              IR::Series.new(
+                id: id, label: node.label, role: "partition",
+                parent_id: parent_id
+              )
+            end
+          end
+
+          def node_values(entries, dimension_id, occupied)
+            entries.flat_map do |node, id, _parent_id|
+              values_for_node(node, id, dimension_id, occupied)
+            end
+          end
+
+          def values_for_node(node, id, dimension_id, occupied)
+            [
+              magnitude_value(node, id, dimension_id, occupied),
+              style_value(node, id, occupied),
+            ].compact
+          end
+
+          def magnitude_value(node, id, dimension_id, occupied)
+            return unless node.value
+
+            data_value(
+              "#{id}_magnitude", "magnitude", node.value, occupied,
+              series_id: id, dimension_id: dimension_id
+            )
+          end
+
+          def style_value(node, id, occupied)
+            return unless node.css_class
+
+            data_value(
+              "#{id}_style", "style_reference", node.css_class, occupied,
+              series_id: id
+            )
+          end
+
+          def style_definitions(class_defs, occupied)
+            class_defs.flat_map do |name, styles|
+              STYLE_PROPERTIES.filter_map do |property|
+                color = style_color(styles, property)
+                next unless color
+
+                data_value(
+                  "style_#{name}_#{property}", "#{property}_color", color,
+                  occupied, label: name
+                )
+              end
+            end
+          end
+
+          def style_color(styles, property)
+            match = styles.match(/#{property}:\s*([^;,]+)/)
+            match[1].strip if match
+          end
+
+          def data_value(preferred_id, role, value, occupied, **attributes)
+            scalar = if value.is_a?(Numeric)
+                       IR::Scalar.new(number: value)
+                     else
+                       IR::Scalar.new(text: value)
+                     end
+            IR::DataValue.new(
+              id: reserve_id(preferred_id, occupied), role: role,
+              value: scalar, **attributes
+            )
+          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 :build_data, :magnitude_dimension, :values_for,
+                               :entries_for, :series_for, :node_values,
+                               :values_for_node, :magnitude_value, :style_value,
+                               :style_definitions, :style_color, :data_value,
+                               :reserve_id
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require_relative "../../../ir"
+
+module Etassia
+  module Notation
+    module Mermaid
+      module IRAdapters
+        # Maps Mermaid's private User Journey model to a notation-neutral graph.
+        module UserJourney
+          TASK_ROLE_PREFIX = "journey_task_"
+          private_constant :TASK_ROLE_PREFIX
+
+          module_function
+
+          def call(diagram)
+            root_id = source_id(diagram.id, "user_journey")
+            occupied = [root_id]
+            nodes, tasks = nodes_for(diagram.sections, occupied)
+            IR::Graph.new(**graph_attributes(
+              diagram, root_id, nodes, edges_for(tasks, occupied)
+            ))
+          end
+
+          def graph_attributes(diagram, root_id, nodes, edges)
+            {
+              id: root_id, label: diagram.title, role: "customer_journey",
+              accessibility_title: optional_value(diagram, :acc_title),
+              accessibility_description: accessibility_description(diagram),
+              nodes: nodes, edges: edges
+            }
+          end
+
+          def accessibility_description(diagram)
+            optional_value(diagram, :acc_description, :acc_descr)
+          end
+
+          def nodes_for(sections, occupied)
+            nodes = []
+            tasks = []
+            sections.each_with_index do |section, section_index|
+              append_section(
+                section, section_index, nodes, tasks, occupied
+              )
+            end
+            [nodes, tasks]
+          end
+
+          def append_section(section, index, nodes, tasks, occupied)
+            section_id = reserve_id("section_#{index}", occupied)
+            nodes << IR::Node.new(
+              id: section_id, label: section.name, role: "journey_section",
+            )
+            section.tasks.each do |task|
+              append_task(task, section_id, nodes, tasks, occupied)
+            end
+          end
+
+          def append_task(task, section_id, nodes, tasks, occupied)
+            node = task_node(task, tasks.length, section_id, occupied)
+            nodes << node
+            nodes.concat(actor_nodes(task, node.id, occupied))
+            tasks << node
+          end
+
+          def task_node(task, index, section_id, occupied)
+            IR::Node.new(
+              id: reserve_id("task_#{index}", occupied),
+              label: task.name,
+              role: "#{TASK_ROLE_PREFIX}#{task.score_color}",
+              parent_id: section_id,
+              properties: IR::PropertySet.new(weight: task.score),
+            )
+          end
+
+          def actor_nodes(task, task_id, occupied)
+            task.actors.map.with_index do |actor, index|
+              IR::Node.new(
+                id: reserve_id("#{task_id}_actor_#{index}", occupied),
+                label: actor, role: "journey_actor", parent_id: task_id
+              )
+            end
+          end
+
+          def edges_for(tasks, occupied)
+            tasks.each_cons(2).with_index.map do |(source, target), index|
+              IR::Edge.new(
+                id: reserve_id("flow_#{index}", occupied),
+                source_id: source.id, target_id: target.id,
+                role: "sequence"
+              )
+            end
+          end
+
+          def source_id(value, fallback)
+            value.to_s.empty? ? fallback : value
+          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)
+            candidate = preferred
+            suffix = 2
+            while occupied.include?(candidate)
+              candidate = "#{preferred}_#{suffix}"
+              suffix += 1
+            end
+            occupied << candidate
+            candidate
+          end
+          private_class_method :graph_attributes, :accessibility_description,
+                               :nodes_for, :append_section, :append_task,
+                               :task_node, :actor_nodes, :edges_for,
+                               :source_id, :optional_value, :reserve_id
+        end
+      end
+    end
+  end
+end