sirena 0.1.0

data/lib/sirena/parser/xy_chart.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "grammars/xy_chart"
+require_relative "transforms/xy_chart"
+require_relative "../diagram/xy_chart"
+
+module Sirena
+  module Parser
+    # XY Chart parser for Mermaid xychart-beta diagram syntax.
+    #
+    # Uses Parslet grammar-based parsing to handle XY chart syntax
+    # with axes and multiple datasets.
+    #
+    # Parses XY charts with support for:
+    # - Title
+    # - X-axis with categorical or numeric values
+    # - Y-axis with range
+    # - Multiple datasets (line, bar, or named)
+    #
+    # @example Parse a simple XY chart
+    #   parser = XYChartParser.new
+    #   source = <<~MERMAID
+    #     xychart-beta
+    #       title "Sales Revenue"
+    #       x-axis [jan, feb, mar]
+    #       y-axis 0 --> 100
+    #       line [5, 10, 15]
+    #   MERMAID
+    #   diagram = parser.parse(source)
+    class XYChartParser < Base
+      # Parses XY chart diagram source into an XYChart model.
+      #
+      # @param source [String] the Mermaid XY chart diagram source
+      # @return [Diagram::XYChart] the parsed XY chart
+      # @raise [ParseError] if syntax is invalid
+      def parse(source)
+        grammar = Grammars::XYChart.new
+
+        begin
+          parse_tree = grammar.parse(source)
+        rescue Parslet::ParseFailed => e
+          raise ParseError, "Syntax error at #{e.parse_failure_cause.pos}: " \
+                           "#{e.parse_failure_cause}"
+        end
+
+        # Transform parse tree to intermediate representation
+        transform = Transforms::XYChart.new
+        result = transform.apply(parse_tree)
+
+        # Create the diagram model
+        create_diagram(result)
+      end
+
+      private
+
+      def create_diagram(result)
+        diagram = Diagram::XYChart.new
+        diagram.title = result[:title]
+
+        # Create X-axis
+        if result[:x_axis]
+          diagram.x_axis = create_x_axis(result[:x_axis])
+        end
+
+        # Create Y-axis
+        if result[:y_axis]
+          diagram.y_axis = create_y_axis(result[:y_axis])
+        end
+
+        # Create datasets
+        result[:datasets].each_with_index do |dataset_data, idx|
+          dataset = Diagram::XYDataset.new(
+            "dataset_#{idx}",
+            dataset_data[:label],
+            dataset_data[:chart_type]
+          )
+          dataset.values = dataset_data[:values]
+          diagram.add_dataset(dataset)
+        end
+
+        diagram
+      end
+
+      def create_x_axis(axis_data)
+        axis = Diagram::XYAxis.new
+        axis.label = axis_data[:label]
+
+        # Extract values and determine if categorical or numeric
+        values = axis_data[:values]
+
+        # Check if all values are numeric
+        if values.all? { |v| v.is_a?(Numeric) }
+          axis.type = :numeric
+          axis.values = values
+        else
+          axis.type = :categorical
+          axis.values = values.map(&:to_s)
+        end
+
+        axis
+      end
+
+      def create_y_axis(axis_data)
+        axis = Diagram::XYAxis.new
+        axis.label = axis_data[:label]
+        axis.type = :numeric
+        axis.min = axis_data[:min]
+        axis.max = axis_data[:max]
+        axis
+      end
+    end
+  end
+end

data/lib/sirena/parser.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require_relative 'parser/base'
+
+module Sirena
+  module Parser
+  end
+end

data/lib/sirena/renderer/architecture.rb

@@ -0,0 +1,251 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Sirena
+  module Renderer
+    # Architecture diagram renderer for converting positioned layouts to SVG
+    class ArchitectureRenderer < Base
+      # Icon mappings for common service types
+      ICON_GLYPHS = {
+        "database" => "⬢",
+        "server" => "▦",
+        "disk" => "◎",
+        "cloud" => "☁",
+        "internet" => "◈",
+        "browser" => "⊞",
+      }.freeze
+
+      # Renders a positioned layout to SVG
+      #
+      # @param layout [Hash] positioned layout with service positions
+      # @return [Svg::Document] the rendered SVG document
+      def render(layout)
+        svg = create_document_from_layout(layout)
+
+        # Render groups first (as backgrounds)
+        render_groups(layout, svg) if layout[:groups]
+
+        # Render edges (connections)
+        render_edges(layout, svg) if layout[:edges]
+
+        # Render services on top
+        render_services(layout, svg) if layout[:services]
+
+        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_groups(layout, svg)
+        # Render groups in order (parent groups before children)
+        layout[:groups].each do |group_id, group_info|
+          render_group(group_info, svg)
+        end
+      end
+
+      def render_group(group_info, svg)
+        group = group_info[:group]
+        x = group_info[:x]
+        y = group_info[:y]
+        width = group_info[:width]
+        height = group_info[:height]
+
+        # Create group element
+        g = Svg::Group.new.tap do |elem|
+          elem.id = "group-#{group.id}"
+        end
+
+        # Draw group boundary
+        boundary = Svg::Rect.new.tap do |rect|
+          rect.x = x
+          rect.y = y
+          rect.width = width
+          rect.height = height
+          rect.fill = theme_color(:group_background) || "#f0f0f0"
+          rect.fill_opacity = "0.3"
+          rect.stroke = theme_color(:border_color) || "#999"
+          rect.stroke_width = "2"
+          rect.stroke_dasharray = "5,5"
+          rect.rx = "8"
+          rect.ry = "8"
+        end
+
+        g.children << boundary
+
+        # Draw group label
+        if group.label
+          label = Svg::Text.new.tap do |text|
+            text.x = x + 10
+            text.y = y + 20
+            text.content = group.label
+            text.font_size = "14"
+            text.font_weight = "bold"
+            text.fill = theme_color(:text_color) || "#333"
+          end
+
+          g.children << label
+        end
+
+        # Draw group icon if present
+        if group.icon
+          icon_text = Svg::Text.new.tap do |text|
+            text.x = x + width - 30
+            text.y = y + 25
+            text.content = icon_glyph(group.icon)
+            text.font_size = "20"
+            text.fill = theme_color(:text_color) || "#666"
+          end
+
+          g.children << icon_text
+        end
+
+        svg << g
+      end
+
+      def render_services(layout, svg)
+        layout[:services].each do |service_id, service_info|
+          render_service(service_info, svg)
+        end
+      end
+
+      def render_service(service_info, svg)
+        service = service_info[:service]
+        x = service_info[:x]
+        y = service_info[:y]
+        width = service_info[:width]
+        height = service_info[:height]
+
+        # Create service group
+        g = Svg::Group.new.tap do |elem|
+          elem.id = "service-#{service.id}"
+        end
+
+        # Draw service box
+        box = Svg::Rect.new.tap do |rect|
+          rect.x = x
+          rect.y = y
+          rect.width = width
+          rect.height = height
+          apply_theme_to_node(rect)
+          rect.rx = "5"
+          rect.ry = "5"
+        end
+
+        g.children << box
+
+        # Draw service icon
+        if service.icon
+          icon = Svg::Text.new.tap do |text|
+            text.x = x + width / 2
+            text.y = y + height / 3
+            text.content = icon_glyph(service.icon)
+            text.font_size = "24"
+            text.text_anchor = "middle"
+            text.dominant_baseline = "middle"
+            text.fill = theme_color(:text_color) || "#666"
+          end
+
+          g.children << icon
+        end
+
+        # Draw service label
+        if service.label
+          label = Svg::Text.new.tap do |text|
+            text.x = x + width / 2
+            text.y = y + height * 2 / 3
+            text.content = service.label
+            apply_theme_to_text(text)
+            text.text_anchor = "middle"
+            text.dominant_baseline = "middle"
+            text.font_size = "12"
+          end
+
+          g.children << label
+        end
+
+        svg << g
+      end
+
+      def render_edges(layout, svg)
+        layout[:edges].each do |edge_info|
+          render_edge(edge_info, svg)
+        end
+      end
+
+      def render_edge(edge_info, svg)
+        edge = edge_info[:edge]
+        from_x = edge_info[:from_x]
+        from_y = edge_info[:from_y]
+        to_x = edge_info[:to_x]
+        to_y = edge_info[:to_y]
+
+        # Create edge group
+        g = Svg::Group.new.tap do |elem|
+          elem.id = "edge-#{edge.from_id}-#{edge.to_id}"
+        end
+
+        # Calculate path
+        path_data = calculate_edge_path(from_x, from_y, to_x, to_y)
+
+        # Draw connection line
+        path = Svg::Path.new.tap do |p|
+          p.d = path_data
+          p.fill = "none"
+          apply_theme_to_edge(p)
+          p.marker_end = "url(#arrowhead)"
+        end
+
+        g.children << path
+
+        # Draw edge label if present
+        if edge.label && !edge.label.empty?
+          mid_x = (from_x + to_x) / 2
+          mid_y = (from_y + to_y) / 2
+
+          label = Svg::Text.new.tap do |text|
+            text.x = mid_x
+            text.y = mid_y - 5
+            text.content = edge.label
+            text.font_size = "10"
+            text.text_anchor = "middle"
+            text.fill = theme_color(:text_color) || "#666"
+          end
+
+          g.children << label
+        end
+
+        svg << g
+      end
+
+      def calculate_edge_path(from_x, from_y, to_x, to_y)
+        # Use simple straight line for now
+        # Could be enhanced with bezier curves or orthogonal routing
+        "M #{from_x} #{from_y} L #{to_x} #{to_y}"
+      end
+
+      def icon_glyph(icon_name)
+        # Extract base icon name (remove prefixes like "logos:" or "fa:")
+        base_name = icon_name.split(":").last
+
+        # Map to glyph or use first letter as fallback
+        ICON_GLYPHS[base_name] || base_name[0].upcase
+      end
+
+      def calculate_width(layout)
+        layout[:width] || 800
+      end
+
+      def calculate_height(layout)
+        layout[:height] || 600
+      end
+    end
+  end
+end

data/lib/sirena/renderer/base.rb

@@ -0,0 +1,251 @@
+# frozen_string_literal: true
+
+module Sirena
+  module Renderer
+    # Abstract base class for diagram renderers.
+    #
+    # Renderers convert laid-out graph structures (with computed positions)
+    # into SVG documents using the Svg builder classes. Each diagram type has
+    # its own renderer that maps graph elements to appropriate SVG shapes.
+    #
+    # The renderer implements the template method pattern, defining the
+    # overall rendering pipeline while allowing subclasses to customize
+    # specific rendering steps.
+    #
+    # @example Define a custom renderer
+    #   class FlowchartRenderer < Renderer::Base
+    #     def render(graph)
+    #       svg = create_document(graph)
+    #       render_nodes(graph, svg)
+    #       render_edges(graph, svg)
+    #       svg
+    #     end
+    #
+    #     protected
+    #
+    #     def render_nodes(graph, svg)
+    #       # Render graph nodes as SVG shapes
+    #     end
+    #
+    #     def render_edges(graph, svg)
+    #       # Render graph edges as SVG paths
+    #     end
+    #   end
+    #
+    # @abstract Subclass and implement rendering methods
+    class Base
+      attr_accessor :theme
+
+      # Creates a new renderer instance.
+      #
+      # @param theme [Theme, nil] theme to use for rendering
+      def initialize(theme: nil)
+        @theme = theme || Theme::Registry.get(:default)
+      end
+
+      # Renders a laid-out graph to an SVG document.
+      #
+      # This method should be overridden by subclasses to implement
+      # diagram-specific rendering logic.
+      #
+      # @param graph [Object] the laid-out elkrb graph with positions
+      # @return [Svg::Document] the rendered SVG document
+      # @raise [NotImplementedError] if not implemented by subclass
+      def render(graph)
+        raise NotImplementedError,
+              "#{self.class} must implement #render(graph)"
+      end
+
+      protected
+
+      # Creates an SVG document with appropriate dimensions.
+      #
+      # @param graph [Object] the graph to get dimensions from
+      # @param padding [Numeric] padding around the diagram
+      # @return [Svg::Document] new SVG document
+      def create_document(graph, padding: 20)
+        width = calculate_width(graph) + (padding * 2)
+        height = calculate_height(graph) + (padding * 2)
+
+        Svg::Document.new.tap do |doc|
+          doc.width = width
+          doc.height = height
+          doc.view_box = "0 0 #{width} #{height}"
+        end
+      end
+
+      # Calculates the total width needed for the diagram.
+      #
+      # Subclasses should override this to compute width from graph.
+      #
+      # @param graph [Object] the graph
+      # @return [Numeric] the width in pixels
+      def calculate_width(_graph)
+        800 # Default width
+      end
+
+      # Calculates the total height needed for the diagram.
+      #
+      # Subclasses should override this to compute height from graph.
+      #
+      # @param graph [Object] the graph
+      # @return [Numeric] the height in pixels
+      def calculate_height(_graph)
+        600 # Default height
+      end
+
+      # Helper methods for accessing theme properties
+
+      # Gets a color property from the theme.
+      #
+      # @param property [Symbol] property name
+      # @return [String, nil] color value
+      def theme_color(property)
+        theme&.colors&.send(property)
+      rescue NoMethodError
+        nil
+      end
+
+      # Gets a typography property from the theme.
+      #
+      # @param property [Symbol] property name
+      # @return [String, Float, nil] typography value
+      def theme_typography(property)
+        theme&.typography&.send(property)
+      rescue NoMethodError
+        nil
+      end
+
+      # Gets a shape property from the theme.
+      #
+      # @param property [Symbol] property name
+      # @return [Float, String, nil] shape value
+      def theme_shape(property)
+        theme&.shapes&.send(property)
+      rescue NoMethodError
+        nil
+      end
+
+      # Gets a spacing property from the theme.
+      #
+      # @param property [Symbol] property name
+      # @return [Float, nil] spacing value
+      def theme_spacing(property)
+        theme&.spacing&.send(property)
+      rescue NoMethodError
+        nil
+      end
+
+      # Gets an effect property from the theme.
+      #
+      # @param property [Symbol] property name
+      # @return [Boolean, Float, String, nil] effect value
+      def theme_effect(property)
+        theme&.effects&.send(property)
+      rescue NoMethodError
+        nil
+      end
+
+      # Applies theme styles to a node element.
+      #
+      # @param element [Svg::Element] SVG element
+      # @return [void]
+      def apply_theme_to_node(element)
+        element.fill = theme_color(:node_fill) if theme_color(:node_fill)
+        element.stroke = theme_color(:node_stroke) if theme_color(:node_stroke)
+        if theme_shape(:stroke_width)
+          element.stroke_width = theme_shape(:stroke_width).to_s
+        end
+      end
+
+      # Applies theme styles to an edge element.
+      #
+      # @param element [Svg::Element] SVG element
+      # @return [void]
+      def apply_theme_to_edge(element)
+        element.stroke = theme_color(:edge_stroke) if theme_color(:edge_stroke)
+        if theme_shape(:stroke_width)
+          element.stroke_width = theme_shape(:stroke_width).to_s
+        end
+      end
+
+      # Applies theme styles to a text element.
+      #
+      # @param element [Svg::Text] SVG text element
+      # @return [void]
+      def apply_theme_to_text(element)
+        element.fill = theme_color(:label_text) if theme_color(:label_text)
+        if theme_typography(:font_family)
+          element.font_family = theme_typography(:font_family)
+        end
+        if theme_typography(:font_size_normal)
+          element.font_size = theme_typography(:font_size_normal).to_s
+        end
+      end
+
+      # Creates default style for SVG elements.
+      #
+      # @param element_type [Symbol] type of element (:node, :edge, :text)
+      # @return [Svg::Style] style object
+      def default_style(element_type)
+        case element_type
+        when :node
+          Svg::Style.new.tap do |style|
+            style.fill = theme_color(:node_fill) || '#ffffff'
+            style.stroke = theme_color(:node_stroke) || '#000000'
+            style.stroke_width =
+              (theme_shape(:stroke_width) || 2).to_s
+          end
+        when :edge
+          Svg::Style.new.tap do |style|
+            style.fill = 'none'
+            style.stroke = theme_color(:edge_stroke) || '#000000'
+            style.stroke_width =
+              (theme_shape(:stroke_width) || 2).to_s
+          end
+        when :text
+          Svg::Style.new.tap do |style|
+            style.fill = theme_color(:label_text) || '#000000'
+            style.font_family =
+              theme_typography(:font_family) || 'Arial, sans-serif'
+            style.font_size =
+              (theme_typography(:font_size_normal) || 14).to_s
+            style.text_anchor = 'middle'
+          end
+        else
+          Svg::Style.new
+        end
+      end
+
+      # Creates an SVG path data string from bend points.
+      #
+      # @param start_point [Hash] hash with :x and :y keys
+      # @param end_point [Hash] hash with :x and :y keys
+      # @param bend_points [Array<Hash>] array of hashes with :x and :y
+      # @return [String] SVG path data string
+      def create_path_data(start_point, end_point, bend_points = [])
+        points = [start_point] + bend_points + [end_point]
+        path_parts = ["M #{points[0][:x]} #{points[0][:y]}"]
+
+        points[1..].each do |point|
+          path_parts << "L #{point[:x]} #{point[:y]}"
+        end
+
+        path_parts.join(' ')
+      end
+
+      # Adds an arrow marker to the SVG document.
+      #
+      # @param svg [Svg::Document] the SVG document
+      # @param id [String] unique identifier for the marker
+      # @return [void]
+      def add_arrow_marker(svg, id: 'arrow')
+        # This is a placeholder for actual marker implementation
+        # Subclasses can implement this to add arrow markers
+      end
+    end
+
+    # Error raised during rendering.
+    class RenderError < StandardError; end
+  end
+end