sirena 0.1.0

data/lib/sirena/svg/group.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require 'lutaml/model'
+require_relative 'element'
+
+module Sirena
+  module Svg
+    # SVG Group element <g>
+    #
+    # Groups multiple SVG elements together for collective transformation
+    # and styling. Implements the Composite pattern for hierarchical
+    # SVG structure.
+    class Group < Element
+      attribute :children, Element, collection: true
+
+      xml do
+        root 'g'
+        map_attribute 'id', to: :id
+        map_attribute 'class', to: :class_name
+        map_attribute 'transform', to: :transform
+        map_attribute 'fill', to: :fill
+        map_attribute 'stroke', to: :stroke
+        map_attribute 'stroke-width', to: :stroke_width
+        map_attribute 'opacity', to: :opacity
+
+        map_element 'g', to: :children
+        map_element 'rect', to: :children
+        map_element 'circle', to: :children
+        map_element 'ellipse', to: :children
+        map_element 'line', to: :children
+        map_element 'path', to: :children
+        map_element 'polygon', to: :children
+        map_element 'polyline', to: :children
+        map_element 'text', to: :children
+      end
+
+      def initialize(**args)
+        super(**args)
+        self.children ||= []
+      end
+
+      # Add a child element to this group
+      #
+      # @param element [Element] SVG element to add
+      # @return [void]
+      def add_child(element)
+        children << element
+      end
+
+      alias << add_child
+
+      # Generate XML with children
+      #
+      # @return [String] XML string
+      def to_xml
+        attrs = build_attributes
+
+        if children.empty?
+          "<g#{attrs}/>"
+        else
+          parts = ["<g#{attrs}>"]
+          children.each do |child|
+            parts << "  #{child.to_xml}" if child.respond_to?(:to_xml)
+          end
+          parts << "</g>"
+          parts.join("\n")
+        end
+      end
+    end
+  end
+end

data/lib/sirena/svg/line.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'lutaml/model'
+require_relative 'element'
+
+module Sirena
+  module Svg
+    # SVG Line element <line>
+    #
+    # Represents a straight line between two points.
+    class Line < Element
+      attribute :x1, :float
+      attribute :y1, :float
+      attribute :x2, :float
+      attribute :y2, :float
+      attribute :stroke_dasharray, :string
+
+      xml do
+        root 'line'
+        map_attribute 'id', to: :id
+        map_attribute 'class', to: :class_name
+        map_attribute 'x1', to: :x1
+        map_attribute 'y1', to: :y1
+        map_attribute 'x2', to: :x2
+        map_attribute 'y2', to: :y2
+        map_attribute 'stroke', to: :stroke
+        map_attribute 'stroke-width', to: :stroke_width
+        map_attribute 'stroke-dasharray', to: :stroke_dasharray
+        map_attribute 'transform', to: :transform
+        map_attribute 'opacity', to: :opacity
+      end
+
+      protected
+
+      # Hook for element-specific attributes
+      #
+      # @return [Array<String>] array of attribute strings
+      def element_attributes
+        attrs = []
+        attrs << %( x1="#{x1}") if x1
+        attrs << %( y1="#{y1}") if y1
+        attrs << %( x2="#{x2}") if x2
+        attrs << %( y2="#{y2}") if y2
+        attrs << %( stroke-dasharray="#{stroke_dasharray}") if stroke_dasharray
+        attrs
+      end
+    end
+  end
+end

data/lib/sirena/svg/path.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require 'lutaml/model'
+require_relative 'element'
+
+module Sirena
+  module Svg
+    # SVG Path element <path>
+    #
+    # Represents complex shapes and lines using SVG path data syntax.
+    # Commonly used for drawing edges in diagrams with curves and bend points.
+    class Path < Element
+      attribute :d, :string
+      attribute :stroke_dasharray, :string
+      attribute :stroke_linecap, :string
+      attribute :stroke_linejoin, :string
+      attribute :marker_end, :string
+      attribute :marker_start, :string
+
+      xml do
+        root 'path'
+        map_attribute 'id', to: :id
+        map_attribute 'class', to: :class_name
+        map_attribute 'd', to: :d
+        map_attribute 'fill', to: :fill
+        map_attribute 'stroke', to: :stroke
+        map_attribute 'stroke-width', to: :stroke_width
+        map_attribute 'stroke-dasharray', to: :stroke_dasharray
+        map_attribute 'stroke-linecap', to: :stroke_linecap
+        map_attribute 'stroke-linejoin', to: :stroke_linejoin
+        map_attribute 'marker-end', to: :marker_end
+        map_attribute 'marker-start', to: :marker_start
+        map_attribute 'transform', to: :transform
+        map_attribute 'opacity', to: :opacity
+      end
+
+      # Helper to build path data from move and line commands
+      #
+      # @param commands [Array<Hash>] Path commands
+      # @return [String] Path data string
+      def self.build_path_data(commands)
+        commands.map do |cmd|
+          case cmd[:type]
+          when :move
+            "M #{cmd[:x]} #{cmd[:y]}"
+          when :line
+            "L #{cmd[:x]} #{cmd[:y]}"
+          when :curve
+            "Q #{cmd[:cx]} #{cmd[:cy]} #{cmd[:x]} #{cmd[:y]}"
+          when :bezier
+            c1x = cmd[:c1x]
+            c1y = cmd[:c1y]
+            c2x = cmd[:c2x]
+            c2y = cmd[:c2y]
+            "C #{c1x} #{c1y} #{c2x} #{c2y} #{cmd[:x]} #{cmd[:y]}"
+          when :close
+            'Z'
+          end
+        end.join(' ')
+      end
+
+      protected
+
+      def element_attributes
+        attrs = []
+        attrs << %( d="#{d}") if d
+        attrs << %( stroke-dasharray="#{stroke_dasharray}") if stroke_dasharray
+        attrs << %( stroke-linecap="#{stroke_linecap}") if stroke_linecap
+        attrs << %( stroke-linejoin="#{stroke_linejoin}") if stroke_linejoin
+        attrs << %( marker-end="#{marker_end}") if marker_end
+        attrs << %( marker-start="#{marker_start}") if marker_start
+        attrs
+      end
+    end
+  end
+end

data/lib/sirena/svg/polygon.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'lutaml/model'
+require_relative 'element'
+
+module Sirena
+  module Svg
+    # SVG Polygon element <polygon>
+    #
+    # Represents a closed shape defined by a series of points.
+    class Polygon < Element
+      attribute :points, :string
+
+      xml do
+        root 'polygon'
+        map_attribute 'id', to: :id
+        map_attribute 'class', to: :class_name
+        map_attribute 'points', to: :points
+        map_attribute 'fill', to: :fill
+        map_attribute 'stroke', to: :stroke
+        map_attribute 'stroke-width', to: :stroke_width
+        map_attribute 'transform', to: :transform
+        map_attribute 'opacity', to: :opacity
+      end
+
+      # Helper to build points string from coordinates array
+      #
+      # @param coords [Array<Array>] Array of [x, y] coordinates
+      # @return [String] Points string for polygon
+      def self.build_points(coords)
+        coords.map { |x, y| "#{x},#{y}" }.join(' ')
+      end
+
+      protected
+
+      def element_attributes
+        attrs = []
+        attrs << %( points="#{points}") if points
+        attrs
+      end
+    end
+  end
+end

data/lib/sirena/svg/polyline.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'lutaml/model'
+require_relative 'element'
+
+module Sirena
+  module Svg
+    # SVG Polyline element <polyline>
+    #
+    # Represents an open shape defined by a series of connected points.
+    class Polyline < Element
+      attribute :points, :string
+
+      xml do
+        root 'polyline'
+        map_attribute 'id', to: :id
+        map_attribute 'class', to: :class_name
+        map_attribute 'points', to: :points
+        map_attribute 'fill', to: :fill
+        map_attribute 'stroke', to: :stroke
+        map_attribute 'stroke-width', to: :stroke_width
+        map_attribute 'transform', to: :transform
+        map_attribute 'opacity', to: :opacity
+      end
+
+      # Helper to build points string from coordinates array
+      #
+      # @param coords [Array<Array>] Array of [x, y] coordinates
+      # @return [String] Points string for polyline
+      def self.build_points(coords)
+        coords.map { |x, y| "#{x},#{y}" }.join(' ')
+      end
+    end
+  end
+end

data/lib/sirena/svg/rect.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'lutaml/model'
+require_relative 'element'
+
+module Sirena
+  module Svg
+    # SVG Rectangle element <rect>
+    #
+    # Represents a rectangle shape with position, dimensions, and optional
+    # rounded corners.
+    class Rect < Element
+      attribute :x, :float
+      attribute :y, :float
+      attribute :width, :float
+      attribute :height, :float
+      attribute :rx, :float
+      attribute :ry, :float
+      attribute :stroke_dasharray, :string
+      attribute :fill_opacity, :string
+
+      xml do
+        root 'rect'
+        map_attribute 'id', to: :id
+        map_attribute 'class', to: :class_name
+        map_attribute 'x', to: :x
+        map_attribute 'y', to: :y
+        map_attribute 'width', to: :width
+        map_attribute 'height', to: :height
+        map_attribute 'rx', to: :rx
+        map_attribute 'ry', to: :ry
+        map_attribute 'fill', to: :fill
+        map_attribute 'fill-opacity', to: :fill_opacity
+        map_attribute 'stroke', to: :stroke
+        map_attribute 'stroke-width', to: :stroke_width
+        map_attribute 'stroke-dasharray', to: :stroke_dasharray
+        map_attribute 'transform', to: :transform
+        map_attribute 'opacity', to: :opacity
+      end
+
+      protected
+
+      def element_attributes
+        attrs = []
+        attrs << %( x="#{x}") if x
+        attrs << %( y="#{y}") if y
+        attrs << %( width="#{width}") if width
+        attrs << %( height="#{height}") if height
+        attrs << %( rx="#{rx}") if rx
+        attrs << %( ry="#{ry}") if ry
+        attrs << %( stroke-dasharray="#{stroke_dasharray}") if stroke_dasharray
+        attrs << %( fill-opacity="#{fill_opacity}") if fill_opacity
+        attrs
+      end
+    end
+  end
+end

data/lib/sirena/svg/style.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'lutaml/model'
+
+module Sirena
+  module Svg
+    # Represents CSS styling for SVG elements
+    #
+    # Encapsulates style properties that can be applied to SVG elements
+    # as inline styles or style attributes.
+    class Style < Lutaml::Model::Serializable
+      attribute :fill, :string
+      attribute :stroke, :string
+      attribute :stroke_width, :float
+      attribute :stroke_dasharray, :string
+      attribute :opacity, :float
+      attribute :fill_opacity, :float
+      attribute :stroke_opacity, :float
+      attribute :font_family, :string
+      attribute :font_size, :float
+      attribute :font_weight, :string
+      attribute :text_anchor, :string
+
+      # Convert style to CSS string for inline style attribute
+      #
+      # @return [String] CSS style string
+      def to_css
+        properties = []
+        properties << "fill:#{fill}" if fill
+        properties << "stroke:#{stroke}" if stroke
+        properties << "stroke-width:#{stroke_width}" if stroke_width
+        properties << "stroke-dasharray:#{stroke_dasharray}" if stroke_dasharray
+        properties << "opacity:#{opacity}" if opacity
+        properties << "fill-opacity:#{fill_opacity}" if fill_opacity
+        properties << "stroke-opacity:#{stroke_opacity}" if stroke_opacity
+        properties << "font-family:#{font_family}" if font_family
+        properties << "font-size:#{font_size}" if font_size
+        properties << "font-weight:#{font_weight}" if font_weight
+        properties << "text-anchor:#{text_anchor}" if text_anchor
+        properties.join(';')
+      end
+    end
+  end
+end

data/lib/sirena/svg/text.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require 'lutaml/model'
+require_relative 'element'
+
+module Sirena
+  module Svg
+    # SVG Text element <text>
+    #
+    # Displays text content at specified coordinates with optional styling
+    # and anchoring. Used for labels, annotations, and textual content.
+    class Text < Element
+      attribute :x, :float
+      attribute :y, :float
+      attribute :dx, :float
+      attribute :dy, :float
+      attribute :text_anchor, :string
+      attribute :font_family, :string
+      attribute :font_size, :string
+      attribute :font_weight, :string
+      attribute :font_style, :string
+      attribute :dominant_baseline, :string
+      attribute :content, :string
+
+      xml do
+        root 'text', mixed: true
+        map_attribute 'id', to: :id
+        map_attribute 'class', to: :class_name
+        map_attribute 'x', to: :x
+        map_attribute 'y', to: :y
+        map_attribute 'dx', to: :dx
+        map_attribute 'dy', to: :dy
+        map_attribute 'text-anchor', to: :text_anchor
+        map_attribute 'font-family', to: :font_family
+        map_attribute 'font-size', to: :font_size
+        map_attribute 'font-weight', to: :font_weight
+        map_attribute 'font-style', to: :font_style
+        map_attribute 'fill', to: :fill
+        map_attribute 'stroke', to: :stroke
+        map_attribute 'stroke-width', to: :stroke_width
+        map_attribute 'transform', to: :transform
+        map_attribute 'opacity', to: :opacity
+        map_attribute 'dominant-baseline', to: :dominant_baseline
+
+        map_content to: :content
+      end
+
+      # Override to_xml to include text content
+      def to_xml
+        attrs = build_attributes
+        "<text#{attrs}>#{content}</text>"
+      end
+
+      protected
+
+      def element_attributes
+        attrs = []
+        attrs << %( x="#{x}") if x
+        attrs << %( y="#{y}") if y
+        attrs << %( dx="#{dx}") if dx
+        attrs << %( dy="#{dy}") if dy
+        attrs << %( text-anchor="#{text_anchor}") if text_anchor
+        attrs << %( font-family="#{font_family}") if font_family
+        attrs << %( font-size="#{font_size}") if font_size
+        attrs << %( font-weight="#{font_weight}") if font_weight
+        attrs << %( font-style="#{font_style}") if font_style
+        attrs << %( dominant-baseline="#{dominant_baseline}") if dominant_baseline
+        attrs
+      end
+    end
+  end
+end

data/lib/sirena/svg.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative 'svg/style'
+require_relative 'svg/element'
+require_relative 'svg/document'
+require_relative 'svg/group'
+require_relative 'svg/rect'
+require_relative 'svg/circle'
+require_relative 'svg/path'
+require_relative 'svg/line'
+require_relative 'svg/polygon'
+require_relative 'svg/polyline'
+require_relative 'svg/text'
+require_relative 'svg/ellipse'
+
+module Sirena
+  module Svg
+  end
+end

data/lib/sirena/text_measurement.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Sirena
+  # Provides text dimension calculation for layout purposes.
+  #
+  # This utility calculates approximate text dimensions using character-based
+  # estimates, avoiding the need for font metrics libraries. The dimensions
+  # are used by the layout engine to size diagram nodes appropriately.
+  #
+  # @example Basic usage
+  #   dims = TextMeasurement.measure("Hello World", font_size: 14)
+  #   # => { width: 77.0, height: 14.0 }
+  #
+  # @example With dimension overrides
+  #   dims = TextMeasurement.measure("Text", font_size: 12,
+  #                                   width: 100, height: 20)
+  #   # => { width: 100, height: 20 }
+  class TextMeasurement
+    # Average character width as ratio of font size
+    AVERAGE_CHAR_WIDTH_RATIO = 0.5
+
+    # Text height as ratio of font size
+    HEIGHT_RATIO = 1.0
+
+    # Measures the approximate dimensions of text.
+    #
+    # @param text [String] the text to measure
+    # @param font_size [Numeric] the font size in points
+    # @param width [Numeric, nil] optional width override
+    # @param height [Numeric, nil] optional height override
+    # @return [Hash] hash with :width and :height keys
+    #
+    # @example Basic measurement
+    #   TextMeasurement.measure("Hello", font_size: 14)
+    #   # => { width: 35.0, height: 14.0 }
+    #
+    # @example With overrides
+    #   TextMeasurement.measure("Hi", font_size: 14, width: 50)
+    #   # => { width: 50, height: 14.0 }
+    def self.measure(text, font_size:, width: nil, height: nil)
+      calculated_width = calculate_width(text, font_size)
+      calculated_height = calculate_height(font_size)
+
+      {
+        width: width || calculated_width,
+        height: height || calculated_height
+      }
+    end
+
+    # Calculates the width of text.
+    #
+    # @param text [String] the text to measure
+    # @param font_size [Numeric] the font size in points
+    # @return [Float] the calculated width
+    def self.calculate_width(text, font_size)
+      char_count = text.to_s.length
+      avg_char_width = font_size * AVERAGE_CHAR_WIDTH_RATIO
+      char_count * avg_char_width
+    end
+
+    # Calculates the height of text.
+    #
+    # @param font_size [Numeric] the font size in points
+    # @return [Float] the calculated height
+    def self.calculate_height(font_size)
+      font_size * HEIGHT_RATIO
+    end
+
+    private_class_method :calculate_width, :calculate_height
+  end
+end

data/lib/sirena/theme/builtin/dark.yml

@@ -0,0 +1,70 @@
+name: dark
+description: "Dark theme optimized for low-light environments"
+
+colors:
+  background: "#1e1e1e"
+  surface: "#2d2d30"
+  surface_variant: "#3e3e42"
+
+  foreground: "#d4d4d4"
+  foreground_secondary: "#969696"
+
+  primary: "#3794ff"
+  secondary: "#858585"
+  accent: "#4ec9b0"
+  error: "#f48771"
+  warning: "#dcdcaa"
+  success: "#89d185"
+  info: "#9cdcfe"
+
+  node_fill: "#2d2d30"
+  node_stroke: "#858585"
+  edge_stroke: "#858585"
+  label_text: "#d4d4d4"
+
+  hover_fill: "#3e3e42"
+  active_fill: "#505050"
+  disabled_fill: "#404040"
+
+typography:
+  font_family: "Arial, Helvetica, sans-serif"
+  font_family_monospace: "Courier New, monospace"
+  font_size_small: 12.0
+  font_size_normal: 14.0
+  font_size_large: 16.0
+  font_size_title: 20.0
+  font_weight_normal: "normal"
+  font_weight_bold: "bold"
+  line_height: 1.5
+  text_transform: "none"
+
+shapes:
+  stroke_width: 2.0
+  stroke_width_thick: 3.0
+  stroke_width_thin: 1.0
+  fill_opacity: 1.0
+  stroke_opacity: 1.0
+  corner_radius: 5.0
+  corner_radius_large: 10.0
+  dash_pattern_dotted: "2,2"
+  dash_pattern_dashed: "5,5"
+
+spacing:
+  node_padding_x: 10.0
+  node_padding_y: 5.0
+  node_margin: 20.0
+  edge_spacing: 10.0
+  edge_label_offset: 5.0
+  rank_spacing: 100.0
+  node_spacing: 50.0
+
+effects:
+  shadow_enabled: true
+  shadow_color: "#00000066"
+  shadow_blur: 8.0
+  shadow_offset_x: 3.0
+  shadow_offset_y: 3.0
+  gradient_enabled: false
+  gradient_type: "linear"
+  arrow_size: 10.0
+  arrow_style: "filled"

data/lib/sirena/theme/builtin/default.yml

@@ -0,0 +1,80 @@
+name: default
+description: "Sirena default theme with clean, professional styling"
+
+colors:
+  background: "#ffffff"
+  surface: "#f5f5f5"
+  surface_variant: "#e0e0e0"
+
+  foreground: "#000000"
+  foreground_secondary: "#666666"
+
+  primary: "#007bff"
+  secondary: "#6c757d"
+  accent: "#28a745"
+  error: "#dc3545"
+  warning: "#ffc107"
+  success: "#28a745"
+  info: "#17a2b8"
+
+  node_fill: "#ffffff"
+  node_stroke: "#000000"
+  edge_stroke: "#000000"
+  label_text: "#000000"
+
+  hover_fill: "#f0f0f0"
+  active_fill: "#e0e0e0"
+  disabled_fill: "#cccccc"
+
+typography:
+  font_family: "Arial, Helvetica, sans-serif"
+  font_family_monospace: "Courier New, monospace"
+
+  font_size_small: 12.0
+  font_size_normal: 14.0
+  font_size_large: 16.0
+  font_size_title: 20.0
+
+  font_weight_normal: "normal"
+  font_weight_bold: "bold"
+
+  line_height: 1.5
+  text_transform: "none"
+
+shapes:
+  stroke_width: 2.0
+  stroke_width_thick: 3.0
+  stroke_width_thin: 1.0
+
+  fill_opacity: 1.0
+  stroke_opacity: 1.0
+
+  corner_radius: 5.0
+  corner_radius_large: 10.0
+
+  dash_pattern_dotted: "2,2"
+  dash_pattern_dashed: "5,5"
+
+spacing:
+  node_padding_x: 10.0
+  node_padding_y: 5.0
+  node_margin: 20.0
+
+  edge_spacing: 10.0
+  edge_label_offset: 5.0
+
+  rank_spacing: 100.0
+  node_spacing: 50.0
+
+effects:
+  shadow_enabled: false
+  shadow_color: "#00000033"
+  shadow_blur: 5.0
+  shadow_offset_x: 2.0
+  shadow_offset_y: 2.0
+
+  gradient_enabled: false
+  gradient_type: "linear"
+
+  arrow_size: 10.0
+  arrow_style: "filled"