sirena 0.1.0

data/lib/sirena/transform/quadrant.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+require_relative '../diagram/quadrant'
+
+module Sirena
+  module Transform
+    # Quadrant chart transformer for converting quadrant models to
+    # renderable structure.
+    #
+    # Like pie charts, quadrant charts have a fixed layout structure
+    # (2x2 grid). This transformer validates the diagram and prepares
+    # the data with computed SVG coordinates for rendering.
+    #
+    # @example Transform a quadrant chart
+    #   transform = QuadrantTransform.new
+    #   data = transform.to_graph(quadrant_diagram)
+    class QuadrantTransform < Base
+      # Default dimensions for quadrant chart
+      DEFAULT_WIDTH = 800
+      DEFAULT_HEIGHT = 600
+      DEFAULT_MARGIN = 80
+
+      # Converts a quadrant diagram to a renderable data structure.
+      #
+      # @param diagram [Diagram::QuadrantChart] the quadrant diagram
+      # @return [Hash] data structure for rendering with SVG coordinates
+      # @raise [TransformError] if diagram is invalid
+      def to_graph(diagram)
+        raise TransformError, 'Invalid diagram' unless diagram.valid?
+
+        # Calculate dimensions
+        width = DEFAULT_WIDTH
+        height = DEFAULT_HEIGHT
+        margin = DEFAULT_MARGIN
+
+        # Chart area (excluding margins)
+        chart_width = width - (margin * 2)
+        chart_height = height - (margin * 2)
+
+        {
+          id: diagram.id || 'quadrant',
+          title: diagram.title,
+          dimensions: {
+            width: width,
+            height: height,
+            margin: margin,
+            chart_width: chart_width,
+            chart_height: chart_height,
+            chart_x: margin,
+            chart_y: margin
+          },
+          axes: {
+            x_left: diagram.x_axis_left || '',
+            x_right: diagram.x_axis_right || '',
+            y_bottom: diagram.y_axis_bottom || '',
+            y_top: diagram.y_axis_top || ''
+          },
+          quadrants: {
+            q1: {
+              label: diagram.quadrant_1_label,
+              number: 1,
+              bounds: calculate_quadrant_bounds(1, margin, chart_width,
+                                                chart_height)
+            },
+            q2: {
+              label: diagram.quadrant_2_label,
+              number: 2,
+              bounds: calculate_quadrant_bounds(2, margin, chart_width,
+                                                chart_height)
+            },
+            q3: {
+              label: diagram.quadrant_3_label,
+              number: 3,
+              bounds: calculate_quadrant_bounds(3, margin, chart_width,
+                                                chart_height)
+            },
+            q4: {
+              label: diagram.quadrant_4_label,
+              number: 4,
+              bounds: calculate_quadrant_bounds(4, margin, chart_width,
+                                                chart_height)
+            }
+          },
+          points: transform_points(diagram, margin, chart_width, chart_height)
+        }
+      end
+
+      private
+
+      # Calculate bounds for a specific quadrant.
+      #
+      # @param quadrant [Integer] quadrant number (1-4)
+      # @param margin [Float] chart margin
+      # @param chart_width [Float] width of chart area
+      # @param chart_height [Float] height of chart area
+      # @return [Hash] bounds with x, y, width, height
+      def calculate_quadrant_bounds(quadrant, margin, chart_width,
+                                     chart_height)
+        half_width = chart_width / 2.0
+        half_height = chart_height / 2.0
+
+        case quadrant
+        when 1 # Top-right
+          {
+            x: margin + half_width,
+            y: margin,
+            width: half_width,
+            height: half_height
+          }
+        when 2 # Top-left
+          {
+            x: margin,
+            y: margin,
+            width: half_width,
+            height: half_height
+          }
+        when 3 # Bottom-left
+          {
+            x: margin,
+            y: margin + half_height,
+            width: half_width,
+            height: half_height
+          }
+        when 4 # Bottom-right
+          {
+            x: margin + half_width,
+            y: margin + half_height,
+            width: half_width,
+            height: half_height
+          }
+        end
+      end
+
+      # Transform points with calculated SVG coordinates.
+      #
+      # @param diagram [Diagram::QuadrantChart] the diagram
+      # @param margin [Float] chart margin
+      # @param chart_width [Float] width of chart area
+      # @param chart_height [Float] height of chart area
+      # @return [Array<Hash>] points with SVG coordinates
+      def transform_points(diagram, margin, chart_width, chart_height)
+        diagram.points.map.with_index do |point, index|
+          # Convert normalized coordinates (0-1) to SVG coordinates
+          # Note: Y-axis is inverted in SVG (0 at top)
+          svg_x = margin + (point.x * chart_width)
+          svg_y = margin + ((1.0 - point.y) * chart_height)
+
+          {
+            id: "point_#{index}",
+            label: point.label,
+            x: point.x,
+            y: point.y,
+            svg_x: svg_x,
+            svg_y: svg_y,
+            quadrant: point.quadrant,
+            radius: point.radius || 6,
+            color: point.color,
+            stroke_color: point.stroke_color,
+            stroke_width: point.stroke_width || 2,
+            index: index
+          }
+        end
+      end
+    end
+  end
+end

data/lib/sirena/transform/radar.rb

@@ -0,0 +1,227 @@
+# frozen_string_literal: true
+
+module Sirena
+  module Transform
+    # Transforms a RadarChart diagram into a positioned layout structure.
+    #
+    # The layout algorithm handles:
+    # - Radial axis positioning (360° / num_axes)
+    # - Data point plotting on each axis
+    # - Value normalization and scaling
+    # - Polar to cartesian coordinate conversion
+    # - Polygon formation for each dataset
+    #
+    # @example Transform a radar chart
+    #   transform = Transform::Radar.new
+    #   layout = transform.to_graph(diagram)
+    class Radar
+      # Default radius of the chart
+      DEFAULT_RADIUS = 200
+
+      # Padding around the chart
+      PADDING = 80
+
+      # Label distance from the chart center
+      LABEL_OFFSET = 30
+
+      # Number of grid circles to draw
+      GRID_CIRCLES = 5
+
+      # Transforms the diagram into a layout structure.
+      #
+      # @param diagram [Diagram::RadarChart] the radar chart diagram
+      # @return [Hash] layout data with axes, curves, and dimensions
+      def to_graph(diagram)
+        num_axes = diagram.axes.length
+        return empty_layout if num_axes == 0
+
+        # Calculate value range
+        min_value, max_value = calculate_value_range(diagram)
+
+        # Position axes radially
+        positioned_axes = position_axes(diagram.axes, num_axes)
+
+        # Position data points for each curve
+        positioned_curves = position_curves(
+          diagram.curves,
+          positioned_axes,
+          min_value,
+          max_value
+        )
+
+        # Calculate grid circles for reference
+        grid_circles = calculate_grid_circles(min_value, max_value)
+
+        {
+          axes: positioned_axes,
+          curves: positioned_curves,
+          grid_circles: grid_circles,
+          center_x: DEFAULT_RADIUS + PADDING,
+          center_y: DEFAULT_RADIUS + PADDING,
+          radius: DEFAULT_RADIUS,
+          width: (DEFAULT_RADIUS + PADDING) * 2,
+          height: (DEFAULT_RADIUS + PADDING) * 2,
+          min_value: min_value,
+          max_value: max_value
+        }
+      end
+
+      private
+
+      # Returns an empty layout structure.
+      #
+      # @return [Hash] empty layout
+      def empty_layout
+        {
+          axes: [],
+          curves: [],
+          grid_circles: [],
+          center_x: PADDING,
+          center_y: PADDING,
+          radius: DEFAULT_RADIUS,
+          width: PADDING * 2,
+          height: PADDING * 2,
+          min_value: 0,
+          max_value: 0
+        }
+      end
+
+      # Calculates the value range from all curves.
+      #
+      # @param diagram [Diagram::RadarChart] diagram
+      # @return [Array<Numeric, Numeric>] min and max values
+      def calculate_value_range(diagram)
+        all_values = diagram.curves.flat_map { |c| c.values.values }
+
+        # Use configured min/max if available
+        min_value = diagram.options[:min] || all_values.min || 0
+        max_value = diagram.options[:max] || all_values.max || 100
+
+        # Ensure max > min
+        max_value = min_value + 1 if max_value <= min_value
+
+        [min_value, max_value]
+      end
+
+      # Positions axes radially around the center.
+      #
+      # @param axes [Array<Diagram::RadarAxis>] axes
+      # @param num_axes [Integer] number of axes
+      # @return [Array<Hash>] positioned axes
+      def position_axes(axes, num_axes)
+        positioned = []
+        angle_step = 360.0 / num_axes
+
+        axes.each_with_index do |axis, idx|
+          # Calculate angle (start at top, go clockwise)
+          angle_degrees = idx * angle_step - 90 # -90 to start at top
+          angle_radians = angle_degrees * Math::PI / 180.0
+
+          # Calculate end point of axis line
+          end_x = Math.cos(angle_radians) * DEFAULT_RADIUS
+          end_y = Math.sin(angle_radians) * DEFAULT_RADIUS
+
+          # Calculate label position (beyond the end point)
+          label_radius = DEFAULT_RADIUS + LABEL_OFFSET
+          label_x = Math.cos(angle_radians) * label_radius
+          label_y = Math.sin(angle_radians) * label_radius
+
+          positioned << {
+            id: axis.id,
+            label: axis.label,
+            angle_degrees: angle_degrees,
+            angle_radians: angle_radians,
+            end_x: end_x,
+            end_y: end_y,
+            label_x: label_x,
+            label_y: label_y,
+            index: idx
+          }
+        end
+
+        positioned
+      end
+
+      # Positions data points for all curves.
+      #
+      # @param curves [Array<Diagram::RadarCurve>] curves
+      # @param positioned_axes [Array<Hash>] positioned axes
+      # @param min_value [Numeric] minimum value
+      # @param max_value [Numeric] maximum value
+      # @return [Array<Hash>] positioned curves with points
+      def position_curves(curves, positioned_axes, min_value, max_value)
+        positioned = []
+
+        curves.each do |curve|
+          points = []
+
+          positioned_axes.each do |axis|
+            value = curve.value_for(axis[:id])
+
+            # Normalize value to 0-1 range
+            normalized = normalize_value(value, min_value, max_value)
+
+            # Calculate radius for this value
+            radius = normalized * DEFAULT_RADIUS
+
+            # Convert to cartesian coordinates
+            x = Math.cos(axis[:angle_radians]) * radius
+            y = Math.sin(axis[:angle_radians]) * radius
+
+            points << {
+              axis_id: axis[:id],
+              value: value,
+              normalized: normalized,
+              x: x,
+              y: y,
+              angle: axis[:angle_radians]
+            }
+          end
+
+          positioned << {
+            id: curve.id,
+            label: curve.label,
+            points: points
+          }
+        end
+
+        positioned
+      end
+
+      # Normalizes a value to the 0-1 range.
+      #
+      # @param value [Numeric] value to normalize
+      # @param min_value [Numeric] minimum value
+      # @param max_value [Numeric] maximum value
+      # @return [Numeric] normalized value
+      def normalize_value(value, min_value, max_value)
+        return 0 if max_value == min_value
+
+        ((value - min_value).to_f / (max_value - min_value)).clamp(0, 1)
+      end
+
+      # Calculates grid circle positions.
+      #
+      # @param min_value [Numeric] minimum value
+      # @param max_value [Numeric] maximum value
+      # @return [Array<Hash>] grid circles with radius and label
+      def calculate_grid_circles(min_value, max_value)
+        circles = []
+
+        GRID_CIRCLES.times do |i|
+          fraction = (i + 1).to_f / GRID_CIRCLES
+          radius = DEFAULT_RADIUS * fraction
+          value = min_value + (max_value - min_value) * fraction
+
+          circles << {
+            radius: radius,
+            value: value,
+            fraction: fraction
+          }
+        end
+
+        circles
+      end
+    end
+  end
+end

data/lib/sirena/transform/requirement.rb

@@ -0,0 +1,233 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+require_relative '../diagram/requirement'
+
+module Sirena
+  module Transform
+    # Requirement diagram transformer for converting requirement models to positioned layouts.
+    #
+    # Converts a requirement diagram model into a positioned layout structure.
+    # Handles requirement and element positioning, relationship routing,
+    # and hierarchical layout based on dependencies.
+    #
+    # @example Transform a requirement diagram
+    #   transform = RequirementTransform.new
+    #   layout = transform.to_layout(requirement_diagram)
+    class RequirementTransform < Base
+      # Default dimensions
+      DEFAULT_REQ_WIDTH = 180
+      DEFAULT_REQ_HEIGHT = 140
+      DEFAULT_ELEM_WIDTH = 150
+      DEFAULT_ELEM_HEIGHT = 80
+      DEFAULT_SPACING_X = 100
+      DEFAULT_SPACING_Y = 80
+      DEFAULT_PADDING = 20
+
+      # Converts a requirement diagram to a positioned layout structure.
+      #
+      # @param diagram [Diagram::RequirementDiagram] the requirement diagram to transform
+      # @return [Hash] positioned layout hash
+      # @raise [TransformError] if diagram is invalid
+      def to_graph(diagram)
+        raise TransformError, 'Diagram cannot be nil' if diagram.nil?
+
+        # Calculate positions for requirements and elements
+        nodes_layout = calculate_node_positions(diagram)
+
+        # Calculate relationship routes
+        relationships_layout = calculate_relationships(diagram, nodes_layout)
+
+        {
+          requirements: nodes_layout[:requirements],
+          elements: nodes_layout[:elements],
+          relationships: relationships_layout,
+          width: nodes_layout[:width],
+          height: nodes_layout[:height]
+        }
+      end
+
+      private
+
+      def calculate_node_positions(diagram)
+        requirements = diagram.requirements
+        elements = diagram.elements
+        relationships = diagram.relationships
+
+        # Build dependency graph to determine layout
+        levels = build_dependency_levels(requirements, elements, relationships)
+
+        positioned_requirements = {}
+        positioned_elements = {}
+
+        current_y = DEFAULT_PADDING
+        max_width = 0
+
+        levels.each_with_index do |level_nodes, level_idx|
+          current_x = DEFAULT_PADDING
+          max_height = 0
+
+          level_nodes.each do |node|
+            if node[:type] == :requirement
+              req = node[:object]
+              dims = calculate_requirement_dimensions(req)
+
+              positioned_requirements[req.name] = {
+                requirement: req,
+                x: current_x,
+                y: current_y,
+                width: dims[:width],
+                height: dims[:height],
+                level: level_idx
+              }
+
+              current_x += dims[:width] + DEFAULT_SPACING_X
+              max_height = [max_height, dims[:height]].max
+            else
+              elem = node[:object]
+              dims = calculate_element_dimensions(elem)
+
+              positioned_elements[elem.name] = {
+                element: elem,
+                x: current_x,
+                y: current_y,
+                width: dims[:width],
+                height: dims[:height],
+                level: level_idx
+              }
+
+              current_x += dims[:width] + DEFAULT_SPACING_X
+              max_height = [max_height, dims[:height]].max
+            end
+          end
+
+          max_width = [max_width, current_x].max
+          current_y += max_height + DEFAULT_SPACING_Y
+        end
+
+        {
+          requirements: positioned_requirements,
+          elements: positioned_elements,
+          width: max_width + DEFAULT_PADDING,
+          height: current_y + DEFAULT_PADDING
+        }
+      end
+
+      def build_dependency_levels(requirements, elements, relationships)
+        # Build a simple level-based layout
+        # Level 0: Elements
+        # Level 1: Requirements that depend on elements
+        # Level 2+: Requirements that depend on other requirements
+
+        nodes_by_name = {}
+        requirements.each { |r| nodes_by_name[r.name] = { type: :requirement, object: r, level: nil } }
+        elements.each { |e| nodes_by_name[e.name] = { type: :element, object: e, level: nil } }
+
+        # Start with elements at level 0
+        elements.each { |e| nodes_by_name[e.name][:level] = 0 }
+
+        # Build dependency map
+        dependencies = Hash.new { |h, k| h[k] = [] }
+        relationships.each do |rel|
+          # Source depends on target (arrow direction)
+          dependencies[rel.source] << rel.target
+        end
+
+        # Calculate levels for requirements
+        changed = true
+        max_iterations = 10
+        iterations = 0
+
+        while changed && iterations < max_iterations
+          changed = false
+          iterations += 1
+
+          requirements.each do |req|
+            node = nodes_by_name[req.name]
+            next if node[:level]
+
+            deps = dependencies[req.name]
+            if deps.empty?
+              # No dependencies, place at level 1
+              node[:level] = 1
+              changed = true
+            else
+              # Check if all dependencies have levels
+              dep_levels = deps.map { |d| nodes_by_name[d]&.dig(:level) }.compact
+              if dep_levels.size == deps.size
+                # All dependencies have levels
+                max_dep_level = dep_levels.max || 0
+                node[:level] = max_dep_level + 1
+                changed = true
+              end
+            end
+          end
+        end
+
+        # Assign default level to any remaining nodes
+        nodes_by_name.each do |_name, node|
+          node[:level] ||= 1 if node[:type] == :requirement
+        end
+
+        # Group by level
+        levels = []
+        nodes_by_name.values.group_by { |n| n[:level] }.sort.each do |_level, nodes|
+          levels << nodes
+        end
+
+        levels
+      end
+
+      def calculate_requirement_dimensions(requirement)
+        # Calculate based on text content
+        text = requirement.text || ''
+        text_lines = text.length > 0 ? ((text.length / 25.0).ceil) : 1
+
+        width = DEFAULT_REQ_WIDTH
+        height = DEFAULT_REQ_HEIGHT + (text_lines - 1) * 20
+
+        {
+          width: width,
+          height: [height, DEFAULT_REQ_HEIGHT].max
+        }
+      end
+
+      def calculate_element_dimensions(element)
+        {
+          width: DEFAULT_ELEM_WIDTH,
+          height: DEFAULT_ELEM_HEIGHT
+        }
+      end
+
+      def calculate_relationships(diagram, nodes_layout)
+        requirements = nodes_layout[:requirements]
+        elements = nodes_layout[:elements]
+        all_nodes = requirements.merge(elements)
+
+        diagram.relationships.map do |rel|
+          source_node = all_nodes[rel.source]
+          target_node = all_nodes[rel.target]
+
+          next unless source_node && target_node
+
+          # Calculate connection points
+          source_x = source_node[:x] + source_node[:width] / 2
+          source_y = source_node[:y] + source_node[:height]
+          target_x = target_node[:x] + target_node[:width] / 2
+          target_y = target_node[:y]
+
+          {
+            relationship: rel,
+            source: rel.source,
+            target: rel.target,
+            type: rel.type,
+            from_x: source_x,
+            from_y: source_y,
+            to_x: target_x,
+            to_y: target_y
+          }
+        end.compact
+      end
+    end
+  end
+end