sirena 0.1.0

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

@@ -0,0 +1,70 @@
+name: high_contrast
+description: "High contrast theme for accessibility"
+
+colors:
+  background: "#000000"
+  surface: "#000000"
+  surface_variant: "#1a1a1a"
+
+  foreground: "#ffffff"
+  foreground_secondary: "#ffffff"
+
+  primary: "#ffff00"
+  secondary: "#00ffff"
+  accent: "#00ff00"
+  error: "#ff0000"
+  warning: "#ff8800"
+  success: "#00ff00"
+  info: "#00ffff"
+
+  node_fill: "#000000"
+  node_stroke: "#ffffff"
+  edge_stroke: "#ffffff"
+  label_text: "#ffffff"
+
+  hover_fill: "#1a1a1a"
+  active_fill: "#333333"
+  disabled_fill: "#666666"
+
+typography:
+  font_family: "Arial, Helvetica, sans-serif"
+  font_family_monospace: "Courier New, monospace"
+  font_size_small: 14.0
+  font_size_normal: 16.0
+  font_size_large: 18.0
+  font_size_title: 24.0
+  font_weight_normal: "bold"
+  font_weight_bold: "bold"
+  line_height: 1.6
+  text_transform: "none"
+
+shapes:
+  stroke_width: 3.0
+  stroke_width_thick: 4.0
+  stroke_width_thin: 2.0
+  fill_opacity: 1.0
+  stroke_opacity: 1.0
+  corner_radius: 0.0
+  corner_radius_large: 0.0
+  dash_pattern_dotted: "4,4"
+  dash_pattern_dashed: "8,8"
+
+spacing:
+  node_padding_x: 15.0
+  node_padding_y: 8.0
+  node_margin: 25.0
+  edge_spacing: 15.0
+  edge_label_offset: 8.0
+  rank_spacing: 120.0
+  node_spacing: 60.0
+
+effects:
+  shadow_enabled: false
+  shadow_color: "#000000"
+  shadow_blur: 0.0
+  shadow_offset_x: 0.0
+  shadow_offset_y: 0.0
+  gradient_enabled: false
+  gradient_type: "linear"
+  arrow_size: 12.0
+  arrow_style: "filled"

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

@@ -0,0 +1,70 @@
+name: light
+description: "Light theme with softer colors"
+
+colors:
+  background: "#fafafa"
+  surface: "#ffffff"
+  surface_variant: "#f0f0f0"
+
+  foreground: "#333333"
+  foreground_secondary: "#757575"
+
+  primary: "#1976d2"
+  secondary: "#757575"
+  accent: "#388e3c"
+  error: "#d32f2f"
+  warning: "#f57c00"
+  success: "#388e3c"
+  info: "#0288d1"
+
+  node_fill: "#ffffff"
+  node_stroke: "#757575"
+  edge_stroke: "#757575"
+  label_text: "#333333"
+
+  hover_fill: "#f5f5f5"
+  active_fill: "#eeeeee"
+  disabled_fill: "#e0e0e0"
+
+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: 1.5
+  stroke_width_thick: 2.5
+  stroke_width_thin: 1.0
+  fill_opacity: 1.0
+  stroke_opacity: 1.0
+  corner_radius: 4.0
+  corner_radius_large: 8.0
+  dash_pattern_dotted: "2,2"
+  dash_pattern_dashed: "5,5"
+
+spacing:
+  node_padding_x: 12.0
+  node_padding_y: 6.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: 4.0
+  shadow_offset_x: 2.0
+  shadow_offset_y: 2.0
+  gradient_enabled: false
+  gradient_type: "linear"
+  arrow_size: 10.0
+  arrow_style: "filled"

data/lib/sirena/theme/color_palette.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+# Represents the color palette for diagram theming
+class Sirena::Theme::ColorPalette < Lutaml::Model::Serializable
+  attribute :background, :string
+  attribute :surface, :string
+  attribute :surface_variant, :string
+  attribute :foreground, :string
+  attribute :foreground_secondary, :string
+  attribute :primary, :string
+  attribute :secondary, :string
+  attribute :accent, :string
+  attribute :error, :string
+  attribute :warning, :string
+  attribute :success, :string
+  attribute :info, :string
+  attribute :node_fill, :string
+  attribute :node_stroke, :string
+  attribute :edge_stroke, :string
+  attribute :label_text, :string
+  attribute :hover_fill, :string
+  attribute :active_fill, :string
+  attribute :disabled_fill, :string
+
+  yaml do
+    map "background", to: :background
+    map "surface", to: :surface
+    map "surface_variant", to: :surface_variant
+    map "foreground", to: :foreground
+    map "foreground_secondary", to: :foreground_secondary
+    map "primary", to: :primary
+    map "secondary", to: :secondary
+    map "accent", to: :accent
+    map "error", to: :error
+    map "warning", to: :warning
+    map "success", to: :success
+    map "info", to: :info
+    map "node_fill", to: :node_fill
+    map "node_stroke", to: :node_stroke
+    map "edge_stroke", to: :edge_stroke
+    map "label_text", to: :label_text
+    map "hover_fill", to: :hover_fill
+    map "active_fill", to: :active_fill
+    map "disabled_fill", to: :disabled_fill
+  end
+end

data/lib/sirena/theme/effect_styles.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+# Represents effect styles for diagram theming
+class Sirena::Theme::EffectStyles < Lutaml::Model::Serializable
+  attribute :shadow_enabled, :boolean
+  attribute :shadow_color, :string
+  attribute :shadow_blur, :float
+  attribute :shadow_offset_x, :float
+  attribute :shadow_offset_y, :float
+  attribute :gradient_enabled, :boolean
+  attribute :gradient_type, :string
+  attribute :arrow_size, :float
+  attribute :arrow_style, :string
+
+  yaml do
+    map "shadow_enabled", to: :shadow_enabled
+    map "shadow_color", to: :shadow_color
+    map "shadow_blur", to: :shadow_blur
+    map "shadow_offset_x", to: :shadow_offset_x
+    map "shadow_offset_y", to: :shadow_offset_y
+    map "gradient_enabled", to: :gradient_enabled
+    map "gradient_type", to: :gradient_type
+    map "arrow_size", to: :arrow_size
+    map "arrow_style", to: :arrow_style
+  end
+end

data/lib/sirena/theme/registry.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative "../theme"
+
+# Registry for pre-defined and custom themes
+class Sirena::Theme::Registry
+  @themes = {}
+
+  class << self
+    # Register a theme
+    def register(name, theme)
+      @themes[name.to_sym] = theme
+    end
+
+    # Get a theme by name
+    def get(name)
+      @themes[name.to_sym]
+    end
+
+    # List all registered theme names
+    def list
+      @themes.keys
+    end
+
+    # Load all built-in themes
+    def load_builtin_themes
+      builtin_dir = File.join(__dir__, "builtin")
+      return unless Dir.exist?(builtin_dir)
+
+      Dir.glob(File.join(builtin_dir, "*.yml")).each do |path|
+        theme = Sirena::Theme.load(path)
+        register(theme.name, theme)
+      end
+    end
+
+    # Clear all registered themes (useful for testing)
+    def clear
+      @themes = {}
+    end
+  end
+end

data/lib/sirena/theme/shape_styles.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+# Represents shape styling settings for diagram theming
+class Sirena::Theme::ShapeStyles < Lutaml::Model::Serializable
+  attribute :stroke_width, :float
+  attribute :stroke_width_thick, :float
+  attribute :stroke_width_thin, :float
+  attribute :fill_opacity, :float
+  attribute :stroke_opacity, :float
+  attribute :corner_radius, :float
+  attribute :corner_radius_large, :float
+  attribute :dash_pattern_dotted, :string
+  attribute :dash_pattern_dashed, :string
+
+  yaml do
+    map "stroke_width", to: :stroke_width
+    map "stroke_width_thick", to: :stroke_width_thick
+    map "stroke_width_thin", to: :stroke_width_thin
+    map "fill_opacity", to: :fill_opacity
+    map "stroke_opacity", to: :stroke_opacity
+    map "corner_radius", to: :corner_radius
+    map "corner_radius_large", to: :corner_radius_large
+    map "dash_pattern_dotted", to: :dash_pattern_dotted
+    map "dash_pattern_dashed", to: :dash_pattern_dashed
+  end
+end

data/lib/sirena/theme/spacing_config.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+# Represents spacing configuration for diagram theming
+class Sirena::Theme::SpacingConfig < Lutaml::Model::Serializable
+  attribute :node_padding_x, :float
+  attribute :node_padding_y, :float
+  attribute :node_margin, :float
+  attribute :edge_spacing, :float
+  attribute :edge_label_offset, :float
+  attribute :rank_spacing, :float
+  attribute :node_spacing, :float
+
+  yaml do
+    map "node_padding_x", to: :node_padding_x
+    map "node_padding_y", to: :node_padding_y
+    map "node_margin", to: :node_margin
+    map "edge_spacing", to: :edge_spacing
+    map "edge_label_offset", to: :edge_label_offset
+    map "rank_spacing", to: :rank_spacing
+    map "node_spacing", to: :node_spacing
+  end
+end

data/lib/sirena/theme/typography.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+# Represents typography settings for diagram theming
+class Sirena::Theme::Typography < Lutaml::Model::Serializable
+  attribute :font_family, :string
+  attribute :font_family_monospace, :string
+  attribute :font_size_small, :float
+  attribute :font_size_normal, :float
+  attribute :font_size_large, :float
+  attribute :font_size_title, :float
+  attribute :font_weight_normal, :string
+  attribute :font_weight_bold, :string
+  attribute :line_height, :float
+  attribute :text_transform, :string
+
+  yaml do
+    map "font_family", to: :font_family
+    map "font_family_monospace", to: :font_family_monospace
+    map "font_size_small", to: :font_size_small
+    map "font_size_normal", to: :font_size_normal
+    map "font_size_large", to: :font_size_large
+    map "font_size_title", to: :font_size_title
+    map "font_weight_normal", to: :font_weight_normal
+    map "font_weight_bold", to: :font_weight_bold
+    map "line_height", to: :line_height
+    map "text_transform", to: :text_transform
+  end
+end

data/lib/sirena/theme.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Sirena
+  # Represents a complete visual theme for diagram rendering
+  class Theme < Lutaml::Model::Serializable
+  end
+end
+
+# Now load sub-models after Theme class is defined
+require_relative "theme/color_palette"
+require_relative "theme/typography"
+require_relative "theme/shape_styles"
+require_relative "theme/spacing_config"
+require_relative "theme/effect_styles"
+
+module Sirena
+  class Theme
+    attribute :name, :string
+    attribute :description, :string
+    attribute :colors, ColorPalette
+    attribute :typography, Typography
+    attribute :shapes, ShapeStyles
+    attribute :spacing, SpacingConfig
+    attribute :effects, EffectStyles
+
+    yaml do
+      map "name", to: :name
+      map "description", to: :description
+      map "colors", to: :colors
+      map "typography", to: :typography
+      map "shapes", to: :shapes
+      map "spacing", to: :spacing
+      map "effects", to: :effects
+    end
+
+    # Load theme from YAML file
+    def self.load(path)
+      yaml_content = File.read(path)
+      from_yaml(yaml_content)
+    end
+
+    # Merge with another theme (for overrides)
+    def merge(other_theme)
+      merged = self.class.new(
+        name: other_theme.name || name,
+        description: other_theme.description || description,
+        colors: merge_attribute(colors, other_theme.colors),
+        typography: merge_attribute(typography, other_theme.typography),
+        shapes: merge_attribute(shapes, other_theme.shapes),
+        spacing: merge_attribute(spacing, other_theme.spacing),
+        effects: merge_attribute(effects, other_theme.effects)
+      )
+      merged
+    end
+
+    private
+
+    def merge_attribute(base, override)
+      return base if override.nil?
+      return override if base.nil?
+
+      # For now, just use override if provided, base otherwise
+      # Full deep merge would require iterating over attributes
+      override
+    end
+  end
+end

data/lib/sirena/transform/architecture.rb

@@ -0,0 +1,273 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "../diagram/architecture"
+
+module Sirena
+  module Transform
+    # Architecture diagram transformer for converting architecture models to positioned layouts
+    class ArchitectureTransform < Base
+      # Default dimensions
+      DEFAULT_SERVICE_WIDTH = 120
+      DEFAULT_SERVICE_HEIGHT = 80
+      DEFAULT_GROUP_PADDING = 30
+      DEFAULT_SPACING = 40
+      DEFAULT_ICON_SIZE = 24
+
+      # Converts an architecture diagram to a positioned layout structure
+      #
+      # @param diagram [Diagram::ArchitectureDiagram] the 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?
+
+        # Build hierarchy
+        hierarchy = build_hierarchy(diagram)
+
+        # Calculate positions
+        service_positions = position_services(diagram, hierarchy)
+        group_bounds = calculate_group_bounds(diagram, service_positions)
+        edge_positions = position_edges(diagram, service_positions)
+
+        {
+          services: service_positions,
+          groups: group_bounds,
+          edges: edge_positions,
+          width: calculate_total_width(service_positions, group_bounds),
+          height: calculate_total_height(service_positions, group_bounds),
+        }
+      end
+
+      private
+
+      def build_hierarchy(diagram)
+        hierarchy = {
+          groups: {},
+          services_by_group: {},
+        }
+
+        # Map groups
+        diagram.groups.each do |group|
+          parent_id = group.parent_id || :root
+          hierarchy[:groups][group.id] = {
+            group: group,
+            parent_id: parent_id,
+            children: [],
+          }
+        end
+
+        # Build parent-child relationships for groups
+        diagram.groups.each do |group|
+          if group.parent_id && hierarchy[:groups][group.parent_id]
+            hierarchy[:groups][group.parent_id][:children] << group.id
+          end
+        end
+
+        # Map services to groups
+        diagram.services.each do |service|
+          group_id = service.group_id || :root
+          hierarchy[:services_by_group][group_id] ||= []
+          hierarchy[:services_by_group][group_id] << service
+        end
+
+        hierarchy
+      end
+
+      def position_services(diagram, hierarchy)
+        positions = {}
+        current_x = DEFAULT_SPACING
+        current_y = DEFAULT_SPACING
+
+        # Group services by their group
+        groups_to_layout = [:root] + diagram.groups.map(&:id)
+
+        groups_to_layout.each do |group_id|
+          services = hierarchy[:services_by_group][group_id] || []
+          next if services.empty?
+
+          # Position services in this group
+          services.each_with_index do |service, index|
+            dims = calculate_service_dimensions(service)
+
+            positions[service.id] = {
+              service: service,
+              x: current_x,
+              y: current_y,
+              width: dims[:width],
+              height: dims[:height],
+              group_id: group_id,
+            }
+
+            current_x += dims[:width] + DEFAULT_SPACING
+          end
+
+          # Move to next row
+          current_x = DEFAULT_SPACING
+          current_y += DEFAULT_SERVICE_HEIGHT + DEFAULT_SPACING * 2
+        end
+
+        # Apply edge-based adjustments if needed
+        adjust_positions_for_edges(diagram, positions)
+
+        positions
+      end
+
+      def adjust_positions_for_edges(diagram, positions)
+        # This is a simple adjustment - could be enhanced with force-directed layout
+        diagram.edges.each do |edge|
+          from = positions[edge.from_id]
+          to = positions[edge.to_id]
+          next unless from && to
+
+          # If positions suggest directional hints, try to respect them
+          if edge.from_position == "R" && edge.to_position == "L"
+            # From should be to the left of to
+            if from[:x] > to[:x]
+              temp_x = from[:x]
+              from[:x] = to[:x]
+              to[:x] = temp_x
+            end
+          elsif edge.from_position == "L" && edge.to_position == "R"
+            # From should be to the right of to
+            if from[:x] < to[:x]
+              temp_x = from[:x]
+              from[:x] = to[:x]
+              to[:x] = temp_x
+            end
+          elsif edge.from_position == "T" && edge.to_position == "B"
+            # From should be above to
+            if from[:y] > to[:y]
+              temp_y = from[:y]
+              from[:y] = to[:y]
+              to[:y] = temp_y
+            end
+          elsif edge.from_position == "B" && edge.to_position == "T"
+            # From should be below to
+            if from[:y] < to[:y]
+              temp_y = from[:y]
+              from[:y] = to[:y]
+              to[:y] = temp_y
+            end
+          end
+        end
+      end
+
+      def calculate_service_dimensions(service)
+        label = service.label || service.id
+        label_dims = measure_text(label, font_size: 14)
+
+        width = [label_dims[:width] + 40, DEFAULT_SERVICE_WIDTH].max
+        height = DEFAULT_SERVICE_HEIGHT
+
+        {
+          width: width,
+          height: height,
+        }
+      end
+
+      def calculate_group_bounds(diagram, service_positions)
+        bounds = {}
+
+        diagram.groups.each do |group|
+          # Find all services in this group
+          group_services = service_positions.values.select do |pos|
+            pos[:group_id] == group.id
+          end
+
+          # Find all child groups
+          child_groups = diagram.groups.select { |g| g.parent_id == group.id }
+
+          if group_services.empty? && child_groups.empty?
+            next
+          end
+
+          # Calculate bounding box
+          if group_services.any?
+            min_x = group_services.map { |s| s[:x] }.min
+            min_y = group_services.map { |s| s[:y] }.min
+            max_x = group_services.map { |s| s[:x] + s[:width] }.max
+            max_y = group_services.map { |s| s[:y] + s[:height] }.max
+          else
+            # Use child group bounds
+            min_x = Float::INFINITY
+            min_y = Float::INFINITY
+            max_x = -Float::INFINITY
+            max_y = -Float::INFINITY
+
+            child_groups.each do |child|
+              child_bounds = bounds[child.id]
+              next unless child_bounds
+
+              min_x = [min_x, child_bounds[:x]].min
+              min_y = [min_y, child_bounds[:y]].min
+              max_x = [max_x, child_bounds[:x] + child_bounds[:width]].max
+              max_y = [max_y, child_bounds[:y] + child_bounds[:height]].max
+            end
+          end
+
+          bounds[group.id] = {
+            group: group,
+            x: min_x - DEFAULT_GROUP_PADDING,
+            y: min_y - DEFAULT_GROUP_PADDING,
+            width: max_x - min_x + DEFAULT_GROUP_PADDING * 2,
+            height: max_y - min_y + DEFAULT_GROUP_PADDING * 2,
+          }
+        end
+
+        bounds
+      end
+
+      def position_edges(diagram, service_positions)
+        diagram.edges.map do |edge|
+          from = service_positions[edge.from_id]
+          to = service_positions[edge.to_id]
+
+          next unless from && to
+
+          # Calculate connection points based on position hints
+          from_point = calculate_connection_point(from, edge.from_position || "R")
+          to_point = calculate_connection_point(to, edge.to_position || "L")
+
+          {
+            edge: edge,
+            from_x: from_point[:x],
+            from_y: from_point[:y],
+            to_x: to_point[:x],
+            to_y: to_point[:y],
+          }
+        end.compact
+      end
+
+      def calculate_connection_point(service_pos, position)
+        case position
+        when "L"
+          { x: service_pos[:x], y: service_pos[:y] + service_pos[:height] / 2 }
+        when "R"
+          { x: service_pos[:x] + service_pos[:width], y: service_pos[:y] + service_pos[:height] / 2 }
+        when "T"
+          { x: service_pos[:x] + service_pos[:width] / 2, y: service_pos[:y] }
+        when "B"
+          { x: service_pos[:x] + service_pos[:width] / 2, y: service_pos[:y] + service_pos[:height] }
+        else
+          # Default to right
+          { x: service_pos[:x] + service_pos[:width], y: service_pos[:y] + service_pos[:height] / 2 }
+        end
+      end
+
+      def calculate_total_width(service_positions, group_bounds)
+        max_service_x = service_positions.values.map { |s| s[:x] + s[:width] }.max || 0
+        max_group_x = group_bounds.values.map { |g| g[:x] + g[:width] }.max || 0
+
+        [max_service_x, max_group_x].max + DEFAULT_SPACING
+      end
+
+      def calculate_total_height(service_positions, group_bounds)
+        max_service_y = service_positions.values.map { |s| s[:y] + s[:height] }.max || 0
+        max_group_y = group_bounds.values.map { |g| g[:y] + g[:height] }.max || 0
+
+        [max_service_y, max_group_y].max + DEFAULT_SPACING
+      end
+    end
+  end
+end