sirena 0.1.0

data/lib/sirena/transform/sankey.rb

@@ -0,0 +1,212 @@
+# frozen_string_literal: true
+require 'set'
+
+require_relative "base"
+require_relative "../diagram/sankey"
+
+module Sirena
+  module Transform
+    # Sankey transformer for converting Sankey models to renderable structure.
+    #
+    # Handles layer assignment, node positioning, flow path calculation,
+    # and flow width proportional to values.
+    #
+    # @example Transform a Sankey diagram
+    #   transform = SankeyTransform.new
+    #   data = transform.to_graph(sankey_diagram)
+    class SankeyTransform < Base
+      # Node height and spacing
+      NODE_HEIGHT = 40
+      NODE_SPACING = 30
+      LAYER_SPACING = 150
+      MIN_NODE_WIDTH = 20
+      MAX_NODE_WIDTH = 40
+
+      # Converts a Sankey diagram to a layout structure with calculated positions.
+      #
+      # @param diagram [Diagram::SankeyDiagram] the sankey diagram to transform
+      # @return [Hash] data structure for rendering
+      # @raise [TransformError] if diagram is invalid
+      def to_graph(diagram)
+        raise TransformError, "Invalid diagram" unless diagram.valid?
+
+        @diagram = diagram
+        @node_layers = {}
+        @node_positions = {}
+
+        # Assign nodes to layers (left to right)
+        assign_layers
+
+        # Calculate vertical positions within layers
+        calculate_positions
+
+        # Build transformation result
+        {
+          id: "sankey",
+          title: diagram.title,
+          acc_title: diagram.acc_title,
+          acc_description: diagram.acc_description,
+          nodes: transform_nodes,
+          flows: transform_flows,
+          metadata: {
+            node_count: diagram.nodes.length,
+            flow_count: diagram.flows.length,
+            total_flow: diagram.total_flow,
+            max_flow: diagram.max_flow,
+            layer_count: @node_layers.values.max.to_i + 1
+          }
+        }
+      end
+
+      private
+
+      def assign_layers
+        # Use topological sorting to assign layers
+        # Source nodes (no inflow) start at layer 0
+        # Each subsequent layer is one step from previous
+
+        visited = Set.new
+        node_ids = @diagram.all_node_ids
+
+        # Start with source nodes at layer 0
+        source_nodes = @diagram.source_nodes
+        source_nodes.each do |node_id|
+          @node_layers[node_id] = 0
+          visited.add(node_id)
+        end
+
+        # BFS to assign layers
+        queue = source_nodes.dup
+        while !queue.empty?
+          current_id = queue.shift
+          current_layer = @node_layers[current_id]
+
+          # Process all flows from this node
+          @diagram.flows_from(current_id).each do |flow|
+            target_id = flow.target
+            next if visited.include?(target_id)
+
+            # Assign target to next layer
+            target_layer = current_layer + 1
+            @node_layers[target_id] = [
+              @node_layers[target_id] || 0,
+              target_layer
+            ].max
+
+            unless queue.include?(target_id)
+              queue << target_id
+              visited.add(target_id)
+            end
+          end
+        end
+
+        # Handle any nodes not reachable from sources (cycles, isolated nodes)
+        node_ids.each do |node_id|
+          unless @node_layers.key?(node_id)
+            @node_layers[node_id] = 0
+          end
+        end
+      end
+
+      def calculate_positions
+        # Group nodes by layer
+        layers = Hash.new { |h, k| h[k] = [] }
+        @node_layers.each do |node_id, layer|
+          layers[layer] << node_id
+        end
+
+        # Calculate vertical positions for each layer
+        layers.each do |layer_num, node_ids|
+          # Sort nodes by total flow magnitude for better layout
+          sorted_nodes = node_ids.sort_by do |id|
+            -(@diagram.total_inflow(id) + @diagram.total_outflow(id))
+          end
+
+          # Position nodes vertically with spacing
+          y_offset = 0
+          sorted_nodes.each do |node_id|
+            x = layer_num * LAYER_SPACING
+            y = y_offset
+
+            @node_positions[node_id] = {
+              x: x,
+              y: y,
+              width: calculate_node_width(node_id),
+              height: NODE_HEIGHT
+            }
+
+            y_offset += NODE_HEIGHT + NODE_SPACING
+          end
+        end
+      end
+
+      def calculate_node_width(node_id)
+        # Node width proportional to flow through it
+        total_flow = @diagram.total_inflow(node_id) +
+                     @diagram.total_outflow(node_id)
+
+        if total_flow > 0 && @diagram.max_flow > 0
+          ratio = total_flow / (@diagram.max_flow * 2)
+          width = MIN_NODE_WIDTH + (ratio * (MAX_NODE_WIDTH - MIN_NODE_WIDTH))
+          width.round
+        else
+          MIN_NODE_WIDTH
+        end
+      end
+
+      def transform_nodes
+        @diagram.nodes.map do |node|
+          position = @node_positions[node.id] || { x: 0, y: 0, width: MIN_NODE_WIDTH, height: NODE_HEIGHT }
+
+          {
+            id: node.id,
+            label: node.display_label,
+            layer: @node_layers[node.id] || 0,
+            x: position[:x],
+            y: position[:y],
+            width: position[:width],
+            height: position[:height],
+            inflow: @diagram.total_inflow(node.id),
+            outflow: @diagram.total_outflow(node.id)
+          }
+        end
+      end
+
+      def transform_flows
+        @diagram.flows.map.with_index do |flow, index|
+          source_pos = @node_positions[flow.source]
+          target_pos = @node_positions[flow.target]
+
+          # Calculate flow width proportional to value
+          flow_width = calculate_flow_width(flow.value)
+
+          {
+            id: "flow_#{index}",
+            source: flow.source,
+            target: flow.target,
+            value: flow.value,
+            label: flow.label,
+            width: flow_width,
+            source_x: source_pos ? source_pos[:x] + source_pos[:width] : 0,
+            source_y: source_pos ? source_pos[:y] + (source_pos[:height] / 2.0) : 0,
+            target_x: target_pos ? target_pos[:x] : LAYER_SPACING,
+            target_y: target_pos ? target_pos[:y] + (target_pos[:height] / 2.0) : 0,
+            self_loop: flow.self_loop?
+          }
+        end
+      end
+
+      def calculate_flow_width(value)
+        # Flow width proportional to value
+        return 1 if @diagram.max_flow.zero?
+
+        ratio = value / @diagram.max_flow
+        min_width = 2
+        max_width = 50
+
+        width = min_width + (ratio * (max_width - min_width))
+        [width.round, min_width].max
+      end
+    end
+  end
+end

data/lib/sirena/transform/sequence.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+require_relative '../diagram/sequence'
+
+module Sirena
+  module Transform
+    # Sequence transformer for converting sequence models to graphs.
+    #
+    # Converts a typed sequence diagram model into a generic graph structure
+    # suitable for layout computation by elkrb. Handles participant
+    # positioning, message routing, and lifeline calculation.
+    #
+    # @example Transform a sequence diagram
+    #   transform = SequenceTransform.new
+    #   graph = transform.to_graph(sequence_diagram)
+    class SequenceTransform < Base
+      # Default font size for text measurement
+      DEFAULT_FONT_SIZE = 14
+
+      # Minimum spacing between participants
+      PARTICIPANT_SPACING = 150
+
+      # Width of participant box
+      PARTICIPANT_WIDTH = 120
+
+      # Height of participant box
+      PARTICIPANT_HEIGHT = 40
+
+      # Vertical spacing between messages
+      MESSAGE_SPACING = 60
+
+      # Converts a sequence diagram to a graph structure.
+      #
+      # @param diagram [Diagram::Sequence] the sequence diagram to transform
+      # @return [Hash] elkrb-compatible graph hash
+      # @raise [TransformError] if diagram is invalid
+      def to_graph(diagram)
+        raise TransformError, 'Invalid diagram' unless diagram.valid?
+
+        {
+          id: diagram.id || 'sequence',
+          children: transform_participants(diagram),
+          edges: transform_messages(diagram),
+          layoutOptions: layout_options(diagram),
+          metadata: {
+            participants: diagram.participants.map(&:id),
+            message_count: diagram.messages.length,
+            notes: diagram.notes
+          }
+        }
+      end
+
+      private
+
+      def transform_participants(diagram)
+        diagram.participants.map.with_index do |participant, index|
+          {
+            id: participant.id,
+            width: PARTICIPANT_WIDTH,
+            height: PARTICIPANT_HEIGHT,
+            labels: [
+              {
+                text: participant.label,
+                width: measure_text(participant.label,
+                                    font_size: DEFAULT_FONT_SIZE)[:width],
+                height: measure_text(participant.label,
+                                     font_size: DEFAULT_FONT_SIZE)[:height]
+              }
+            ],
+            metadata: {
+              actor_type: participant.actor_type,
+              index: index,
+              lifeline_length: calculate_lifeline_length(diagram)
+            }
+          }
+        end
+      end
+
+      def transform_messages(diagram)
+        return [] if diagram.messages.nil? || diagram.messages.empty?
+
+        diagram.messages.map.with_index do |message, index|
+          {
+            id: "msg_#{index}",
+            sources: [message.from_id],
+            targets: [message.to_id],
+            labels: message_labels(message),
+            metadata: {
+              arrow_type: message.arrow_type,
+              message_index: index,
+              message_text: message.message_text
+            }
+          }
+        end
+      end
+
+      def message_labels(message)
+        return [] if message.message_text.nil? || message.message_text.empty?
+
+        label_dims = measure_text(
+          message.message_text,
+          font_size: DEFAULT_FONT_SIZE
+        )
+
+        [
+          {
+            text: message.message_text,
+            width: label_dims[:width],
+            height: label_dims[:height]
+          }
+        ]
+      end
+
+      def calculate_lifeline_length(diagram)
+        # Calculate total height needed for all messages
+        message_count = diagram.messages.length
+        base_height = message_count * MESSAGE_SPACING
+
+        # Add extra space for notes if present
+        note_count = diagram.notes&.length || 0
+        base_height + (note_count * 30)
+      end
+
+      def layout_options(_diagram)
+        # Sequence diagrams use layered algorithm for vertical timeline
+        # DIRECTION_DOWN ensures participants are arranged horizontally at top
+        # with messages flowing downward in chronological order
+        build_elk_options(
+          algorithm: ALGORITHM_LAYERED,
+          direction: DIRECTION_DOWN,
+          ElkOptions::NODE_NODE_SPACING => PARTICIPANT_SPACING,
+          ElkOptions::LAYER_SPACING => MESSAGE_SPACING,
+          ElkOptions::EDGE_NODE_SPACING => 20,
+          ElkOptions::EDGE_EDGE_SPACING => 15,
+          # SIMPLE node placement maintains participant order
+          ElkOptions::NODE_PLACEMENT => 'SIMPLE',
+          ElkOptions::MODEL_ORDER => 'NODES_AND_EDGES'
+        )
+      end
+    end
+  end
+end

data/lib/sirena/transform/state_diagram.rb

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+require_relative '../diagram/state_diagram'
+
+module Sirena
+  module Transform
+    # State diagram transformer for converting state diagram models to graphs.
+    #
+    # Converts a typed state diagram model into a generic graph structure
+    # suitable for layout computation by elkrb. Handles state node dimension
+    # calculation, transition mapping, and layout configuration.
+    #
+    # @example Transform a state diagram
+    #   transform = StateDiagramTransform.new
+    #   graph = transform.to_graph(state_diagram)
+    class StateDiagramTransform < Base
+      # Default font size for text measurement
+      DEFAULT_FONT_SIZE = 14
+
+      # Converts a state diagram to a graph structure.
+      #
+      # @param diagram [Diagram::StateDiagram] the state diagram to transform
+      # @return [Hash] elkrb-compatible graph hash
+      # @raise [TransformError] if diagram is invalid
+      def to_graph(diagram)
+        raise TransformError, 'Invalid diagram' unless diagram.valid?
+
+        {
+          id: diagram.id || 'state_diagram',
+          children: transform_states(diagram),
+          edges: transform_transitions(diagram),
+          layoutOptions: layout_options(diagram)
+        }
+      end
+
+      private
+
+      def transform_states(diagram)
+        diagram.states.map do |state|
+          dims = calculate_state_dimensions(state)
+
+          {
+            id: state.id,
+            width: dims[:width],
+            height: dims[:height],
+            labels: state_labels(state, dims),
+            metadata: {
+              state_type: state.state_type,
+              description: state.description
+            }
+          }
+        end
+      end
+
+      def transform_transitions(diagram)
+        return [] if diagram.transitions.nil? || diagram.transitions.empty?
+
+        diagram.transitions.map do |transition|
+          {
+            id: "#{transition.from_id}_to_#{transition.to_id}",
+            sources: [transition.from_id],
+            targets: [transition.to_id],
+            labels: transition_labels(transition),
+            metadata: {
+              trigger: transition.trigger,
+              guard_condition: transition.guard_condition
+            }
+          }
+        end
+      end
+
+      def state_labels(state, dims)
+        labels = []
+
+        # Add state label
+        if state.label && !state.label.empty?
+          labels << {
+            text: state.label,
+            width: dims[:label_width],
+            height: dims[:label_height]
+          }
+        end
+
+        # Add description if present
+        if state.description && !state.description.empty?
+          desc_dims = measure_text(
+            state.description,
+            font_size: DEFAULT_FONT_SIZE - 2
+          )
+          labels << {
+            text: state.description,
+            width: desc_dims[:width],
+            height: desc_dims[:height]
+          }
+        end
+
+        labels
+      end
+
+      def transition_labels(transition)
+        label = transition.label
+        return [] if label.nil? || label.empty?
+
+        label_dims = measure_text(label, font_size: DEFAULT_FONT_SIZE)
+
+        [
+          {
+            text: label,
+            width: label_dims[:width],
+            height: label_dims[:height]
+          }
+        ]
+      end
+
+      def calculate_state_dimensions(state)
+        label_text = state.label || state.id
+        label_dims = measure_text(
+          label_text,
+          font_size: DEFAULT_FONT_SIZE
+        )
+
+        # Adjust dimensions based on state type
+        state_dims = case state.state_type
+                     when 'start', 'end'
+                       calculate_terminal_dimensions
+                     when 'choice'
+                       calculate_choice_dimensions(label_dims)
+                     when 'fork', 'join'
+                       calculate_fork_join_dimensions
+                     else
+                       calculate_normal_state_dimensions(
+                         label_dims,
+                         state.description
+                       )
+                     end
+
+        {
+          width: state_dims[:width],
+          height: state_dims[:height],
+          label_width: label_dims[:width],
+          label_height: label_dims[:height]
+        }
+      end
+
+      def calculate_terminal_dimensions
+        # Start and end states are small circles
+        {
+          width: 30,
+          height: 30
+        }
+      end
+
+      def calculate_choice_dimensions(label_dims)
+        # Choice states are diamonds
+        size = [label_dims[:width], label_dims[:height]].max + 40
+        {
+          width: size,
+          height: size
+        }
+      end
+
+      def calculate_fork_join_dimensions
+        # Fork and join are represented as thick bars
+        {
+          width: 100,
+          height: 10
+        }
+      end
+
+      def calculate_normal_state_dimensions(label_dims, description)
+        # Normal states are rounded rectangles
+        width = label_dims[:width] + 40
+        height = label_dims[:height] + 30
+
+        # Add extra height if there's a description
+        if description && !description.empty?
+          desc_dims = measure_text(
+            description,
+            font_size: DEFAULT_FONT_SIZE - 2
+          )
+          height += desc_dims[:height] + 10
+          width = [width, desc_dims[:width] + 40].max
+        end
+
+        # Minimum dimensions
+        width = [width, 100].max
+        height = [height, 50].max
+
+        {
+          width: width,
+          height: height
+        }
+      end
+
+      def layout_options(diagram)
+        # State diagrams use layered algorithm for state machine flow
+        # This ensures proper hierarchical layout of states with clear
+        # transition paths from start to end states
+        build_elk_options(
+          algorithm: ALGORITHM_LAYERED,
+          direction: direction_to_layout(diagram.direction),
+          ElkOptions::NODE_NODE_SPACING => 60,
+          ElkOptions::LAYER_SPACING => 60,
+          ElkOptions::EDGE_NODE_SPACING => 40,
+          ElkOptions::EDGE_EDGE_SPACING => 30,
+          # SIMPLE node placement for predictable state flow
+          ElkOptions::NODE_PLACEMENT => 'SIMPLE'
+        )
+      end
+
+      def direction_to_layout(direction)
+        case direction
+        when 'TD', 'TB'
+          DIRECTION_DOWN
+        when 'LR'
+          DIRECTION_RIGHT
+        when 'RL'
+          DIRECTION_LEFT
+        when 'BT'
+          DIRECTION_UP
+        else
+          DIRECTION_DOWN # Default direction
+        end
+      end
+    end
+  end
+end