etassia 0.1.0

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

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+require_relative "../../../ir"
+
+module Etassia
+  module Notation
+    module Mermaid
+      module IRAdapters
+        # Maps Mermaid's private Flowchart model to a notation-neutral graph.
+        module Flowchart
+          module_function
+
+          def call(diagram)
+            return diagram unless diagram.valid?
+
+            adapt(diagram)
+          end
+
+          def adapt(diagram)
+            occupied = []
+            boxes = drawable_boxes(diagram)
+            box_ids = identity_map(boxes, occupied)
+            node_ids = identity_map(diagram.nodes, occupied)
+            nodes = entity_nodes(diagram, boxes, box_ids, node_ids, occupied)
+            edges = edge_nodes(diagram.edges || [], node_ids, box_ids, occupied)
+            settings = settings_nodes(diagram, occupied)
+            IR::Graph.new(**graph_attributes(
+              diagram, nodes + settings, edges, occupied
+            ))
+          end
+
+          def entity_nodes(diagram, boxes, box_ids, node_ids, occupied)
+            holders = node_holders(boxes, box_ids)
+            collisions = node_subgraph_collision_ids(diagram)
+            flow_nodes(diagram, node_ids, holders, collisions, occupied) +
+              group_nodes(boxes, box_ids, occupied)
+          end
+
+          def flow_nodes(diagram, node_ids, holders, collisions, occupied)
+            diagram.nodes.flat_map do |node|
+              flow_node(
+                node, node_ids.fetch(node), holders[node.id], occupied,
+                subgraph_collision: collisions.include?(node.id)
+              )
+            end
+          end
+
+          def group_nodes(boxes, box_ids, occupied)
+            boxes.flat_map { |box| group_node(box, box_ids, occupied) }
+          end
+
+          def flow_node(node, id, parent_id, occupied,
+                        subgraph_collision: false)
+            entity = IR::Node.new(
+              id: id, label: node.label, role: "flow_node",
+              parent_id: parent_id
+            )
+            semantics = [["source_identifier", node.id],
+                         ["shape", node.shape],
+                         ["style_reference", node.classes],
+                         ["fill", node.fill], ["stroke", node.stroke]]
+            semantics << ["subgraph_collision", "true"] if subgraph_collision
+            [entity, *semantic_nodes(id, semantics, occupied)]
+          end
+
+          def group_node(box, box_ids, occupied)
+            id = box_ids.fetch(box)
+            entity = IR::Node.new(
+              id: id, label: box.title, role: "group",
+              parent_id: source_index(box_ids)[box.parent_id]
+            )
+            semantics = [["source_identifier", box.id],
+                         ["layout_direction", box.direction]]
+            [entity, *semantic_nodes(id, semantics, occupied)]
+          end
+
+          def edge_nodes(edges, node_ids, box_ids, occupied)
+            endpoints = first_source_index(box_ids).merge(
+              first_source_index(node_ids),
+            )
+            edges.map { |edge| edge_node(edge, endpoints, occupied) }
+          end
+
+          def edge_node(edge, endpoints, occupied)
+            preferred = "#{edge.source_id}_to_#{edge.target_id}"
+            IR::Edge.new(
+              id: reserve_id(preferred, occupied),
+              source_id: endpoints.fetch(edge.source_id),
+              target_id: endpoints.fetch(edge.target_id),
+              label: edge.label, role: edge.arrow_type,
+              minimum_rank_span: edge.minimum_rank_span,
+              properties: marker_properties(edge.arrow_type)
+            )
+          end
+
+          def marker_properties(arrow_type)
+            marker = arrow_type.to_s.sub(/\A(?:thick|dotted)_/, "")
+            both = marker.delete_suffix!("_both")
+            marker = nil if %w[line invisible].include?(marker)
+            IR::PropertySet.new(
+              source_marker: both ? marker : nil, target_marker: marker,
+            )
+          end
+
+          def settings_nodes(diagram, occupied)
+            id = reserve_id("diagram_settings", occupied)
+            values = [["diagram_identifier", diagram.id || "flowchart"],
+                      ["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 || "flowchart", occupied),
+              label: diagram.title, role: "flow_diagram",
+              accessibility_title: accessibility(diagram, :acc_title),
+              accessibility_description: accessibility(
+                diagram, :acc_description, :acc_descr
+              ),
+              nodes: nodes, edges: edges
+            }
+          end
+
+          def accessibility(diagram, *names)
+            names.each do |name|
+              next unless diagram.respond_to?(name)
+
+              value = diagram.public_send(name)
+              return value unless value.nil?
+            end
+            nil
+          end
+
+          def drawable_boxes(diagram)
+            (diagram.subgraphs || []).select(&:drawable?)
+          end
+
+          def node_subgraph_collision_ids(diagram)
+            node_ids = diagram.nodes.map(&:id)
+            (diagram.subgraphs || []).filter_map do |subgraph|
+              next if subgraph.drawable?
+
+              subgraph.id if node_ids.include?(subgraph.id)
+            end
+          end
+
+          def node_holders(boxes, box_ids)
+            boxes.each_with_object({}) do |box, holders|
+              box_id = box_ids.fetch(box)
+              box.node_ids.each { |source_id| holders[source_id] = box_id }
+            end
+          end
+
+          def identity_map(items, occupied)
+            items.each_with_object({}.compare_by_identity) do |item, result|
+              result[item] = reserve_id(item.id, occupied)
+            end
+          end
+
+          def source_index(identities)
+            identities.each_with_object({}) do |(item, id), index|
+              index[item.id] = id
+            end
+          end
+
+          def first_source_index(identities)
+            identities.each_with_object({}) do |(item, id), index|
+              index[item.id] ||= id
+            end
+          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 :adapt, :entity_nodes, :flow_node, :group_node,
+                               :edge_nodes, :edge_node, :marker_properties,
+                               :settings_nodes, :semantic_nodes,
+                               :graph_attributes, :accessibility,
+                               :drawable_boxes, :node_subgraph_collision_ids,
+                               :node_holders, :identity_map,
+                               :source_index, :first_source_index, :reserve_id
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,236 @@
+# frozen_string_literal: true
+
+require_relative "../../../ir"
+
+module Etassia
+  module Notation
+    module Mermaid
+      module IRAdapters
+        # Maps the private Gantt model to ordered scheduling constraints.
+        module Gantt
+          module_function
+
+          def call(diagram)
+            root_id = present_id(diagram.id, "gantt")
+            occupied = [root_id]
+            settings = settings_item(diagram, occupied)
+            entries = task_entries(diagram, occupied)
+            IR::Prepositioned.new(
+              **root_attributes(diagram, root_id),
+              items: document_items(diagram, settings, entries, occupied),
+              connections: dependency_edges(entries, occupied),
+            )
+          end
+
+          def settings_item(diagram, occupied)
+            IR::PrepositionedItem.new(
+              id: reserve_id("schedule_settings", occupied),
+              role: "schedule_settings",
+              placements: placements(setting_values(diagram)),
+            )
+          end
+
+          def setting_values(diagram)
+            {
+              date_format: diagram.date_format,
+              axis_format: diagram.axis_format,
+              tick_interval: diagram.tick_interval,
+              weekend: diagram.weekend,
+              inclusive_end_dates: diagram.inclusive_end_dates,
+              today_marker: diagram.today_marker,
+            }
+          end
+
+          def root_attributes(diagram, root_id)
+            {
+              id: root_id, label: diagram.title, role: "schedule",
+              accessibility_title: optional(diagram, :acc_title),
+              accessibility_description: accessibility_description(diagram)
+            }
+          end
+
+          def document_items(diagram, settings, entries, occupied)
+            exclusions = exclusion_items(diagram, settings, occupied)
+            scheduled = entries.flat_map { |entry| entry.fetch(:items) }
+            [settings, *exclusions, *scheduled]
+          end
+
+          def exclusion_items(diagram, settings, occupied)
+            diagram.excludes.map.with_index do |exclusion, index|
+              IR::PrepositionedItem.new(
+                id: reserve_id("exclusion_#{index}", occupied),
+                label: exclusion, role: "exclusion", parent_id: settings.id,
+                placements: [placement("source_order", index, index)]
+              )
+            end
+          end
+
+          def task_entries(diagram, occupied)
+            diagram.sections.map.with_index do |section, index|
+              section_entry(section, index, occupied)
+            end
+          end
+
+          def section_entry(section, index, occupied)
+            section_id = reserve_id("section_#{index}", occupied)
+            section_item = IR::PrepositionedItem.new(
+              id: section_id, label: section.name, role: "section",
+              placements: [placement("source_order", index, index)]
+            )
+            tasks = section.tasks.map.with_index do |task, task_index|
+              task_entry(task, task_index, section_id, occupied)
+            end
+            { items: [section_item, *tasks.flat_map { |entry| entry[:items] }],
+              tasks: tasks }
+          end
+
+          def task_entry(task, index, section_id, occupied)
+            item_id = reserve_id(present_id(task.id, "task_#{index}"), occupied)
+            item = IR::PrepositionedItem.new(
+              id: item_id, label: task.description, role: "task",
+              parent_id: section_id, placements: task_placements(task, index)
+            )
+            flags = task.tags.map.with_index do |tag, flag_index|
+              status_item(tag, flag_index, item_id, occupied)
+            end
+            { source: task, item: item, items: [item, *flags] }
+          end
+
+          def task_placements(task, index)
+            values = {
+              source_order: index, source_id: task.id,
+              start_date: task.start_date, end_date: task.end_date,
+              duration: task.duration, after_tasks: task.after_task,
+              until_task: task.until_task, click_href: task.click_href,
+              click_callback: task.click_callback
+            }
+            placements(values)
+          end
+
+          def status_item(tag, index, task_id, occupied)
+            IR::PrepositionedItem.new(
+              id: reserve_id("#{task_id}_status_#{index}", occupied),
+              label: tag, role: "status_flag", parent_id: task_id,
+              placements: [placement("source_order", index, index)]
+            )
+          end
+
+          def dependency_edges(entries, occupied)
+            tasks = entries.flat_map { |entry| entry.fetch(:tasks) }
+            by_source_id = tasks.each_with_object({}) do |entry, index|
+              source_id = entry.fetch(:source).id
+              index[source_id] = entry if source_id
+            end
+            tasks.flat_map.with_index do |entry, index|
+              dependency_edges_for(entry, index, by_source_id, occupied)
+            end
+          end
+
+          def dependency_edges_for(entry, index, by_source_id, occupied)
+            task = entry.fetch(:source)
+            after_edges = after_edges_for(
+              entry, index, task.after_task, by_source_id, occupied
+            )
+            until_edge = until_edge_for(
+              entry, index, task.until_task, by_source_id, occupied
+            )
+            until_edge ? after_edges.append(until_edge) : after_edges
+          end
+
+          def after_edges_for(entry, index, names, by_source_id, occupied)
+            names.to_s.split.filter_map.with_index do |id, offset|
+              dependency = by_source_id[id]
+              next unless dependency
+
+              dependency_edge(
+                edge_attributes("starts_after", index, offset,
+                                dependency.fetch(:item), entry.fetch(:item)),
+                occupied,
+              )
+            end
+          end
+
+          def until_edge_for(entry, index, name, by_source_id, occupied)
+            dependency = by_source_id[name]
+            return unless dependency
+
+            dependency_edge(
+              edge_attributes("ends_at_start", index, 0,
+                              entry.fetch(:item), dependency.fetch(:item)),
+              occupied,
+            )
+          end
+
+          def edge_attributes(role, index, offset, source, target)
+            {
+              id: "dependency_#{index}_#{offset}", role: role,
+              source_id: source.id, target_id: target.id
+            }
+          end
+
+          def dependency_edge(attributes, occupied)
+            IR::Edge.new(
+              **attributes,
+              id: reserve_id(attributes.fetch(:id), occupied),
+            )
+          end
+
+          def placements(values)
+            values.filter_map.with_index do |(dimension, value), ordinal|
+              next if value.nil?
+
+              placement(dimension.to_s, ordinal, value)
+            end
+          end
+
+          def placement(dimension, ordinal, value)
+            IR::Placement.new(
+              dimension: dimension, ordinal: ordinal, value: scalar(value),
+            )
+          end
+
+          def scalar(value)
+            if [true, false].include?(value)
+              return IR::Scalar.new(boolean: value)
+            end
+            return IR::Scalar.new(number: value) if value.is_a?(Numeric)
+
+            IR::Scalar.new(text: value.to_s)
+          end
+
+          def present_id(value, fallback)
+            value.to_s.empty? ? fallback : value
+          end
+
+          def optional(object, reader)
+            object.public_send(reader) if object.respond_to?(reader)
+          end
+
+          def accessibility_description(diagram)
+            optional(diagram, :acc_description) || optional(diagram, :acc_descr)
+          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 :settings_item, :setting_values,
+                               :root_attributes, :document_items,
+                               :exclusion_items, :task_entries, :section_entry,
+                               :task_entry, :task_placements, :status_item,
+                               :dependency_edges, :dependency_edges_for,
+                               :after_edges_for, :until_edge_for,
+                               :edge_attributes, :dependency_edge, :placements,
+                               :placement, :scalar, :present_id, :optional,
+                               :accessibility_description, :reserve_id
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+require_relative "../../../ir"
+
+module Etassia
+  module Notation
+    module Mermaid
+      module IRAdapters
+        # Maps Mermaid's private Git Graph model to a notation-neutral graph.
+        module GitGraph
+          COMMIT_FIELDS = %i[
+            message type branch_name merge_branch cherry_pick_parent
+          ].freeze
+          BRANCH_FIELDS = %i[order parent_branch created_at_commit].freeze
+          private_constant :COMMIT_FIELDS, :BRANCH_FIELDS
+
+          module_function
+
+          def call(diagram)
+            occupied = []
+            root_id = reserve_id("git_graph", occupied)
+            commits, commit_ids = commit_nodes(diagram.commits, occupied)
+            branches = branch_nodes(diagram.branches, occupied)
+            IR::Graph.new(**graph_attributes(
+              diagram, root_id, occupied,
+              commits.flatten + branches.flatten,
+              edges: parent_edges(diagram.commits, commit_ids, occupied)
+            ))
+          end
+
+          def graph_attributes(diagram, root_id, occupied, nodes, edges:)
+            {
+              id: root_id, role: "version_history",
+              accessibility_title: diagram.acc_title,
+              accessibility_description: diagram.acc_description,
+              nodes: graph_semantics(diagram, occupied) + nodes,
+              edges: edges
+            }
+          end
+
+          def graph_semantics(diagram, occupied)
+            [
+              orientation_node(diagram, occupied),
+              IR::Node.new(
+                id: reserve_id("main_branch", occupied),
+                label: diagram.main_branch_name, role: "main_branch"
+              ),
+            ]
+          end
+
+          def orientation_node(diagram, occupied)
+            IR::Node.new(
+              id: reserve_id("orientation", occupied),
+              label: diagram.orientation, role: "orientation"
+            )
+          end
+
+          def commit_nodes(commits, occupied)
+            ids = []
+            groups = commits.map.with_index do |commit, index|
+              source_id = commit.id || "commit_#{index}"
+              node_id = reserve_id("commit_#{source_id}", occupied)
+              ids << node_id
+              [IR::Node.new(id: node_id, label: source_id, role: "commit")] +
+                commit_semantics(commit, node_id, occupied)
+            end
+            [groups, ids]
+          end
+
+          def commit_semantics(commit, parent_id, occupied)
+            values = field_values(commit, COMMIT_FIELDS)
+            values.concat(tag_values(commit))
+            values.concat(parent_values(commit))
+            values.concat(action_values(commit))
+            values.map do |role, value|
+              semantic_node(parent_id, role, value, occupied)
+            end
+          end
+
+          def tag_values(commit)
+            tags = Array(commit.tags)
+            tags = [commit.tag] if tags.empty? && !commit.tag.nil?
+            tags.map { |tag| ["tag", tag] }
+          end
+
+          def field_values(source, fields)
+            fields.filter_map do |field|
+              value = source.public_send(field)
+              [field.to_s, value] unless value.nil?
+            end
+          end
+
+          def parent_values(commit)
+            commit.parent_ids.map { |id| ["parent_reference", id] }
+          end
+
+          def action_values(commit)
+            values = []
+            values << ["merge_commit", "true"] if commit.is_merge
+            if commit.is_cherry_pick
+              values << ["cherry_pick_commit", "true"]
+            end
+            values
+          end
+
+          def branch_nodes(branches, occupied)
+            branches.map do |branch|
+              node_id = reserve_id("branch_#{branch.name}", occupied)
+              values = field_values(branch, BRANCH_FIELDS)
+              [IR::Node.new(
+                id: node_id, label: branch.name, role: "branch",
+              )] + values.map do |role, value|
+                semantic_node(node_id, role, value, occupied)
+              end
+            end
+          end
+
+          def parent_edges(commits, commit_ids, occupied)
+            source_nodes = source_node_index(commits, commit_ids)
+            commits.flat_map.with_index do |commit, commit_index|
+              commit.parent_ids.filter_map.with_index do |parent_id, edge_index|
+                endpoints = [
+                  source_nodes[parent_id], commit_ids.fetch(commit_index)
+                ]
+                parent_edge(
+                  commit, [commit_index, edge_index], endpoints, occupied
+                )
+              end
+            end
+          end
+
+          def parent_edge(commit, indexes, endpoints, occupied)
+            source_id, target_id = endpoints
+            return unless source_id
+
+            commit_index, edge_index = indexes
+            IR::Edge.new(
+              id: reserve_id("parent_#{commit_index}_#{edge_index}", occupied),
+              source_id: source_id, target_id: target_id,
+              role: edge_role(commit)
+            )
+          end
+
+          def source_node_index(commits, commit_ids)
+            commits.each_with_index.to_h do |commit, index|
+              [commit.id || "commit_#{index}", commit_ids.fetch(index)]
+            end
+          end
+
+          def edge_role(commit)
+            return "merge" if commit.is_merge
+            return "cherry_pick" if commit.is_cherry_pick
+
+            "parent"
+          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 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, :graph_semantics,
+                               :orientation_node,
+                               :commit_nodes, :commit_semantics,
+                               :field_values, :tag_values, :parent_values,
+                               :action_values,
+                               :branch_nodes, :parent_edges, :parent_edge,
+                               :source_node_index, :edge_role, :semantic_node,
+                               :reserve_id
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative "../../../ir"
+
+module Etassia
+  module Notation
+    module Mermaid
+      module IRAdapters
+        # Maps Mermaid's private Info model to notation-neutral data.
+        module Info
+          module_function
+
+          def call(diagram)
+            root_id = diagram.id || "info"
+            IR::Data.new(
+              id: root_id, label: diagram.title, role: "information_panel",
+              values: [IR::DataValue.new(
+                id: value_id(root_id), role: "show_information",
+                value: IR::Scalar.new(boolean: diagram.show_info || false)
+              )]
+            )
+          end
+
+          def value_id(root_id)
+            return "show_information_2" if root_id == "show_information"
+
+            "show_information"
+          end
+          private_class_method :value_id
+        end
+      end
+    end
+  end
+end