sirena 0.1.0

data/lib/sirena/diagram/pie.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require 'lutaml/model'
+require_relative 'base'
+
+module Sirena
+  module Diagram
+    # Represents a slice in a pie chart.
+    #
+    # A slice represents a data point with a label and numeric value.
+    class PieSlice < Lutaml::Model::Serializable
+      # Label/name for this slice
+      attribute :label, :string
+
+      # Numeric value for this slice (can be integer or decimal)
+      attribute :value, :float
+
+      # Validates the slice has required attributes.
+      #
+      # @return [Boolean] true if slice is valid
+      def valid?
+        !label.nil? && !label.empty? && !value.nil?
+      end
+
+      # Calculate percentage of total.
+      #
+      # @param total [Float] the total value of all slices
+      # @return [Float] percentage (0-100)
+      def percentage(total)
+        return 0.0 if total.zero?
+
+        (value.to_f / total) * 100.0
+      end
+    end
+
+    # Pie chart diagram model.
+    #
+    # Represents a complete pie chart with labeled slices showing
+    # proportional data distribution. Pie charts are useful for showing
+    # part-to-whole relationships.
+    #
+    # @example Creating a simple pie chart
+    #   pie = Pie.new
+    #   pie.title = 'Sales Report'
+    #   pie.slices << PieSlice.new(label: 'Apples', value: 42.5)
+    #   pie.slices << PieSlice.new(label: 'Oranges', value: 30.2)
+    #   pie.slices << PieSlice.new(label: 'Bananas', value: 27.3)
+    class Pie < Base
+      # Collection of data slices in the pie chart
+      attribute :slices, PieSlice, collection: true, default: -> { [] }
+
+      # Whether to show data values on the chart
+      attribute :show_data, :boolean, default: -> { false }
+
+      # Accessibility title (for screen readers)
+      attribute :acc_title, :string
+
+      # Accessibility description (for screen readers)
+      attribute :acc_description, :string
+
+      # Returns the diagram type identifier.
+      #
+      # @return [Symbol] :pie
+      def diagram_type
+        :pie
+      end
+
+      # Validates the pie chart structure.
+      #
+      # A pie chart is valid if:
+      # - All slices (if any) are valid
+      # - All slice values are numeric
+      #
+      # Note: Empty pie charts are allowed for parsing tests
+      #
+      # @return [Boolean] true if pie chart is valid
+      def valid?
+        return true if slices.nil? || slices.empty?
+
+        slices.all?(&:valid?)
+      end
+
+      # Calculate total value of all slices.
+      #
+      # @return [Float] sum of all slice values
+      def total_value
+        slices.sum(&:value)
+      end
+
+      # Get slices with their calculated percentages.
+      #
+      # @return [Array<Hash>] array of hashes with :slice and :percentage
+      def slices_with_percentages
+        total = total_value
+        slices.map do |slice|
+          {
+            slice: slice,
+            percentage: slice.percentage(total)
+          }
+        end
+      end
+
+      # Calculate angle in degrees for a slice.
+      #
+      # @param slice [PieSlice] the slice to calculate angle for
+      # @return [Float] angle in degrees (0-360)
+      def slice_angle(slice)
+        total = total_value
+        return 0.0 if total.zero?
+
+        (slice.value / total) * 360.0
+      end
+    end
+  end
+end

data/lib/sirena/diagram/quadrant.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require 'lutaml/model'
+require_relative 'base'
+
+module Sirena
+  module Diagram
+    # Represents a data point in a quadrant chart.
+    #
+    # A point has a label, normalized x/y coordinates (0-1 range),
+    # and optional styling parameters.
+    class QuadrantPoint < Lutaml::Model::Serializable
+      # Label/name for this point
+      attribute :label, :string
+
+      # X coordinate (normalized 0-1)
+      attribute :x, :float
+
+      # Y coordinate (normalized 0-1)
+      attribute :y, :float
+
+      # Optional radius for the point
+      attribute :radius, :float
+
+      # Optional fill color
+      attribute :color, :string
+
+      # Optional stroke color
+      attribute :stroke_color, :string
+
+      # Optional stroke width
+      attribute :stroke_width, :float
+
+      # Validates the point has required attributes.
+      #
+      # @return [Boolean] true if point is valid
+      def valid?
+        !label.nil? && !label.empty? &&
+          !x.nil? && !y.nil? &&
+          x >= 0.0 && x <= 1.0 &&
+          y >= 0.0 && y <= 1.0
+      end
+
+      # Determine which quadrant this point is in (1-4).
+      #
+      # Quadrants are numbered:
+      # - Quadrant 1: top-right (x >= 0.5, y >= 0.5)
+      # - Quadrant 2: top-left (x < 0.5, y >= 0.5)
+      # - Quadrant 3: bottom-left (x < 0.5, y < 0.5)
+      # - Quadrant 4: bottom-right (x >= 0.5, y < 0.5)
+      #
+      # @return [Integer] quadrant number (1-4)
+      def quadrant
+        if x >= 0.5 && y >= 0.5
+          1
+        elsif x < 0.5 && y >= 0.5
+          2
+        elsif x < 0.5 && y < 0.5
+          3
+        else
+          4
+        end
+      end
+    end
+
+    # Quadrant chart diagram model.
+    #
+    # Represents a 2x2 quadrant chart for visualizing data points
+    # in a two-dimensional space. Useful for categorizing items
+    # based on two independent variables.
+    #
+    # @example Creating a simple quadrant chart
+    #   chart = QuadrantChart.new
+    #   chart.title = 'Product Analysis'
+    #   chart.x_axis_left = 'Low Cost'
+    #   chart.x_axis_right = 'High Cost'
+    #   chart.y_axis_bottom = 'Low Value'
+    #   chart.y_axis_top = 'High Value'
+    #   chart.quadrant_1_label = 'Invest'
+    #   chart.points << QuadrantPoint.new(label: 'Product A', x: 0.3, y: 0.7)
+    class QuadrantChart < Base
+      # X-axis label for the left side
+      attribute :x_axis_left, :string
+
+      # X-axis label for the right side
+      attribute :x_axis_right, :string
+
+      # Y-axis label for the bottom
+      attribute :y_axis_bottom, :string
+
+      # Y-axis label for the top
+      attribute :y_axis_top, :string
+
+      # Label for quadrant 1 (top-right)
+      attribute :quadrant_1_label, :string
+
+      # Label for quadrant 2 (top-left)
+      attribute :quadrant_2_label, :string
+
+      # Label for quadrant 3 (bottom-left)
+      attribute :quadrant_3_label, :string
+
+      # Label for quadrant 4 (bottom-right)
+      attribute :quadrant_4_label, :string
+
+      # Collection of data points in the chart
+      attribute :points, QuadrantPoint, collection: true, default: -> { [] }
+
+      # Returns the diagram type identifier.
+      #
+      # @return [Symbol] :quadrant
+      def diagram_type
+        :quadrant
+      end
+
+      # Validates the quadrant chart structure.
+      #
+      # A quadrant chart is valid if:
+      # - All points (if any) are valid
+      #
+      # Note: Axis labels are optional for minimal diagrams
+      #
+      # @return [Boolean] true if chart is valid
+      def valid?
+        return false unless points.all?(&:valid?)
+
+        true
+      end
+
+      # Get points grouped by quadrant.
+      #
+      # @return [Hash<Integer, Array<QuadrantPoint>>] points by quadrant
+      def points_by_quadrant
+        points.group_by(&:quadrant)
+      end
+    end
+  end
+end

data/lib/sirena/diagram/radar.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Sirena
+  module Diagram
+    # Represents a radar/spider chart diagram
+    class RadarChart < Base
+      attr_accessor :title, :acc_title, :acc_descr, :axes, :curves, :options
+
+      def initialize
+        super
+        @axes = []
+        @curves = []
+        @options = {}
+      end
+
+      def type
+        :radar
+      end
+    end
+
+    # Represents an axis in a radar chart
+    class RadarAxis
+      attr_accessor :id, :label
+
+      def initialize(id, label = nil)
+        @id = id
+        @label = label || id
+      end
+    end
+
+    # Represents a data curve/dataset in a radar chart
+    class RadarCurve
+      attr_accessor :id, :label, :values
+
+      def initialize(id, label = nil)
+        @id = id
+        @label = label || id
+        @values = {}
+      end
+
+      # Add a value for an axis
+      def add_value(axis_id, value)
+        @values[axis_id] = value.to_f
+      end
+
+      # Get value for an axis
+      def value_for(axis_id)
+        @values[axis_id] || 0.0
+      end
+    end
+  end
+end

data/lib/sirena/diagram/requirement.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Sirena
+  module Diagram
+    # Represents a requirement in the diagram
+    class Requirement < Lutaml::Model::Serializable
+      attribute :name, :string
+      attribute :type, :string, default: -> { "requirement" }
+      attribute :id, :string
+      attribute :text, :string
+      attribute :risk, :string # Low, Medium, High
+      attribute :verifymethod, :string # Analysis, Inspection, Test, Demonstration
+      attribute :classes, :string, collection: true, default: -> { [] }
+
+      def add_class(class_name)
+        classes << class_name
+      end
+    end
+
+    # Represents an element in the diagram
+    class RequirementElement < Lutaml::Model::Serializable
+      attribute :name, :string
+      attribute :type, :string
+      attribute :docref, :string
+      attribute :classes, :string, collection: true, default: -> { [] }
+
+      def add_class(class_name)
+        classes << class_name
+      end
+    end
+
+    # Represents a relationship between requirements/elements
+    class RequirementRelationship < Lutaml::Model::Serializable
+      attribute :source, :string
+      attribute :target, :string
+      attribute :type, :string # contains, copies, derives, satisfies, verifies, refines, traces
+
+      VALID_TYPES = %w[
+        contains
+        copies
+        derives
+        satisfies
+        verifies
+        refines
+        traces
+      ].freeze
+
+      def valid?
+        VALID_TYPES.include?(type)
+      end
+    end
+
+    # Represents styling for a requirement or element
+    class RequirementStyle < Lutaml::Model::Serializable
+      attribute :target_ids, :string, collection: true, default: -> { [] }
+      attribute :fill, :string
+      attribute :stroke, :string
+      attribute :stroke_width, :string
+      attribute :properties, :string, collection: true, default: -> { [] }
+
+      def add_target(id)
+        target_ids << id
+      end
+
+      def add_property(property)
+        properties << property
+      end
+    end
+
+    # Represents a CSS class definition
+    class RequirementClass < Lutaml::Model::Serializable
+      attribute :name, :string
+      attribute :fill, :string
+      attribute :stroke, :string
+      attribute :stroke_width, :string
+      attribute :properties, :string, collection: true, default: -> { [] }
+
+      def add_property(property)
+        properties << property
+      end
+    end
+
+    # Represents a class assignment to requirements/elements
+    class RequirementClassAssignment < Lutaml::Model::Serializable
+      attribute :target_ids, :string, collection: true, default: -> { [] }
+      attribute :class_names, :string, collection: true, default: -> { [] }
+
+      def add_target(id)
+        target_ids << id
+      end
+
+      def add_class(class_name)
+        class_names << class_name
+      end
+    end
+
+    # Represents a Mermaid requirement diagram
+    class RequirementDiagram < Lutaml::Model::Serializable
+      attribute :requirements, Requirement, collection: true, default: -> { [] }
+      attribute :elements, RequirementElement, collection: true, default: -> { [] }
+      attribute :relationships, RequirementRelationship, collection: true, default: -> { [] }
+      attribute :styles, RequirementStyle, collection: true, default: -> { [] }
+      attribute :classes, RequirementClass, collection: true, default: -> { [] }
+      attribute :class_assignments, RequirementClassAssignment, collection: true, default: -> { [] }
+
+      def add_requirement(requirement)
+        requirements << requirement
+      end
+
+      def add_element(element)
+        elements << element
+      end
+
+      def add_relationship(relationship)
+        relationships << relationship
+      end
+
+      def add_style(style)
+        styles << style
+      end
+
+      def add_class(klass)
+        classes << klass
+      end
+
+      def add_class_assignment(assignment)
+        class_assignments << assignment
+      end
+    end
+  end
+end

data/lib/sirena/diagram/sankey.rb

@@ -0,0 +1,217 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+require_relative "base"
+
+module Sirena
+  module Diagram
+    # Represents a node in a Sankey diagram.
+    #
+    # A node can be a source, target, or intermediate point in the flow.
+    # Nodes are automatically discovered from flow definitions.
+    class SankeyNode < Lutaml::Model::Serializable
+      # Unique identifier for the node
+      attribute :id, :string
+
+      # Display label for the node (defaults to id if not set)
+      attribute :label, :string
+
+      def initialize(id = nil, label = nil)
+        super()
+        @id = id
+        @label = label || id
+      end
+
+      # Validates the node has required attributes.
+      #
+      # @return [Boolean] true if node is valid
+      def valid?
+        !id.nil? && !id.empty?
+      end
+
+      # Get display label, falling back to id.
+      #
+      # @return [String] the label to display
+      def display_label
+        label && !label.empty? ? label : id
+      end
+    end
+
+    # Represents a flow/link between two nodes in a Sankey diagram.
+    #
+    # A flow connects a source node to a target node with a value
+    # that determines the width of the flow arrow.
+    class SankeyFlow < Lutaml::Model::Serializable
+      # Source node identifier
+      attribute :source, :string
+
+      # Target node identifier
+      attribute :target, :string
+
+      # Flow value (determines arrow width)
+      attribute :value, :float
+
+      # Optional label for the flow
+      attribute :label, :string
+
+      def initialize(source = nil, target = nil, value = 0.0)
+        super()
+        @source = source
+        @target = target
+        @value = value.to_f
+      end
+
+      # Validates the flow has required attributes.
+      #
+      # @return [Boolean] true if flow is valid
+      def valid?
+        !source.nil? && !source.empty? &&
+          !target.nil? && !target.empty? &&
+          value > 0
+      end
+
+      # Check if this is a self-loop.
+      #
+      # @return [Boolean] true if source equals target
+      def self_loop?
+        source == target
+      end
+    end
+
+    # Sankey diagram model.
+    #
+    # Represents a Sankey diagram showing flows between nodes where
+    # the width of arrows is proportional to flow values. Used for
+    # visualizing energy flows, material flows, cost distributions, etc.
+    #
+    # @example Creating a Sankey diagram
+    #   sankey = SankeyDiagram.new
+    #   sankey.title = 'Energy Flow'
+    #
+    #   flow1 = SankeyFlow.new('Source', 'Process', 100)
+    #   flow2 = SankeyFlow.new('Process', 'Output', 70)
+    #   flow3 = SankeyFlow.new('Process', 'Waste', 30)
+    #   sankey.flows << flow1 << flow2 << flow3
+    class SankeyDiagram < Base
+      # Collection of explicitly defined nodes (optional)
+      attribute :nodes, SankeyNode, collection: true,
+                default: -> { [] }
+
+      # Collection of flows between nodes
+      attribute :flows, SankeyFlow, collection: true,
+                default: -> { [] }
+
+      # Accessibility title (for screen readers)
+      attribute :acc_title, :string
+
+      # Accessibility description (for screen readers)
+      attribute :acc_description, :string
+
+      def initialize
+        @nodes = []
+        @flows = []
+        super
+      end
+
+      # Returns the diagram type identifier.
+      #
+      # @return [Symbol] :sankey
+      def diagram_type
+        :sankey
+      end
+
+      # Validates the diagram structure.
+      #
+      # A Sankey diagram is valid if it has at least one flow.
+      #
+      # @return [Boolean] true if diagram is valid
+      def valid?
+        !flows.empty? && flows.all?(&:valid?)
+      end
+
+      # Get all unique node IDs from flows and explicit nodes.
+      #
+      # @return [Array<String>] array of unique node IDs
+      def all_node_ids
+        node_ids_from_flows = flows.flat_map { |f| [f.source, f.target] }
+        explicit_node_ids = nodes.map(&:id)
+        (node_ids_from_flows + explicit_node_ids).uniq
+      end
+
+      # Get or create node by ID.
+      #
+      # @param id [String] node identifier
+      # @return [SankeyNode] the node
+      def node_by_id(id)
+        nodes.find { |n| n.id == id } || SankeyNode.new(id)
+      end
+
+      # Get all flows from a specific node.
+      #
+      # @param node_id [String] the source node ID
+      # @return [Array<SankeyFlow>] flows from this node
+      def flows_from(node_id)
+        flows.select { |f| f.source == node_id }
+      end
+
+      # Get all flows to a specific node.
+      #
+      # @param node_id [String] the target node ID
+      # @return [Array<SankeyFlow>] flows to this node
+      def flows_to(node_id)
+        flows.select { |f| f.target == node_id }
+      end
+
+      # Calculate total outflow from a node.
+      #
+      # @param node_id [String] the node ID
+      # @return [Float] sum of all outgoing flow values
+      def total_outflow(node_id)
+        flows_from(node_id).sum(&:value)
+      end
+
+      # Calculate total inflow to a node.
+      #
+      # @param node_id [String] the node ID
+      # @return [Float] sum of all incoming flow values
+      def total_inflow(node_id)
+        flows_to(node_id).sum(&:value)
+      end
+
+      # Get source nodes (nodes with no inflow).
+      #
+      # @return [Array<String>] source node IDs
+      def source_nodes
+        all_node_ids.select { |id| total_inflow(id).zero? }
+      end
+
+      # Get sink nodes (nodes with no outflow).
+      #
+      # @return [Array<String>] sink node IDs
+      def sink_nodes
+        all_node_ids.select { |id| total_outflow(id).zero? }
+      end
+
+      # Get total flow value in the diagram.
+      #
+      # @return [Float] sum of all flow values
+      def total_flow
+        flows.sum(&:value)
+      end
+
+      # Get maximum flow value.
+      #
+      # @return [Float] maximum single flow value
+      def max_flow
+        flows.map(&:value).max || 0.0
+      end
+
+      # Get minimum flow value.
+      #
+      # @return [Float] minimum single flow value
+      def min_flow
+        flows.map(&:value).min || 0.0
+      end
+    end
+  end
+end