sirena 0.1.0

data/lib/sirena/renderer/flowchart.rb

@@ -0,0 +1,301 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module Sirena
+  module Renderer
+    # Flowchart renderer for converting graphs to SVG.
+    #
+    # Converts a laid-out graph structure (with computed positions) into
+    # SVG using the Svg builder classes. Handles different node shapes,
+    # edge routing, and label positioning.
+    #
+    # @example Render a flowchart
+    #   renderer = FlowchartRenderer.new
+    #   svg = renderer.render(laid_out_graph)
+    class FlowchartRenderer < Base
+      # Renders a laid-out graph to SVG.
+      #
+      # @param graph [Hash] laid-out graph with node positions
+      # @return [Svg::Document] the rendered SVG document
+      def render(graph)
+        svg = create_document(graph)
+
+        # Render edges first (so they appear under nodes)
+        render_edges(graph, svg) if graph[:edges]
+
+        # Render nodes
+        render_nodes(graph, svg) if graph[:children]
+
+        svg
+      end
+
+      protected
+
+      def calculate_width(graph)
+        return 800 unless graph[:children]
+
+        max_x = graph[:children].map do |node|
+          (node[:x] || 0) + (node[:width] || 100)
+        end.max || 800
+
+        max_x + 40 # Add padding
+      end
+
+      def calculate_height(graph)
+        return 600 unless graph[:children]
+
+        max_y = graph[:children].map do |node|
+          (node[:y] || 0) + (node[:height] || 50)
+        end.max || 600
+
+        max_y + 40 # Add padding
+      end
+
+      def render_nodes(graph, svg)
+        graph[:children].each do |node|
+          render_node(node, svg)
+        end
+      end
+
+      def render_node(node, svg)
+        shape = node.dig(:metadata, :shape) || 'rect'
+
+        # Create group for node and its label
+        group = Svg::Group.new.tap do |g|
+          g.id = "node-#{node[:id]}"
+        end
+
+        # Render node shape
+        shape_element = create_node_shape(node, shape)
+        group.children << shape_element if shape_element
+
+        # Render node label
+        if node[:labels] && !node[:labels].empty?
+          label = node[:labels].first
+          text_element = create_node_label(node, label)
+          group.children << text_element if text_element
+        end
+
+        svg << group
+      end
+
+      def create_node_shape(node, shape)
+        x = node[:x] || 0
+        y = node[:y] || 0
+        width = node[:width] || 100
+        height = node[:height] || 50
+
+        case shape
+        when 'rect', 'subroutine'
+          create_rectangle(x, y, width, height)
+        when 'rounded', 'stadium'
+          create_rounded_rectangle(x, y, width, height)
+        when 'circle', 'double_circle'
+          create_circle_shape(x, y, width, height)
+        when 'rhombus'
+          create_rhombus(x, y, width, height)
+        when 'hexagon'
+          create_hexagon(x, y, width, height)
+        else
+          create_rectangle(x, y, width, height)
+        end
+      end
+
+      def create_rectangle(x, y, width, height)
+        Svg::Rect.new.tap do |rect|
+          rect.x = x
+          rect.y = y
+          rect.width = width
+          rect.height = height
+          apply_theme_to_node(rect)
+        end
+      end
+
+      def create_rounded_rectangle(x, y, width, height)
+        Svg::Rect.new.tap do |rect|
+          rect.x = x
+          rect.y = y
+          rect.width = width
+          rect.height = height
+          rect.rx = height / 2
+          rect.ry = height / 2
+          apply_theme_to_node(rect)
+        end
+      end
+
+      def create_circle_shape(x, y, width, height)
+        cx = x + width / 2
+        cy = y + height / 2
+        r = [width, height].min / 2
+
+        Svg::Circle.new.tap do |circle|
+          circle.cx = cx
+          circle.cy = cy
+          circle.r = r
+          apply_theme_to_node(circle)
+        end
+      end
+
+      def create_rhombus(x, y, width, height)
+        cx = x + width / 2
+        cy = y + height / 2
+
+        points = [
+          "#{cx},#{y}",
+          "#{x + width},#{cy}",
+          "#{cx},#{y + height}",
+          "#{x},#{cy}"
+        ].join(' ')
+
+        Svg::Polygon.new.tap do |polygon|
+          polygon.points = points
+          apply_theme_to_node(polygon)
+        end
+      end
+
+      def create_hexagon(x, y, width, height)
+        cy = y + height / 2
+        w4 = width / 4
+
+        points = [
+          "#{x + w4},#{y}",
+          "#{x + width - w4},#{y}",
+          "#{x + width},#{cy}",
+          "#{x + width - w4},#{y + height}",
+          "#{x + w4},#{y + height}",
+          "#{x},#{cy}"
+        ].join(' ')
+
+        Svg::Polygon.new.tap do |polygon|
+          polygon.points = points
+          apply_theme_to_node(polygon)
+        end
+      end
+
+      def create_node_label(node, label)
+        x = node[:x] || 0
+        y = node[:y] || 0
+        width = node[:width] || 100
+        height = node[:height] || 50
+
+        # Center text in node
+        text_x = x + width / 2
+        text_y = y + height / 2
+
+        Svg::Text.new.tap do |text|
+          text.x = text_x
+          text.y = text_y
+          text.content = label[:text]
+          apply_theme_to_text(text)
+          text.text_anchor = 'middle'
+          text.dominant_baseline = 'middle'
+        end
+      end
+
+      def render_edges(graph, svg)
+        graph[:edges].each do |edge|
+          render_edge(edge, graph, svg)
+        end
+      end
+
+      def render_edge(edge, graph, svg)
+        source = find_node(graph, edge[:sources]&.first)
+        target = find_node(graph, edge[:targets]&.first)
+
+        return unless source && target
+
+        # Calculate edge path
+        path_data = calculate_edge_path(source, target, edge)
+
+        # Create path element
+        path = Svg::Path.new.tap do |p|
+          p.d = path_data
+          p.fill = 'none'
+          apply_theme_to_edge(p)
+          p.marker_end = 'url(#arrowhead)' if arrow_type?(edge)
+        end
+
+        # Create group for edge and label
+        group = Svg::Group.new.tap do |g|
+          g.id = "edge-#{edge[:id]}"
+        end
+
+        group.children << path
+
+        # Render edge label if present
+        if edge[:labels] && !edge[:labels].empty?
+          label = edge[:labels].first
+          text = create_edge_label(source, target, label)
+          group.children << text if text
+        end
+
+        svg << group
+      end
+
+      def find_node(graph, node_id)
+        return nil unless graph[:children] && node_id
+
+        graph[:children].find { |n| n[:id] == node_id }
+      end
+
+      def calculate_edge_path(source, target, edge)
+        # Simple straight line path
+        sx = (source[:x] || 0) + (source[:width] || 100) / 2
+        sy = (source[:y] || 0) + (source[:height] || 50) / 2
+        tx = (target[:x] || 0) + (target[:width] || 100) / 2
+        ty = (target[:y] || 0) + (target[:height] || 50) / 2
+
+        # Use sections if available (from elkrb layout)
+        if edge[:sections] && !edge[:sections].empty?
+          section = edge[:sections].first
+          if section[:bendPoints] && !section[:bendPoints].empty?
+            return create_path_with_bends(sx, sy, tx, ty,
+                                          section[:bendPoints])
+          end
+        end
+
+        "M #{sx} #{sy} L #{tx} #{ty}"
+      end
+
+      def create_path_with_bends(sx, sy, tx, ty, bend_points)
+        path_parts = ["M #{sx} #{sy}"]
+
+        bend_points.each do |point|
+          path_parts << "L #{point[:x]} #{point[:y]}"
+        end
+
+        path_parts << "L #{tx} #{ty}"
+        path_parts.join(' ')
+      end
+
+      def arrow_type?(edge)
+        arrow_type = edge.dig(:metadata, :arrow_type)
+        %w[arrow dotted_arrow thick_arrow].include?(arrow_type)
+      end
+
+      def create_edge_label(source, target, label)
+        # Position label at midpoint of edge
+        sx = (source[:x] || 0) + (source[:width] || 100) / 2
+        sy = (source[:y] || 0) + (source[:height] || 50) / 2
+        tx = (target[:x] || 0) + (target[:width] || 100) / 2
+        ty = (target[:y] || 0) + (target[:height] || 50) / 2
+
+        mid_x = (sx + tx) / 2
+        mid_y = (sy + ty) / 2
+
+        Svg::Text.new.tap do |text|
+          text.x = mid_x
+          text.y = mid_y - 5 # Offset slightly above line
+          text.content = label[:text]
+          apply_theme_to_text(text)
+          # Use smaller font for edge labels
+          if theme_typography(:font_size_small)
+            text.font_size = theme_typography(:font_size_small).to_s
+          end
+          text.text_anchor = 'middle'
+        end
+      end
+    end
+  end
+end

data/lib/sirena/renderer/gantt.rb

@@ -0,0 +1,331 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "../svg/document"
+require_relative "../svg/rect"
+require_relative "../svg/text"
+require_relative "../svg/line"
+require_relative "../svg/path"
+require_relative "../svg/group"
+require_relative "../svg/polygon"
+
+module Sirena
+  module Renderer
+    # Gantt chart renderer for converting Gantt diagrams to SVG.
+    #
+    # Converts a Gantt diagram model into SVG with timeline, tasks,
+    # sections, and dependency indicators.
+    #
+    # @example Render a Gantt chart
+    #   renderer = GanttRenderer.new
+    #   svg = renderer.render(gantt_graph)
+    class GanttRenderer < Base
+      # Gantt chart dimensions
+      MARGIN_LEFT = 200
+      MARGIN_TOP = 80
+      MARGIN_RIGHT = 50
+      MARGIN_BOTTOM = 50
+      ROW_HEIGHT = 40
+      SECTION_HEIGHT = 30
+      TASK_BAR_HEIGHT = 24
+      TIMELINE_WIDTH = 800
+      TIMELINE_HEIGHT = 40
+      TITLE_Y = 40
+
+      # Task status colors
+      TASK_COLORS = {
+        done: "#5CB85C",      # Green
+        active: "#5BC0DE",    # Blue
+        critical: "#D9534F", # Red
+        default: "#428BCA"   # Default blue
+      }.freeze
+
+      # Renders a Gantt chart diagram to SVG.
+      #
+      # @param graph [Hash] the Gantt chart graph structure from transform
+      # @return [Svg::Document] the rendered SVG document
+      def render(graph)
+        @graph = graph
+        @current_y = MARGIN_TOP + TIMELINE_HEIGHT
+
+        svg = create_document_for_gantt(graph)
+
+        # Render title if present
+        render_title(graph, svg) if graph[:title]
+
+        # Render timeline axis
+        render_timeline(graph, svg)
+
+        # Render sections and tasks
+        render_sections(graph, svg)
+
+        svg
+      end
+
+      protected
+
+      def create_document_for_gantt(graph)
+        width = calculate_width_for_gantt(graph)
+        height = calculate_height_for_gantt(graph)
+
+        Svg::Document.new.tap do |doc|
+          doc.width = width
+          doc.height = height
+          doc.view_box = "0 0 #{width} #{height}"
+        end
+      end
+
+      def calculate_width_for_gantt(_graph)
+        MARGIN_LEFT + TIMELINE_WIDTH + MARGIN_RIGHT
+      end
+
+      def calculate_height_for_gantt(graph)
+        sections = graph[:sections] || []
+        total_rows = sections.sum { |s| s[:tasks].length + 1 } # +1 for section header
+
+        MARGIN_TOP + TIMELINE_HEIGHT + (total_rows * ROW_HEIGHT) + MARGIN_BOTTOM
+      end
+
+      def render_title(graph, svg)
+        title_text = Svg::Text.new.tap do |t|
+          t.x = MARGIN_LEFT + (TIMELINE_WIDTH / 2)
+          t.y = TITLE_Y
+          t.content = graph[:title]
+          t.fill = theme_color(:label_text) || "#000000"
+          t.font_family = theme_typography(:font_family) || "Arial, sans-serif"
+          t.font_size = (theme_typography(:font_size_large) || 18).to_s
+          t.text_anchor = "middle"
+          t.font_weight = "bold"
+        end
+        svg << title_text
+      end
+
+      def render_timeline(graph, svg)
+        timeline = graph[:timeline]
+        return unless timeline
+
+        # Timeline background
+        timeline_bg = Svg::Rect.new.tap do |r|
+          r.x = MARGIN_LEFT
+          r.y = MARGIN_TOP
+          r.width = TIMELINE_WIDTH
+          r.height = TIMELINE_HEIGHT
+          r.fill = theme_color(:node_fill) || "#f5f5f5"
+          r.stroke = theme_color(:node_stroke) || "#cccccc"
+          r.stroke_width = "1"
+        end
+        svg << timeline_bg
+
+        # Date labels
+        render_date_labels(timeline, svg)
+
+        # Grid lines (optional)
+        render_grid_lines(timeline, svg)
+      end
+
+      def render_date_labels(timeline, svg)
+        total_days = timeline[:total_days]
+        return if total_days <= 0
+
+        # Determine label interval based on timeline length
+        interval = calculate_label_interval(total_days)
+
+        (0..total_days).step(interval).each do |day|
+          date = timeline[:start_date] + day
+          x = MARGIN_LEFT + ((day.to_f / total_days) * TIMELINE_WIDTH)
+
+          # Date label
+          label = Svg::Text.new.tap do |t|
+            t.x = x
+            t.y = MARGIN_TOP + TIMELINE_HEIGHT - 10
+            t.content = format_date(date, @graph[:axis_format])
+            t.fill = theme_color(:label_text) || "#000000"
+            t.font_family = theme_typography(:font_family) || "Arial, sans-serif"
+            t.font_size = (theme_typography(:font_size_small) || 10).to_s
+            t.text_anchor = "middle"
+          end
+          svg << label
+        end
+      end
+
+      def render_grid_lines(timeline, svg)
+        total_days = timeline[:total_days]
+        return if total_days <= 0
+
+        interval = calculate_label_interval(total_days)
+        sections = @graph[:sections] || []
+        total_rows = sections.sum { |s| s[:tasks].length + 1 }
+        grid_height = total_rows * ROW_HEIGHT
+
+        (0..total_days).step(interval).each do |day|
+          x = MARGIN_LEFT + ((day.to_f / total_days) * TIMELINE_WIDTH)
+
+          line = Svg::Line.new.tap do |l|
+            l.x1 = x
+            l.y1 = MARGIN_TOP + TIMELINE_HEIGHT
+            l.x2 = x
+            l.y2 = MARGIN_TOP + TIMELINE_HEIGHT + grid_height
+            l.stroke = theme_color(:node_stroke) || "#e0e0e0"
+            l.stroke_width = "1"
+            l.stroke_dasharray = "2,2"
+          end
+          svg << line
+        end
+      end
+
+      def render_sections(graph, svg)
+        sections = graph[:sections] || []
+
+        sections.each do |section|
+          render_section_header(section, svg)
+          @current_y += SECTION_HEIGHT
+
+          section[:tasks].each do |task|
+            render_task(task, svg)
+            @current_y += ROW_HEIGHT
+          end
+        end
+      end
+
+      def render_section_header(section, svg)
+        # Section background
+        section_bg = Svg::Rect.new.tap do |r|
+          r.x = 0
+          r.y = @current_y
+          r.width = MARGIN_LEFT + TIMELINE_WIDTH + MARGIN_RIGHT
+          r.height = SECTION_HEIGHT
+          r.fill = theme_color(:section_bg) || "#f0f0f0"
+          r.stroke = "none"
+        end
+        svg << section_bg
+
+        # Section name
+        section_text = Svg::Text.new.tap do |t|
+          t.x = 10
+          t.y = @current_y + (SECTION_HEIGHT / 2)
+          t.content = section[:name]
+          t.fill = theme_color(:label_text) || "#000000"
+          t.font_family = theme_typography(:font_family) || "Arial, sans-serif"
+          t.font_size = (theme_typography(:font_size_base) || 14).to_s
+          t.dominant_baseline = "middle"
+          t.font_weight = "bold"
+        end
+        svg << section_text
+      end
+
+      def render_task(task, svg)
+        # Task label
+        task_label = Svg::Text.new.tap do |t|
+          t.x = 10
+          t.y = @current_y + (ROW_HEIGHT / 2)
+          t.content = task[:description]
+          t.fill = theme_color(:label_text) || "#000000"
+          t.font_family = theme_typography(:font_family) || "Arial, sans-serif"
+          t.font_size = (theme_typography(:font_size_small) || 12).to_s
+          t.dominant_baseline = "middle"
+        end
+        svg << task_label
+
+        # Task bar (if dates are available)
+        if task[:start_x] && task[:width]
+          render_task_bar(task, svg)
+        end
+      end
+
+      def render_task_bar(task, svg)
+        x = MARGIN_LEFT + task[:start_x]
+        y = @current_y + ((ROW_HEIGHT - TASK_BAR_HEIGHT) / 2)
+        width = task[:width]
+
+        # Handle milestone (zero duration)
+        if task[:milestone] || width < 10
+          render_milestone(x, y, task, svg)
+        else
+          render_normal_task(x, y, width, task, svg)
+        end
+      end
+
+      def render_normal_task(x, y, width, task, svg)
+        color = get_task_color(task)
+
+        task_bar = Svg::Rect.new.tap do |r|
+          r.x = x
+          r.y = y
+          r.width = width
+          r.height = TASK_BAR_HEIGHT
+          r.fill = color
+          r.stroke = theme_color(:node_stroke) || "#ffffff"
+          r.stroke_width = "1"
+          r.rx = "3"
+          r.ry = "3"
+        end
+        svg << task_bar
+
+        # Add task ID if present
+        if task[:id] && width > 40
+          id_text = Svg::Text.new.tap do |t|
+            t.x = x + (width / 2)
+            t.y = y + (TASK_BAR_HEIGHT / 2)
+            t.content = task[:id]
+            t.fill = "#ffffff"
+            t.font_family = theme_typography(:font_family) || "Arial, sans-serif"
+            t.font_size = "10"
+            t.text_anchor = "middle"
+            t.dominant_baseline = "middle"
+          end
+          svg << id_text
+        end
+      end
+
+      def render_milestone(x, y, task, svg)
+        # Render as diamond
+        center_y = y + (TASK_BAR_HEIGHT / 2)
+        size = 12
+
+        points = [
+          [x, center_y],               # Left
+          [x + size, center_y - size], # Top
+          [x + size * 2, center_y],    # Right
+          [x + size, center_y + size]  # Bottom
+        ]
+
+        diamond = Svg::Polygon.new.tap do |p|
+          p.points = points.map { |pt| "#{pt[0]},#{pt[1]}" }.join(" ")
+          p.fill = get_task_color(task)
+          p.stroke = theme_color(:node_stroke) || "#ffffff"
+          p.stroke_width = "2"
+        end
+        svg << diamond
+      end
+
+      def get_task_color(task)
+        return TASK_COLORS[:critical] if task[:critical]
+        return TASK_COLORS[:done] if task[:done]
+        return TASK_COLORS[:active] if task[:active]
+
+        TASK_COLORS[:default]
+      end
+
+      def calculate_label_interval(total_days)
+        return 1 if total_days <= 7
+        return 7 if total_days <= 60
+        return 14 if total_days <= 120
+
+        30
+      end
+
+      def format_date(date, format)
+        return date.strftime("%m-%d") unless format
+
+        # Simple format conversion (extend as needed)
+        format_str = format.gsub("%d", "%d")
+                           .gsub("%m", "%m")
+                           .gsub("%Y", "%Y")
+
+        date.strftime(format_str)
+      rescue StandardError
+        date.strftime("%m-%d")
+      end
+    end
+  end
+end