sirena 0.1.0

data/lib/sirena/transform/timeline.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "../diagram/timeline"
+
+module Sirena
+  module Transform
+    # Timeline transformer for converting timeline models to renderable structure.
+    #
+    # Handles chronological ordering, positioning along the timeline axis,
+    # and grouping by sections.
+    #
+    # @example Transform a timeline
+    #   transform = TimelineTransform.new
+    #   data = transform.to_graph(timeline_diagram)
+    class TimelineTransform < Base
+      # Converts a Timeline diagram to a layout structure with calculated positions.
+      #
+      # @param diagram [Diagram::Timeline] the timeline 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
+
+        # Collect all events and determine timeline bounds
+        all_events = collect_all_events(diagram)
+        timeline_range = calculate_timeline_range(all_events)
+
+        {
+          id: "timeline",
+          title: diagram.title,
+          acc_title: diagram.acc_title,
+          acc_description: diagram.acc_description,
+          sections: transform_sections(diagram, timeline_range),
+          events: transform_events(diagram.events, timeline_range),
+          timeline: timeline_range,
+          metadata: {
+            section_count: diagram.sections.length,
+            total_events: all_events.length,
+            has_sections: diagram.has_sections?
+          }
+        }
+      end
+
+      private
+
+      def collect_all_events(diagram)
+        events = diagram.events.dup
+        diagram.sections.each do |section|
+          events.concat(section.events)
+        end
+        events
+      end
+
+      def calculate_timeline_range(events)
+        return default_timeline_range if events.empty?
+
+        # Extract numeric time values for positioning
+        time_values = events.map { |e| extract_numeric_time(e.time) }.compact
+
+        if time_values.empty?
+          return default_timeline_range
+        end
+
+        min_time = time_values.min
+        max_time = time_values.max
+
+        # Add some padding
+        padding = ((max_time - min_time) * 0.1).ceil
+        padding = 1 if padding < 1
+
+        {
+          min: min_time - padding,
+          max: max_time + padding,
+          span: (max_time - min_time) + (2 * padding)
+        }
+      end
+
+      def default_timeline_range
+        {
+          min: 2000,
+          max: 2024,
+          span: 24
+        }
+      end
+
+      def extract_numeric_time(time_str)
+        # Try to extract a numeric value from the time string
+        # This handles years (2004), dates (2004-01-01), etc.
+        return nil if time_str.nil? || time_str.empty?
+
+        # Extract first continuous sequence of digits
+        match = time_str.match(/\d+/)
+        match ? match[0].to_i : nil
+      end
+
+      def transform_sections(diagram, timeline_range)
+        diagram.sections.map.with_index do |section, index|
+          {
+            id: "section_#{index}",
+            name: section.name,
+            events: transform_events(section.events, timeline_range),
+            tasks: section.tasks,
+            has_events: section.has_events?,
+            has_tasks: section.has_tasks?
+          }
+        end
+      end
+
+      def transform_events(events, timeline_range)
+        events.map.with_index do |event, index|
+          {
+            id: "event_#{index}",
+            time: event.time,
+            descriptions: event.descriptions,
+            primary_description: event.primary_description,
+            multiple_descriptions: event.multiple_descriptions?,
+            x_position: calculate_x_position(event.time, timeline_range)
+          }
+        end
+      end
+
+      def calculate_x_position(time_str, timeline_range)
+        numeric_time = extract_numeric_time(time_str)
+        return 0 unless numeric_time
+
+        # Calculate position as percentage along timeline
+        # This will be scaled by renderer to actual coordinates
+        if timeline_range[:span] > 0
+          ((numeric_time - timeline_range[:min]).to_f / timeline_range[:span]) * 100.0
+        else
+          50.0 # Center if no span
+        end
+      end
+    end
+  end
+end

data/lib/sirena/transform/treemap.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require_relative '../diagram/treemap'
+
+module Sirena
+  module Transform
+    # Layout calculator for treemap diagrams
+    class Treemap
+      PADDING = 10
+      MIN_CELL_SIZE = 40
+      LABEL_HEIGHT = 20
+      HEADER_HEIGHT = 40
+
+      # Transforms the diagram into a layout structure.
+      #
+      # @param diagram [Diagram::TreemapDiagram] the treemap diagram
+      # @return [Hash] layout data with positioned cells and dimensions
+      def to_graph(diagram)
+        total_value = diagram.total_value
+        return default_layout(diagram) if total_value <= 0
+
+        # Calculate dimensions
+        width = calculate_width(diagram)
+        height = calculate_height(diagram)
+        y_offset = diagram.title ? HEADER_HEIGHT + PADDING : PADDING
+
+        # Layout root nodes
+        cells = []
+        x = PADDING
+        y = y_offset
+
+        diagram.root_nodes.each do |node|
+          cell = layout_node(node, x, y, width - 2 * PADDING,
+                            height - y_offset - PADDING, total_value)
+          cells << cell if cell
+          y += cell[:height] + PADDING if cell
+        end
+
+        {
+          width: width,
+          height: height,
+          title: diagram.title,
+          cells: cells,
+          class_defs: diagram.class_defs
+        }
+      end
+
+      private
+
+      def layout_node(node, x, y, available_width, available_height, total_value)
+        node_value = node.total_value
+        return nil if node_value <= 0
+
+        # Calculate proportional height
+        ratio = node_value / total_value
+        height = [available_height * ratio, MIN_CELL_SIZE].max
+
+        cell = {
+          label: node.label,
+          value: node_value,
+          x: x,
+          y: y,
+          width: available_width,
+          height: height,
+          css_class: node.css_class,
+          depth: node.depth,
+          children: []
+        }
+
+        # If this node has children, layout them recursively
+        if node.branch? && node.children.any?
+          child_y = y + LABEL_HEIGHT
+          child_height = height - LABEL_HEIGHT - PADDING
+
+          node.children.each do |child|
+            child_cell = layout_node(child, x + PADDING, child_y,
+                                     available_width - 2 * PADDING,
+                                     child_height, node_value)
+            if child_cell
+              cell[:children] << child_cell
+              child_y += child_cell[:height] + PADDING
+            end
+          end
+        end
+
+        cell
+      end
+
+      def calculate_width(diagram)
+        # Base width calculation
+        800
+      end
+
+      def calculate_height(diagram)
+        # Calculate based on number of nodes
+        node_count = count_nodes(diagram.root_nodes)
+        base_height = 400
+        additional_height = [node_count * 30, 200].min
+
+        base_height + additional_height
+      end
+
+      def count_nodes(nodes)
+        nodes.sum do |node|
+          1 + (node.children ? count_nodes(node.children) : 0)
+        end
+      end
+
+      def default_layout(diagram)
+        {
+          width: 800,
+          height: 400,
+          title: diagram.title,
+          cells: [],
+          class_defs: diagram.class_defs
+        }
+      end
+    end
+  end
+end

data/lib/sirena/transform/user_journey.rb

@@ -0,0 +1,207 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+require_relative '../diagram/user_journey'
+
+module Sirena
+  module Transform
+    # User Journey diagram transformer for converting journey models to graphs.
+    #
+    # Converts a typed user journey model into a generic graph structure
+    # suitable for layout computation by elkrb. Handles task box sizing
+    # based on task name and actor count, sequential flow between tasks,
+    # and horizontal timeline layout.
+    #
+    # @example Transform a user journey
+    #   transform = UserJourneyTransform.new
+    #   graph = transform.to_graph(user_journey)
+    class UserJourneyTransform < Base
+      # Default font size for text measurement
+      DEFAULT_FONT_SIZE = 14
+
+      # Minimum width for a task box
+      MIN_TASK_WIDTH = 120
+
+      # Height per task box
+      TASK_HEIGHT = 80
+
+      # Padding within task box
+      TASK_PADDING = 10
+
+      # Horizontal spacing between tasks
+      TASK_SPACING = 60
+
+      # Vertical spacing between sections
+      SECTION_SPACING = 40
+
+      # Converts a user journey to a graph structure.
+      #
+      # @param diagram [Diagram::UserJourney] the user journey 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 || 'user_journey',
+          children: transform_tasks(diagram),
+          edges: transform_task_flow(diagram),
+          layoutOptions: layout_options,
+          metadata: {
+            title: diagram.title,
+            sections: diagram.sections.map(&:name)
+          }
+        }
+      end
+
+      private
+
+      def transform_tasks(diagram)
+        task_id = 0
+        nodes = []
+
+        diagram.sections.each_with_index do |section, section_idx|
+          section.tasks.each do |task|
+            dims = calculate_task_dimensions(task)
+
+            nodes << {
+              id: "task_#{task_id}",
+              width: dims[:width],
+              height: dims[:height],
+              labels: task_labels(task),
+              metadata: {
+                name: task.name,
+                score: task.score,
+                score_color: task.score_color,
+                actors: task.actors,
+                section_name: section.name,
+                section_index: section_idx
+              }
+            }
+
+            task_id += 1
+          end
+        end
+
+        nodes
+      end
+
+      def transform_task_flow(diagram)
+        # Create sequential edges between tasks
+        edges = []
+        all_tasks = diagram.all_tasks
+        task_id = 0
+
+        all_tasks.each_with_index do |_task, idx|
+          next if idx >= all_tasks.length - 1
+
+          edges << {
+            id: "flow_#{task_id}",
+            sources: ["task_#{task_id}"],
+            targets: ["task_#{task_id + 1}"],
+            metadata: {
+              type: 'sequence'
+            }
+          }
+
+          task_id += 1
+        end
+
+        edges
+      end
+
+      def calculate_task_dimensions(task)
+        # Calculate width based on task name and actors
+        max_width = MIN_TASK_WIDTH
+
+        # Check task name width
+        name_width = measure_text(
+          task.name,
+          font_size: DEFAULT_FONT_SIZE + 2
+        )[:width]
+        max_width = [max_width, name_width].max
+
+        # Check actors width (displayed as comma-separated list)
+        actors_text = task.actors.join(', ')
+        actors_width = measure_text(
+          actors_text,
+          font_size: DEFAULT_FONT_SIZE
+        )[:width]
+        max_width = [max_width, actors_width].max
+
+        # Add padding
+        total_width = max_width + (TASK_PADDING * 2)
+
+        {
+          width: total_width,
+          height: TASK_HEIGHT
+        }
+      end
+
+      def task_labels(task)
+        labels = []
+
+        # Task name label
+        name_dims = measure_text(
+          task.name,
+          font_size: DEFAULT_FONT_SIZE + 2
+        )
+
+        labels << {
+          text: task.name,
+          width: name_dims[:width],
+          height: name_dims[:height],
+          position: :top
+        }
+
+        # Score label
+        score_text = task.score.to_s
+        score_dims = measure_text(
+          score_text,
+          font_size: DEFAULT_FONT_SIZE + 4
+        )
+
+        labels << {
+          text: score_text,
+          width: score_dims[:width],
+          height: score_dims[:height],
+          position: :center
+        }
+
+        # Actors label
+        actors_text = task.actors.join(', ')
+        actors_dims = measure_text(
+          actors_text,
+          font_size: DEFAULT_FONT_SIZE - 2
+        )
+
+        labels << {
+          text: actors_text,
+          width: actors_dims[:width],
+          height: actors_dims[:height],
+          position: :bottom
+        }
+
+        labels
+      end
+
+      def layout_options
+        # User journeys use layered algorithm for sequential task flow
+        # DIRECTION_RIGHT provides left-to-right horizontal timeline
+        # SIMPLE node placement maintains task order in journey sequence
+        build_elk_options(
+          algorithm: ALGORITHM_LAYERED,
+          direction: DIRECTION_RIGHT,
+          ElkOptions::NODE_NODE_SPACING => TASK_SPACING,
+          ElkOptions::LAYER_SPACING => TASK_SPACING,
+          ElkOptions::EDGE_NODE_SPACING => 30,
+          ElkOptions::EDGE_EDGE_SPACING => 20,
+          # SIMPLE node placement for chronological task ordering
+          ElkOptions::NODE_PLACEMENT => 'SIMPLE',
+          ElkOptions::MODEL_ORDER => 'NODES_AND_EDGES',
+          ElkOptions::HIERARCHY_HANDLING => 'INCLUDE_CHILDREN'
+        )
+      end
+    end
+  end
+end