etassia 0.1.0

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

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require_relative "../../../ir"
+
+module Etassia
+  module Notation
+    module Mermaid
+      module IRAdapters
+        # Maps Mermaid's private Kanban model to notation-neutral ordered data.
+        module Kanban
+          METADATA_ROLES = {
+            assigned: "assignee",
+            ticket: "ticket_reference",
+            icon: "icon",
+            label: "secondary_label",
+            priority: "priority",
+          }.freeze
+          private_constant :METADATA_ROLES
+
+          module_function
+
+          def call(diagram)
+            columns = Array(diagram.columns)
+            occupied = []
+            adapted = adapted_columns(columns, occupied)
+            items = items_for(adapted)
+            root_id = reserve_id(diagram.id || "kanban", occupied)
+            IR::Data.new(
+              id: root_id, label: diagram.title, role: "work_board",
+              items: items, values: values_for(adapted, occupied)
+            )
+          end
+
+          def adapted_columns(columns, occupied)
+            columns.map do |column|
+              column_id = reserve_id(column.id, occupied)
+              cards = column.cards.map do |card|
+                [card, reserve_id(card.id, occupied)]
+              end
+              [column, column_id, cards]
+            end
+          end
+
+          def items_for(columns)
+            columns.flat_map do |column, column_id, cards|
+              [IR::Item.new(
+                id: column_id, label: column.title, role: "board_column",
+              )] + cards.map do |card, card_id|
+                IR::Item.new(
+                  id: card_id, label: card.text, role: "work_item",
+                  parent_id: column_id
+                )
+              end
+            end
+          end
+
+          def values_for(columns, occupied)
+            columns.flat_map do |column, column_id, cards|
+              decoration_values(column, column_id, occupied) +
+                cards.flat_map do |card, card_id|
+                  card_values(card, card_id, occupied)
+                end
+            end
+          end
+
+          def decoration_values(item, parent_id, occupied)
+            values = []
+            if item.icon
+              values << text_value(parent_id, "icon", item.icon, occupied)
+            end
+            values + item.classes.map do |style|
+              text_value(parent_id, "style_reference", style, occupied)
+            end
+          end
+
+          def card_values(card, parent_id, occupied)
+            metadata = card.metadata.map do |name, value|
+              text_value(parent_id, METADATA_ROLES.fetch(name), value, occupied)
+            end
+            metadata + card.classes.map do |style|
+              text_value(parent_id, "style_reference", style, occupied)
+            end
+          end
+
+          def text_value(parent_id, role, text, occupied)
+            IR::DataValue.new(
+              id: reserve_id("#{parent_id}_#{role}", occupied),
+              parent_id: parent_id, role: role,
+              value: IR::Scalar.new(text: text)
+            )
+          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 :adapted_columns, :items_for, :values_for,
+                               :decoration_values, :card_values, :text_value,
+                               :reserve_id
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require_relative "../../../ir"
+
+module Etassia
+  module Notation
+    module Mermaid
+      module IRAdapters
+        # Maps Mermaid's private Mindmap tree to a notation-neutral graph.
+        module Mindmap
+          module_function
+
+          def call(diagram)
+            entries = entries_for(diagram)
+            nodes = nodes_for(entries)
+            occupied = nodes.map(&:id)
+            IR::Graph.new(
+              id: reserve_id("mindmap", occupied),
+              label: diagram.title,
+              role: "hierarchy",
+              nodes: nodes,
+              edges: edges_for(entries, occupied),
+            )
+          end
+
+          def entries_for(diagram)
+            return [] unless diagram.root
+
+            flatten_subtree(diagram.root)
+          end
+
+          def nodes_for(entries)
+            entries.map do |node, parent_id|
+              IR::Node.new(
+                id: node.id,
+                label: node.content,
+                role: node.shape || "default",
+                parent_id: parent_id,
+              )
+            end
+          end
+
+          def edges_for(entries, occupied)
+            entries.drop(1).map do |node, parent_id|
+              IR::Edge.new(
+                id: reserve_id("#{parent_id}_to_#{node.id}", occupied),
+                source_id: parent_id,
+                target_id: node.id,
+                role: "parent_child",
+              )
+            end
+          end
+
+          def flatten_subtree(node, parent_id = nil)
+            [[node, parent_id]] + node.children.flat_map do |child|
+              flatten_subtree(child, node.id)
+            end
+          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 :entries_for, :nodes_for, :edges_for,
+                               :flatten_subtree, :reserve_id
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative "../../../ir"
+
+module Etassia
+  module Notation
+    module Mermaid
+      module IRAdapters
+        # Maps Mermaid's private Packet model to a notation-neutral bit grid.
+        module Packet
+          module_function
+
+          def call(diagram)
+            root_id = diagram.id || "packet"
+            occupied = [root_id]
+            items = diagram.fields.map.with_index do |field, index|
+              field_item(field, index, occupied)
+            end
+            IR::Prepositioned.new(
+              id: root_id, label: diagram.title, role: "bit_grid", items: items,
+            )
+          end
+
+          def field_item(field, index, occupied)
+            IR::PrepositionedItem.new(
+              id: reserve_id("field_#{index}", occupied),
+              label: field.label, role: "field",
+              placements: [IR::Placement.new(
+                dimension: "bit", ordinal: index,
+                value: IR::Scalar.new(number: field.bit_start),
+                span: IR::Scalar.new(number: field.size)
+              )]
+            )
+          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 :field_item, :reserve_id
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require_relative "../../../ir"
+
+module Etassia
+  module Notation
+    module Mermaid
+      module IRAdapters
+        # Maps Mermaid's private Pie model to notation-neutral ordered data.
+        module Pie
+          module_function
+
+          def call(diagram)
+            root_id = diagram.id || "pie"
+            occupied = [root_id]
+            dimension = dimension_for(occupied)
+            values = slice_values(diagram, dimension.id, occupied)
+            values << visibility_value(diagram, occupied)
+            IR::Data.new(**data_attributes(diagram, root_id, dimension, values))
+          end
+
+          def data_attributes(diagram, root_id, dimension, values)
+            {
+              id: root_id, label: diagram.title, role: "proportional_series",
+              accessibility_title: diagram.acc_title,
+              accessibility_description: diagram.acc_description,
+              dimensions: [dimension], values: values
+            }
+          end
+
+          def dimension_for(occupied)
+            IR::Dimension.new(
+              id: reserve_id("category", occupied), role: "category",
+            )
+          end
+
+          def slice_values(diagram, dimension_id, occupied)
+            Array(diagram.slices).map.with_index do |slice, index|
+              IR::DataValue.new(
+                id: reserve_id("slice_#{index}", occupied),
+                label: slice.label, role: "segment",
+                dimension_id: dimension_id,
+                value: IR::Scalar.new(number: slice.value)
+              )
+            end
+          end
+
+          def visibility_value(diagram, occupied)
+            IR::DataValue.new(
+              id: reserve_id("show_values", occupied), role: "show_values",
+              value: IR::Scalar.new(boolean: diagram.show_data || false)
+            )
+          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 :data_attributes, :dimension_for, :slice_values,
+                               :visibility_value, :reserve_id
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require_relative "../../../ir"
+
+module Etassia
+  module Notation
+    module Mermaid
+      module IRAdapters
+        # Maps a Quadrant model to ordered coordinate constraints.
+        module Quadrant
+          AXES = {
+            x_min: :x_axis_left,
+            x_max: :x_axis_right,
+            y_min: :y_axis_bottom,
+            y_max: :y_axis_top,
+          }.freeze
+
+          module_function
+
+          def call(diagram)
+            occupied = [diagram.id || "quadrant"]
+            frame = container("coordinate_frame", "frame", occupied)
+            series = container("point_series", "series", occupied,
+                               parent_id: frame.id)
+            items = [frame, *axis_items(diagram, frame.id, occupied),
+                     *region_items(diagram, frame.id, occupied), series]
+            items.concat(point_items(diagram, series.id, occupied))
+            IR::Prepositioned.new(
+              id: occupied.first, label: diagram.title,
+              role: "coordinate_plane", items: items
+            )
+          end
+
+          def axis_items(diagram, parent_id, occupied)
+            AXES.map.with_index do |(position, reader), index|
+              IR::PrepositionedItem.new(
+                id: reserve_id("axis_#{position}", occupied),
+                label: diagram.public_send(reader), role: "axis_label",
+                parent_id: parent_id,
+                placements: [placement("axis_position", index, position)]
+              )
+            end
+          end
+
+          def region_items(diagram, parent_id, occupied)
+            (1..4).map do |number|
+              IR::PrepositionedItem.new(
+                id: reserve_id("region_#{number}", occupied),
+                label: diagram.public_send("quadrant_#{number}_label"),
+                role: "region_label", parent_id: parent_id,
+                placements: [placement("region", number - 1, number)]
+              )
+            end
+          end
+
+          def point_items(diagram, parent_id, occupied)
+            diagram.points.map.with_index do |point, index|
+              IR::PrepositionedItem.new(
+                id: reserve_id("point_#{index}", occupied),
+                label: point.label, role: "point", parent_id: parent_id,
+                placements: point_placements(point, index)
+              )
+            end
+          end
+
+          def point_placements(point, index)
+            values = {
+              x_value: point.x, y_value: point.y,
+              marker_size: point.radius || 5,
+              stroke_width: point.stroke_width || 2,
+              fill_color: point.color, stroke_color: point.stroke_color
+            }
+            values.filter_map do |dimension, value|
+              placement(dimension.to_s, index, value) unless value.nil?
+            end
+          end
+
+          def container(role, dimension, occupied, parent_id: nil)
+            IR::PrepositionedItem.new(
+              id: reserve_id(role, occupied), role: role,
+              parent_id: parent_id,
+              placements: [placement(dimension, 0, 0)]
+            )
+          end
+
+          def placement(dimension, ordinal, value)
+            IR::Placement.new(
+              dimension: dimension.to_s, ordinal: ordinal,
+              value: scalar(value)
+            )
+          end
+
+          def scalar(value)
+            return IR::Scalar.new(number: value) if value.is_a?(Numeric)
+
+            IR::Scalar.new(text: value.to_s)
+          end
+
+          def reserve_id(preferred, occupied)
+            candidate = preferred.to_s
+            suffix = 2
+            while occupied.include?(candidate)
+              candidate = "#{preferred}_#{suffix}"
+              suffix += 1
+            end
+            occupied << candidate
+            candidate
+          end
+          private_class_method :axis_items, :region_items, :point_items,
+                               :point_placements, :container, :placement,
+                               :scalar, :reserve_id
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+require_relative "../../../ir"
+
+module Etassia
+  module Notation
+    module Mermaid
+      module IRAdapters
+        # Maps Mermaid's private Radar model to notation-neutral ordered data.
+        module Radar
+          OPTION_ROLES = {
+            min: "lower_bound",
+            max: "upper_bound",
+            ticks: "tick_count",
+            show_legend: "legend_visibility",
+            graticule: "grid_shape",
+          }.freeze
+          private_constant :OPTION_ROLES
+
+          module_function
+
+          def call(diagram)
+            occupied = []
+            dimensions, dimension_ids = dimensions_for(diagram, occupied)
+            series, series_ids = series_for(diagram, occupied)
+            build_data(
+              diagram, dimensions, series, dimension_ids + series_ids,
+              occupied
+            )
+          end
+
+          def build_data(diagram, dimensions, series, identities, occupied)
+            root_id = reserve_id(diagram.id || "radar", occupied)
+            IR::Data.new(
+              id: root_id, label: diagram.title, role: "radial_comparison",
+              accessibility_title: diagram.acc_title,
+              accessibility_description: diagram.acc_descr,
+              dimensions: dimensions, series: series,
+              values: values_for(
+                diagram, dimensions, series, identities, occupied
+              )
+            )
+          end
+
+          def values_for(diagram, dimensions, series, identities, occupied)
+            identifier_values(identities, occupied) +
+              measurement_values(diagram, dimensions, series, occupied) +
+              option_values(diagram.options, occupied)
+          end
+
+          def dimensions_for(diagram, occupied)
+            identities = []
+            dimensions = diagram.axes.map do |axis|
+              id = reserve_id(axis.id, occupied)
+              identities << [id, axis.id] if id != axis.id
+              IR::Dimension.new(id: id, label: axis.label, role: "axis")
+            end
+            [dimensions, identities]
+          end
+
+          def series_for(diagram, occupied)
+            identities = []
+            series = diagram.curves.map do |curve|
+              id = reserve_id(curve.id, occupied)
+              identities << [id, curve.id] if id != curve.id
+              IR::Series.new(
+                id: id, label: curve.label, role: "dataset",
+              )
+            end
+            [series, identities]
+          end
+
+          def identifier_values(identities, occupied)
+            identities.map do |item_id, source_id|
+              IR::DataValue.new(
+                id: reserve_id("#{item_id}_identifier", occupied),
+                parent_id: item_id, role: "identifier",
+                value: IR::Scalar.new(text: source_id)
+              )
+            end
+          end
+
+          def measurement_values(diagram, dimensions, series, occupied)
+            diagram.curves.zip(series).flat_map do |curve, dataset|
+              diagram.axes.zip(dimensions).map do |axis, dimension|
+                measurement_value(
+                  curve, dataset, axis, dimension, occupied
+                )
+              end
+            end
+          end
+
+          def measurement_value(curve, dataset, axis, dimension, occupied)
+            IR::DataValue.new(
+              id: reserve_id("#{dataset.id}_#{dimension.id}", occupied),
+              role: "measurement", dimension_id: dimension.id,
+              series_id: dataset.id,
+              value: IR::Scalar.new(number: curve.value_for(axis.id))
+            )
+          end
+
+          def option_values(options, occupied)
+            OPTION_ROLES.filter_map do |name, role|
+              next unless options.key?(name)
+
+              IR::DataValue.new(
+                id: reserve_id(role, occupied), role: role,
+                value: scalar(options.fetch(name))
+              )
+            end
+          end
+
+          def scalar(value)
+            case value
+            when Numeric
+              IR::Scalar.new(number: value)
+            when true, false
+              IR::Scalar.new(boolean: value)
+            else
+              IR::Scalar.new(text: value.to_s)
+            end
+          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, :values_for, :dimensions_for,
+                               :series_for, :identifier_values,
+                               :measurement_values, :measurement_value,
+                               :option_values, :scalar, :reserve_id
+        end
+      end
+    end
+  end
+end