sirena 0.1.0

data/lib/sirena/transform/gantt.rb

@@ -0,0 +1,253 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "../diagram/gantt"
+require "date"
+
+module Sirena
+  module Transform
+    # Gantt chart transformer for converting gantt models to renderable structure.
+    #
+    # Handles date calculations, dependency resolution, and timeline positioning.
+    #
+    # @example Transform a Gantt chart
+    #   transform = GanttTransform.new
+    #   data = transform.to_graph(gantt_diagram)
+    class GanttTransform < Base
+      # Converts a Gantt diagram to a layout structure with calculated positions.
+      #
+      # @param diagram [Diagram::GanttChart] the Gantt diagram to transform
+      # @return [Hash] data structure for rendering
+      # @raise [TransformError] if diagram is invalid
+      def to_graph(diagram)
+        @diagram = diagram
+        @task_map = build_task_map(diagram)
+
+        # Calculate dates for all tasks
+        calculate_task_dates
+
+        # Determine timeline range
+        timeline = calculate_timeline
+
+        {
+          id: "gantt",
+          title: diagram.title,
+          date_format: diagram.date_format,
+          axis_format: diagram.axis_format,
+          tick_interval: diagram.tick_interval,
+          excludes: diagram.excludes,
+          today_marker: diagram.today_marker,
+          sections: transform_sections(diagram, timeline),
+          timeline: timeline,
+          metadata: {
+            section_count: diagram.sections.length,
+            task_count: total_task_count(diagram)
+          }
+        }
+      end
+
+      private
+
+      def build_task_map(diagram)
+        map = {}
+        diagram.sections.each do |section|
+          section.tasks.each do |task|
+            map[task.id] = task if task.id
+          end
+        end
+        map
+      end
+
+      def calculate_task_dates
+        # First pass: calculate tasks with explicit dates
+        @diagram.sections.each do |section|
+          section.tasks.each do |task|
+            calculate_task_date(task) if task.start_date && !task.after_task
+          end
+        end
+
+        # Second pass: resolve dependencies
+        max_iterations = 100
+        iteration = 0
+        loop do
+          changed = false
+          @diagram.sections.each do |section|
+            section.tasks.each do |task|
+              if !task.calculated_start && (task.after_task || task.until_task)
+                if resolve_task_dependency(task)
+                  changed = true
+                end
+              end
+            end
+          end
+
+          iteration += 1
+          break if !changed || iteration >= max_iterations
+        end
+      end
+
+      def calculate_task_date(task)
+        return if task.calculated_start
+
+        if task.start_date
+          task.calculated_start = parse_date(task.start_date)
+        end
+
+        if task.end_date
+          task.calculated_end = parse_date(task.end_date)
+        elsif task.duration && task.calculated_start
+          task.calculated_end = add_duration(task.calculated_start, task.duration)
+        end
+
+        task.calculated_start
+      end
+
+      def resolve_task_dependency(task)
+        if task.after_task
+          ref_task = @task_map[task.after_task]
+          return false unless ref_task && ref_task.calculated_end
+
+          task.calculated_start = ref_task.calculated_end
+          if task.duration
+            task.calculated_end = add_duration(task.calculated_start, task.duration)
+          elsif task.end_date
+            task.calculated_end = parse_date(task.end_date)
+          elsif task.until_task
+            until_task = @task_map[task.until_task]
+            task.calculated_end = until_task.calculated_start if until_task
+          end
+          return true
+        end
+
+        if task.until_task && task.start_date
+          task.calculated_start = parse_date(task.start_date)
+          until_task = @task_map[task.until_task]
+          if until_task && until_task.calculated_start
+            task.calculated_end = until_task.calculated_start
+            return true
+          end
+        end
+
+        false
+      end
+
+      def parse_date(date_str)
+        # Handle various date formats
+        Date.parse(date_str)
+      rescue ArgumentError
+        # Default to today if parsing fails
+        Date.today
+      end
+
+      def add_duration(start_date, duration_str)
+        # Parse duration string (e.g., "30d", "2w", "48h", "1M")
+        value = duration_str.to_i
+        unit = duration_str[-1]
+
+        case unit
+        when "d"
+          start_date + value
+        when "w"
+          start_date + (value * 7)
+        when "h"
+          # Convert hours to days (rough approximation)
+          start_date + (value / 24.0).ceil
+        when "M"
+          # Add months (rough approximation)
+          start_date >> value
+        else
+          start_date + value # Default to days
+        end
+      end
+
+      def calculate_timeline
+        min_date = nil
+        max_date = nil
+
+        @diagram.sections.each do |section|
+          section.tasks.each do |task|
+            if task.calculated_start
+              min_date = task.calculated_start if !min_date || task.calculated_start < min_date
+            end
+            if task.calculated_end
+              max_date = task.calculated_end if !max_date || task.calculated_end > max_date
+            end
+          end
+        end
+
+        # Default to a reasonable range if no dates found
+        min_date ||= Date.today
+        max_date ||= Date.today + 30
+
+        # Add padding
+        min_date -= 1
+        max_date += 1
+
+        {
+          start_date: min_date,
+          end_date: max_date,
+          total_days: (max_date - min_date).to_i
+        }
+      end
+
+      def transform_sections(diagram, timeline)
+        diagram.sections.map.with_index do |section, section_index|
+          {
+            id: "section_#{section_index}",
+            name: section.name,
+            tasks: transform_tasks(section, timeline, section_index)
+          }
+        end
+      end
+
+      def transform_tasks(section, timeline, section_index)
+        section.tasks.map.with_index do |task, task_index|
+          {
+            id: task.id || "task_#{section_index}_#{task_index}",
+            description: task.description,
+            tags: task.tags,
+            done: task.done?,
+            active: task.active?,
+            critical: task.critical?,
+            milestone: task.milestone?,
+            start_date: task.calculated_start,
+            end_date: task.calculated_end,
+            start_x: calculate_x_position(task.calculated_start, timeline),
+            width: calculate_width(task.calculated_start, task.calculated_end, timeline),
+            click_href: task.click_href,
+            click_callback: task.click_callback
+          }
+        end
+      end
+
+      def calculate_x_position(date, timeline)
+        return 0 unless date
+
+        days_from_start = (date - timeline[:start_date]).to_i
+        (days_from_start.to_f / timeline[:total_days]) * 800 # 800 is the timeline width
+      end
+
+      def calculate_width(start_date, end_date, timeline)
+        return 20 unless start_date && end_date # Minimum width for milestones
+
+        duration_days = (end_date - start_date).to_i
+        return 10 if duration_days <= 0 # Milestone or zero duration
+
+        (duration_days.to_f / timeline[:total_days]) * 800
+      end
+
+      def total_task_count(diagram)
+        diagram.sections.sum { |s| s.tasks.length }
+      end
+    end
+  end
+end
+
+# Extend GanttTask to hold calculated dates
+module Sirena
+  module Diagram
+    class GanttTask
+      attr_accessor :calculated_start, :calculated_end
+    end
+  end
+end

data/lib/sirena/transform/git_graph.rb

@@ -0,0 +1,283 @@
+# frozen_string_literal: true
+
+module Sirena
+  module Transform
+    # Transforms a GitGraph diagram into a positioned layout structure.
+    #
+    # Unlike other transformers that use ELK layout, GitGraph uses a custom
+    # layout algorithm that assigns commits to horizontal lanes (Y positions)
+    # and sequential X positions based on commit order.
+    #
+    # The layout algorithm handles:
+    # - Branch lane assignment (main branch at top)
+    # - Commit positioning (chronological X coordinates)
+    # - Parent-child relationships for drawing connections
+    # - Merge point tracking for drawing merge arrows
+    # - Cherry-pick visualization
+    #
+    # @example Transform a git graph
+    #   transform = Transform::GitGraph.new
+    #   layout = transform.to_graph(diagram)
+    class GitGraph
+      # Spacing between commits horizontally
+      COMMIT_SPACING = 80
+
+      # Spacing between branch lanes vertically
+      LANE_SPACING = 60
+
+      # Radius of commit circles
+      COMMIT_RADIUS = 8
+
+      # Default branch colors (cycling through these)
+      DEFAULT_COLORS = %w[
+        #2563eb #7c3aed #db2777 #ea580c #ca8a04
+        #16a34a #0891b2 #4f46e5 #c026d3 #dc2626
+      ].freeze
+
+      # Transforms the diagram into a layout structure.
+      #
+      # @param diagram [Diagram::GitGraph] the git graph diagram
+      # @return [Hash] layout data with commits, branches, and connections
+      def to_graph(diagram)
+        # Build commit lookup and parent tracking
+        commits_by_id = build_commit_lookup(diagram.commits)
+        branch_info = build_branch_info(diagram)
+
+        # Assign lanes to branches
+        lane_assignments = assign_lanes(diagram, branch_info)
+
+        # Position commits
+        positioned_commits = position_commits(
+          diagram.commits,
+          commits_by_id,
+          lane_assignments
+        )
+
+        # Build connections between commits
+        connections = build_connections(
+          positioned_commits,
+          commits_by_id
+        )
+
+        # Build branch metadata
+        branches = build_branch_metadata(
+          diagram.branches,
+          lane_assignments,
+          positioned_commits
+        )
+
+        {
+          commits: positioned_commits,
+          branches: branches,
+          connections: connections,
+          width: calculate_width(positioned_commits),
+          height: calculate_height(lane_assignments)
+        }
+      end
+
+      private
+
+      # Builds a lookup hash of commits by ID.
+      #
+      # @param commits [Array<Diagram::GitGraph::Commit>] commits
+      # @return [Hash<String, Diagram::GitGraph::Commit>] commit lookup
+      def build_commit_lookup(commits)
+        lookup = {}
+        commits.each_with_index do |commit, idx|
+          # Use index as fallback ID if no ID specified
+          key = commit.id || "commit_#{idx}"
+          lookup[key] = commit
+        end
+        lookup
+      end
+
+      # Builds branch information from diagram.
+      #
+      # @param diagram [Diagram::GitGraph] diagram
+      # @return [Hash] branch info with parent relationships
+      def build_branch_info(diagram)
+        info = {}
+
+        # Start with main branch
+        info["main"] = {
+          parent: nil,
+          order: 0,
+          created_at: nil
+        }
+
+        # Add other branches
+        diagram.branches.each do |branch|
+          info[branch.name] = {
+            parent: branch.parent_branch || "main",
+            order: branch.order || info.size,
+            created_at: branch.created_at_commit
+          }
+        end
+
+        info
+      end
+
+      # Assigns lanes (Y positions) to branches.
+      #
+      # Main branch gets lane 0, child branches get lanes below parent.
+      #
+      # @param diagram [Diagram::GitGraph] diagram
+      # @param branch_info [Hash] branch information
+      # @return [Hash<String, Integer>] branch name to lane number
+      def assign_lanes(diagram, branch_info)
+        lanes = {}
+        next_lane = 0
+
+        # Assign main branch to lane 0
+        lanes["main"] = next_lane
+        next_lane += 1
+
+        # Sort branches by order then by creation
+        sorted_branches = diagram.branches.sort_by do |b|
+          [branch_info[b.name][:order] || 999, b.name]
+        end
+
+        # Assign lanes to other branches
+        sorted_branches.each do |branch|
+          lanes[branch.name] = next_lane
+          next_lane += 1
+        end
+
+        lanes
+      end
+
+      # Positions commits with X and Y coordinates.
+      #
+      # @param commits [Array<Diagram::GitGraph::Commit>] commits
+      # @param commits_by_id [Hash] commit lookup
+      # @param lane_assignments [Hash] branch to lane mapping
+      # @return [Array<Hash>] positioned commits
+      def position_commits(commits, commits_by_id, lane_assignments)
+        positioned = []
+
+        commits.each_with_index do |commit, idx|
+          # X position is based on commit order
+          x = idx * COMMIT_SPACING + COMMIT_SPACING
+
+          # Y position is based on branch lane
+          branch = commit.branch_name || "main"
+          lane = lane_assignments[branch] || 0
+          y = lane * LANE_SPACING + LANE_SPACING
+
+          commit_id = commit.id || "commit_#{idx}"
+
+          positioned << {
+            id: commit_id,
+            x: x,
+            y: y,
+            branch: branch,
+            lane: lane,
+            type: commit.type || "NORMAL",
+            tag: commit.tag,
+            parent_ids: commit.parent_ids,
+            is_merge: commit.is_merge || false,
+            merge_branch: commit.merge_branch,
+            is_cherry_pick: commit.is_cherry_pick || false,
+            cherry_pick_parent: commit.cherry_pick_parent,
+            # Store original commit for reference
+            original: commit
+          }
+        end
+
+        positioned
+      end
+
+      # Builds connections between commits.
+      #
+      # @param positioned_commits [Array<Hash>] positioned commits
+      # @param commits_by_id [Hash] commit lookup
+      # @return [Array<Hash>] connections with from/to commits and type
+      def build_connections(positioned_commits, commits_by_id)
+        connections = []
+        commit_positions = positioned_commits.each_with_object({}) do |c, h|
+          h[c[:id]] = c
+        end
+
+        positioned_commits.each do |commit|
+          # Connect to parent commits
+          commit[:parent_ids].each do |parent_id|
+            parent = commit_positions[parent_id]
+            next unless parent
+
+            connection_type = if commit[:is_merge]
+                                :merge
+                              elsif commit[:is_cherry_pick]
+                                :cherry_pick
+                              else
+                                :normal
+                              end
+
+            connections << {
+              from: parent[:id],
+              to: commit[:id],
+              from_x: parent[:x],
+              from_y: parent[:y],
+              to_x: commit[:x],
+              to_y: commit[:y],
+              from_branch: parent[:branch],
+              to_branch: commit[:branch],
+              type: connection_type
+            }
+          end
+        end
+
+        connections
+      end
+
+      # Builds branch metadata for rendering.
+      #
+      # @param branches [Array<Diagram::GitGraph::Branch>] branches
+      # @param lane_assignments [Hash] lane assignments
+      # @param positioned_commits [Array<Hash>] positioned commits
+      # @return [Array<Hash>] branch metadata
+      def build_branch_metadata(branches, lane_assignments, positioned_commits)
+        metadata = []
+
+        # Add main branch
+        metadata << {
+          name: "main",
+          lane: lane_assignments["main"] || 0,
+          color: DEFAULT_COLORS[0]
+        }
+
+        # Add other branches with cycling colors
+        branches.each_with_index do |branch, idx|
+          metadata << {
+            name: branch.name,
+            lane: lane_assignments[branch.name] || (idx + 1),
+            color: DEFAULT_COLORS[(idx + 1) % DEFAULT_COLORS.length]
+          }
+        end
+
+        metadata
+      end
+
+      # Calculates total width needed for the layout.
+      #
+      # @param positioned_commits [Array<Hash>] positioned commits
+      # @return [Numeric] total width in pixels
+      def calculate_width(positioned_commits)
+        return COMMIT_SPACING * 2 if positioned_commits.empty?
+
+        max_x = positioned_commits.map { |c| c[:x] }.max
+        max_x + COMMIT_SPACING
+      end
+
+      # Calculates total height needed for the layout.
+      #
+      # @param lane_assignments [Hash] lane assignments
+      # @return [Numeric] total height in pixels
+      def calculate_height(lane_assignments)
+        return LANE_SPACING * 2 if lane_assignments.empty?
+
+        max_lane = lane_assignments.values.max
+        (max_lane + 1) * LANE_SPACING + LANE_SPACING
+      end
+    end
+  end
+end

data/lib/sirena/transform/info.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+require_relative '../diagram/info'
+
+module Sirena
+  module Transform
+    # Info diagram transformer for converting info models to renderable structure.
+    #
+    # Info diagrams have no complex layout requirements - they simply display
+    # an informational message. This transformer prepares basic data for rendering.
+    #
+    # @example Transform an info diagram
+    #   transform = InfoTransform.new
+    #   data = transform.to_graph(info_diagram)
+    class InfoTransform < Base
+      # Converts an info diagram to a simple data structure.
+      #
+      # Info diagrams don't need layout computation. This method validates
+      # the diagram and returns a structure for the renderer.
+      #
+      # @param diagram [Diagram::Info] the info 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?
+
+        {
+          id: diagram.id || 'info',
+          title: diagram.title,
+          show_info: diagram.show_info || false,
+          metadata: {
+            diagram_type: :info
+          }
+        }
+      end
+    end
+  end
+end