sirena 0.1.0

data/lib/sirena/renderer/requirement.rb

@@ -0,0 +1,371 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module Sirena
+  module Renderer
+    # Requirement diagram renderer for converting positioned layouts to SVG.
+    #
+    # Converts a positioned requirement diagram layout into SVG using the Svg
+    # builder classes. Handles requirements with properties, elements, and
+    # relationships between them.
+    #
+    # @example Render a requirement diagram
+    #   renderer = RequirementRenderer.new
+    #   svg = renderer.render(layout)
+    class RequirementRenderer < Base
+      # Risk level color mapping
+      RISK_COLORS = {
+        'high' => '#ff6b6b',
+        'medium' => '#ffd93d',
+        'low' => '#6bcf7f'
+      }.freeze
+
+      # Requirement type labels
+      REQUIREMENT_TYPE_LABELS = {
+        'requirement' => 'Requirement',
+        'functionalRequirement' => 'Functional Req',
+        'interfaceRequirement' => 'Interface Req',
+        'performanceRequirement' => 'Performance Req',
+        'physicalRequirement' => 'Physical Req',
+        'designConstraint' => 'Design Constraint'
+      }.freeze
+
+      # Renders a positioned layout to SVG.
+      #
+      # @param layout [Hash] positioned layout with requirement and element positions
+      # @return [Svg::Document] the rendered SVG document
+      def render(layout)
+        svg = create_document_from_layout(layout)
+
+        # Render relationships first (so they appear under nodes)
+        render_relationships(layout, svg) if layout[:relationships]
+
+        # Render requirements
+        render_requirements(layout, svg) if layout[:requirements]
+
+        # Render elements
+        render_elements(layout, svg) if layout[:elements]
+
+        svg
+      end
+
+      protected
+
+      def create_document_from_layout(layout)
+        width = layout[:width] || 800
+        height = layout[:height] || 600
+
+        Svg::Document.new(width: width, height: height)
+      end
+
+      def render_requirements(layout, svg)
+        layout[:requirements].each do |_req_name, req_info|
+          render_requirement(req_info, svg)
+        end
+      end
+
+      def render_requirement(req_info, svg)
+        requirement = req_info[:requirement]
+        x = req_info[:x]
+        y = req_info[:y]
+        width = req_info[:width]
+        height = req_info[:height]
+
+        # Create group for requirement
+        group = Svg::Group.new.tap do |g|
+          g.id = "requirement-#{requirement.name}"
+        end
+
+        # Draw main box
+        box = create_requirement_box(x, y, width, height, requirement)
+        group.children << box
+
+        # Draw header section with type
+        header_height = 30
+        header = create_requirement_header(x, y, width, header_height, requirement)
+        group.children << header
+
+        # Add text content
+        text_y = y + header_height + 15
+        line_height = 16
+
+        # ID
+        if requirement.id
+          id_text = create_property_text(x + 10, text_y, "ID: #{requirement.id}")
+          group.children << id_text
+          text_y += line_height
+        end
+
+        # Text
+        if requirement.text
+          text_lines = wrap_text(requirement.text, width - 20, 12)
+          text_lines.each do |line|
+            text_element = create_property_text(x + 10, text_y, line)
+            group.children << text_element
+            text_y += line_height
+          end
+          text_y += 5
+        end
+
+        # Risk
+        if requirement.risk
+          risk_text = create_property_text(x + 10, text_y, "Risk: #{requirement.risk.capitalize}")
+          risk_text.fill = get_risk_color(requirement.risk)
+          risk_text.font_weight = 'bold'
+          group.children << risk_text
+          text_y += line_height
+        end
+
+        # Verify method
+        if requirement.verifymethod
+          verify_text = create_property_text(x + 10, text_y, "Verify: #{requirement.verifymethod.capitalize}")
+          group.children << verify_text
+        end
+
+        svg << group
+      end
+
+      def create_requirement_box(x, y, width, height, requirement)
+        Svg::Rect.new.tap do |rect|
+          rect.x = x
+          rect.y = y
+          rect.width = width
+          rect.height = height
+          rect.fill = theme_color(:node_fill) || '#f9f9f9'
+          rect.stroke = get_risk_color(requirement.risk) || theme_color(:border_color) || '#333'
+          rect.stroke_width = '2'
+          rect.rx = '5'
+          rect.ry = '5'
+        end
+      end
+
+      def create_requirement_header(x, y, width, height, requirement)
+        group = Svg::Group.new
+
+        # Header background
+        header_bg = Svg::Rect.new.tap do |rect|
+          rect.x = x
+          rect.y = y
+          rect.width = width
+          rect.height = height
+          rect.fill = get_risk_color(requirement.risk) || theme_color(:node_fill) || '#e0e0e0'
+          rect.opacity = '0.3'
+        end
+        group.children << header_bg
+
+        # Type label
+        type_label = REQUIREMENT_TYPE_LABELS[requirement.type] || requirement.type
+        type_text = Svg::Text.new.tap do |text|
+          text.x = x + 10
+          text.y = y + height / 2
+          text.content = type_label
+          text.fill = theme_color(:text_color) || '#000'
+          text.font_size = '12'
+          text.font_weight = 'bold'
+          text.dominant_baseline = 'middle'
+        end
+        group.children << type_text
+
+        # Name on the right
+        name_text = Svg::Text.new.tap do |text|
+          text.x = x + width - 10
+          text.y = y + height / 2
+          text.content = requirement.name
+          text.fill = theme_color(:text_color) || '#000'
+          text.font_size = '11'
+          text.text_anchor = 'end'
+          text.dominant_baseline = 'middle'
+        end
+        group.children << name_text
+
+        group
+      end
+
+      def render_elements(layout, svg)
+        layout[:elements].each do |_elem_name, elem_info|
+          render_element(elem_info, svg)
+        end
+      end
+
+      def render_element(elem_info, svg)
+        element = elem_info[:element]
+        x = elem_info[:x]
+        y = elem_info[:y]
+        width = elem_info[:width]
+        height = elem_info[:height]
+
+        # Create group for element
+        group = Svg::Group.new.tap do |g|
+          g.id = "element-#{element.name}"
+        end
+
+        # Draw hexagon shape for elements
+        hexagon = create_hexagon(x, y, width, height)
+        group.children << hexagon
+
+        # Add name
+        name_text = Svg::Text.new.tap do |text|
+          text.x = x + width / 2
+          text.y = y + height / 2 - 10
+          text.content = element.name
+          text.fill = theme_color(:text_color) || '#000'
+          text.font_size = '14'
+          text.font_weight = 'bold'
+          text.text_anchor = 'middle'
+          text.dominant_baseline = 'middle'
+        end
+        group.children << name_text
+
+        # Add type if present
+        if element.type
+          type_text = Svg::Text.new.tap do |text|
+            text.x = x + width / 2
+            text.y = y + height / 2 + 10
+            text.content = "Type: #{element.type}"
+            text.fill = theme_color(:text_color) || '#666'
+            text.font_size = '11'
+            text.text_anchor = 'middle'
+            text.dominant_baseline = 'middle'
+          end
+          group.children << type_text
+        end
+
+        svg << group
+      end
+
+      def create_hexagon(x, y, width, height)
+        cx = x + width / 2
+        cy = y + height / 2
+        w = width / 2
+        h = height / 2
+
+        points = [
+          "#{cx - w},#{cy}",
+          "#{cx - w/2},#{cy - h}",
+          "#{cx + w/2},#{cy - h}",
+          "#{cx + w},#{cy}",
+          "#{cx + w/2},#{cy + h}",
+          "#{cx - w/2},#{cy + h}"
+        ].join(' ')
+
+        Svg::Polygon.new.tap do |polygon|
+          polygon.points = points
+          polygon.fill = theme_color(:node_fill) || '#e0f2f1'
+          polygon.stroke = theme_color(:border_color) || '#00796b'
+          polygon.stroke_width = '2'
+        end
+      end
+
+      def render_relationships(layout, svg)
+        layout[:relationships].each do |rel_info|
+          render_relationship(rel_info, svg)
+        end
+      end
+
+      def render_relationship(rel_info, svg)
+        # Calculate path for relationship
+        path_data = calculate_relationship_path(rel_info)
+
+        # Create path element
+        path = Svg::Path.new.tap do |p|
+          p.d = path_data
+          p.fill = 'none'
+          p.stroke = theme_color(:edge_color) || '#666'
+          p.stroke_width = '2'
+          p.marker_end = 'url(#arrowhead)'
+        end
+
+        # Create group for relationship
+        group = Svg::Group.new.tap do |g|
+          g.id = "relationship-#{rel_info[:source]}-#{rel_info[:target]}"
+        end
+
+        group.children << path
+
+        # Add label for relationship type
+        if rel_info[:type]
+          mid_x = (rel_info[:from_x] + rel_info[:to_x]) / 2
+          mid_y = (rel_info[:from_y] + rel_info[:to_y]) / 2
+
+          label_bg = Svg::Rect.new.tap do |rect|
+            label_width = rel_info[:type].length * 7
+            rect.x = mid_x - label_width / 2
+            rect.y = mid_y - 10
+            rect.width = label_width
+            rect.height = 18
+            rect.fill = '#fff'
+            rect.stroke = theme_color(:edge_color) || '#666'
+            rect.stroke_width = '1'
+            rect.rx = '3'
+          end
+          group.children << label_bg
+
+          label = Svg::Text.new.tap do |text|
+            text.x = mid_x
+            text.y = mid_y
+            text.content = rel_info[:type]
+            text.fill = theme_color(:text_color) || '#000'
+            text.font_size = '10'
+            text.text_anchor = 'middle'
+            text.dominant_baseline = 'middle'
+          end
+          group.children << label
+        end
+
+        svg << group
+      end
+
+      def calculate_relationship_path(rel_info)
+        from_x = rel_info[:from_x]
+        from_y = rel_info[:from_y]
+        to_x = rel_info[:to_x]
+        to_y = rel_info[:to_y]
+
+        # Use bezier curve for better aesthetics
+        control_offset = (to_y - from_y).abs / 3
+
+        "M #{from_x} #{from_y} C #{from_x} #{from_y + control_offset}, " \
+          "#{to_x} #{to_y - control_offset}, #{to_x} #{to_y}"
+      end
+
+      def create_property_text(x, y, content)
+        Svg::Text.new.tap do |text|
+          text.x = x
+          text.y = y
+          text.content = content
+          text.fill = theme_color(:text_color) || '#000'
+          text.font_size = '12'
+        end
+      end
+
+      def get_risk_color(risk)
+        return nil unless risk
+
+        RISK_COLORS[risk.downcase] || theme_color(:border_color) || '#666'
+      end
+
+      def wrap_text(text, max_width, font_size)
+        # Simple text wrapping
+        words = text.split(' ')
+        lines = []
+        current_line = []
+
+        chars_per_line = (max_width / (font_size * 0.6)).to_i
+
+        words.each do |word|
+          test_line = (current_line + [word]).join(' ')
+          if test_line.length <= chars_per_line
+            current_line << word
+          else
+            lines << current_line.join(' ') unless current_line.empty?
+            current_line = [word]
+          end
+        end
+
+        lines << current_line.join(' ') unless current_line.empty?
+        lines
+      end
+    end
+  end
+end

data/lib/sirena/renderer/sankey.rb

@@ -0,0 +1,255 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "../svg/document"
+require_relative "../svg/rect"
+require_relative "../svg/text"
+require_relative "../svg/path"
+require_relative "../svg/group"
+
+module Sirena
+  module Renderer
+    # Sankey renderer for converting Sankey diagrams to SVG.
+    #
+    # Converts a Sankey diagram model into SVG with nodes as rectangles
+    # and flows as curved paths with width proportional to flow values.
+    #
+    # @example Render a Sankey diagram
+    #   renderer = SankeyRenderer.new
+    #   svg = renderer.render(sankey_graph)
+    class SankeyRenderer < Base
+      # Sankey dimensions
+      MARGIN_LEFT = 60
+      MARGIN_TOP = 100
+      MARGIN_RIGHT = 60
+      MARGIN_BOTTOM = 60
+      TITLE_Y = 40
+
+      # Flow colors (cycle through for visual distinction)
+      FLOW_COLORS = [
+        "#4472C4", # Blue
+        "#ED7D31", # Orange
+        "#A5A5A5", # Gray
+        "#FFC000", # Yellow
+        "#5B9BD5", # Light Blue
+        "#70AD47", # Green
+        "#C00000", # Red
+        "#7030A0"  # Purple
+      ].freeze
+
+      # Renders a Sankey diagram to SVG.
+      #
+      # @param graph [Hash] the sankey graph structure from transform
+      # @return [Svg::Document] the rendered SVG document
+      def render(graph)
+        @graph = graph
+        @flow_color_index = 0
+
+        svg = create_document_for_sankey(graph)
+
+        # Render title if present
+        render_title(graph, svg) if graph[:title]
+
+        # Render flows first (so they appear behind nodes)
+        render_flows(graph, svg)
+
+        # Render nodes on top
+        render_nodes(graph, svg)
+
+        svg
+      end
+
+      protected
+
+      def create_document_for_sankey(graph)
+        width = calculate_width_for_sankey(graph)
+        height = calculate_height_for_sankey(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_sankey(graph)
+        nodes = graph[:nodes] || []
+        return MARGIN_LEFT + MARGIN_RIGHT + 400 if nodes.empty?
+
+        max_x = nodes.map { |n| n[:x] + n[:width] }.max || 400
+        MARGIN_LEFT + max_x + MARGIN_RIGHT + 100
+      end
+
+      def calculate_height_for_sankey(graph)
+        nodes = graph[:nodes] || []
+        return MARGIN_TOP + MARGIN_BOTTOM + 300 if nodes.empty?
+
+        max_y = nodes.map { |n| n[:y] + n[:height] }.max || 300
+        MARGIN_TOP + max_y + MARGIN_BOTTOM
+      end
+
+      def render_title(graph, svg)
+        title_text = Svg::Text.new.tap do |t|
+          t.x = (svg.width.to_i / 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_nodes(graph, svg)
+        nodes = graph[:nodes] || []
+
+        nodes.each do |node|
+          render_node(node, svg)
+        end
+      end
+
+      def render_node(node, svg)
+        x = MARGIN_LEFT + node[:x]
+        y = MARGIN_TOP + node[:y]
+        width = node[:width]
+        height = node[:height]
+
+        # Node rectangle
+        node_rect = Svg::Rect.new.tap do |r|
+          r.x = x
+          r.y = y
+          r.width = width
+          r.height = height
+          r.fill = theme_color(:node_fill) || "#2E86AB"
+          r.stroke = theme_color(:node_stroke) || "#1A5276"
+          r.stroke_width = "2"
+          r.rx = "3"
+          r.ry = "3"
+        end
+        svg << node_rect
+
+        # Node label
+        label_x = x + (width / 2)
+        label_y = y + (height / 2) + 5
+
+        node_text = Svg::Text.new.tap do |t|
+          t.x = label_x
+          t.y = label_y
+          t.content = node[:label]
+          t.fill = theme_color(:node_text) || "#FFFFFF"
+          t.font_family = theme_typography(:font_family) || "Arial, sans-serif"
+          t.font_size = (theme_typography(:font_size_small) || 11).to_s
+          t.text_anchor = "middle"
+          t.font_weight = "bold"
+        end
+        svg << node_text
+      end
+
+      def render_flows(graph, svg)
+        flows = graph[:flows] || []
+
+        flows.each do |flow|
+          render_flow(flow, svg)
+        end
+      end
+
+      def render_flow(flow, svg)
+        return if flow[:self_loop] # Skip self-loops for now
+
+        source_x = MARGIN_LEFT + flow[:source_x]
+        source_y = MARGIN_TOP + flow[:source_y]
+        target_x = MARGIN_LEFT + flow[:target_x]
+        target_y = MARGIN_TOP + flow[:target_y]
+        flow_width = flow[:width]
+
+        # Get color for this flow
+        color = get_flow_color
+
+        # Create curved path for flow
+        path_d = create_flow_path(source_x, source_y, target_x, target_y, flow_width)
+
+        flow_path = Svg::Path.new.tap do |p|
+          p.d = path_d
+          p.fill = color
+          p.opacity = "0.4"
+          p.stroke = "none"
+        end
+        svg << flow_path
+
+        # Optional: render flow value label
+        if flow[:value] && flow[:value] > 0
+          render_flow_label(flow, source_x, source_y, target_x, target_y, svg)
+        end
+      end
+
+      def create_flow_path(x1, y1, x2, y2, width)
+        # Calculate control points for bezier curve
+        dx = x2 - x1
+        control_offset = dx * 0.5
+
+        # Calculate perpendicular offset for width
+        half_width = width / 2.0
+
+        # Top curve points
+        top_y1 = y1 - half_width
+        top_y2 = y2 - half_width
+
+        # Bottom curve points
+        bottom_y1 = y1 + half_width
+        bottom_y2 = y2 + half_width
+
+        # Control points for bezier curves
+        cp1_x = x1 + control_offset
+        cp2_x = x2 - control_offset
+
+        # Build path: start at top-left, curve to top-right,
+        # line down right side, curve back to bottom-left, close
+        path_commands = [
+          "M #{x1} #{top_y1}",
+          "C #{cp1_x} #{top_y1}, #{cp2_x} #{top_y2}, #{x2} #{top_y2}",
+          "L #{x2} #{bottom_y2}",
+          "C #{cp2_x} #{bottom_y2}, #{cp1_x} #{bottom_y1}, #{x1} #{bottom_y1}",
+          "Z"
+        ]
+
+        path_commands.join(" ")
+      end
+
+      def render_flow_label(flow, x1, y1, x2, y2, svg)
+        # Position label at midpoint of flow
+        mid_x = (x1 + x2) / 2.0
+        mid_y = (y1 + y2) / 2.0
+
+        # Format value (show up to 2 decimal places)
+        value_text = format_flow_value(flow[:value])
+
+        label = Svg::Text.new.tap do |t|
+          t.x = mid_x
+          t.y = mid_y
+          t.content = value_text
+          t.fill = theme_color(:label_text) || "#333333"
+          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
+
+      def format_flow_value(value)
+        if value == value.to_i
+          value.to_i.to_s
+        else
+          format("%.2f", value).gsub(/\.?0+$/, "")
+        end
+      end
+
+      def get_flow_color
+        color = FLOW_COLORS[@flow_color_index % FLOW_COLORS.length]
+        @flow_color_index += 1
+        color
+      end
+    end
+  end
+end