sirena 0.1.0

data/lib/sirena/parser/transforms/radar.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require "parslet"
+
+module Sirena
+  module Parser
+    module Transforms
+      # Transform for Radar diagrams
+      class Radar < Parslet::Transform
+        # Transform axis definition
+        rule(id: simple(:id), label: simple(:label)) do
+          { id: id.to_s, label: label.to_s }
+        end
+
+        rule(id: simple(:id)) do
+          { id: id.to_s, label: id.to_s }
+        end
+
+        # Transform positional values (simple list)
+        rule(value: simple(:v)) do
+          v.to_s.to_f
+        end
+
+        # Transform named values (axis: value pairs)
+        rule(axis: simple(:axis), value: simple(:v)) do
+          { axis: axis.to_s, value: v.to_s.to_f }
+        end
+
+        # Transform curve definition
+        rule(id: simple(:id), label: simple(:label), values: subtree(:vals)) do
+          {
+            type: :curve,
+            id: id.to_s,
+            label: label.to_s,
+            values: vals
+          }
+        end
+
+        rule(id: simple(:id), values: subtree(:vals)) do
+          {
+            type: :curve,
+            id: id.to_s,
+            label: id.to_s,
+            values: vals
+          }
+        end
+
+        # Transform title
+        rule(title: simple(:title)) do
+          { type: :title, title: title.to_s }
+        end
+
+        # Transform accessibility
+        rule(acc_title: simple(:acc_title)) do
+          { type: :acc_title, acc_title: acc_title.to_s }
+        end
+
+        rule(acc_descr: simple(:acc_descr)) do
+          { type: :acc_descr, acc_descr: acc_descr.to_s }
+        end
+
+        # Transform axes definition
+        rule(axes: subtree(:axes)) do
+          {
+            type: :axes,
+            axes: Array(axes)
+          }
+        end
+
+        # Transform options
+        rule(ticks: simple(:ticks)) do
+          { type: :option, key: :ticks, value: ticks.to_s.to_i }
+        end
+
+        rule(show_legend: simple(:show_legend)) do
+          { type: :option, key: :show_legend, value: show_legend.to_s == "true" }
+        end
+
+        rule(graticule: simple(:graticule)) do
+          { type: :option, key: :graticule, value: graticule.to_s }
+        end
+
+        rule(min: simple(:min)) do
+          { type: :option, key: :min, value: min.to_s.to_f }
+        end
+
+        rule(max: simple(:max)) do
+          { type: :option, key: :max, value: max.to_s.to_f }
+        end
+
+        # Transform the entire diagram
+        rule(statements: subtree(:statements)) do
+          result = {
+            title: nil,
+            acc_title: nil,
+            acc_descr: nil,
+            axes: [],
+            curves: [],
+            options: {}
+          }
+
+          Array(statements).each do |stmt|
+            next unless stmt.is_a?(Hash)
+
+            case stmt[:type]
+            when :title
+              result[:title] = stmt[:title]
+            when :acc_title
+              result[:acc_title] = stmt[:acc_title]
+            when :acc_descr
+              result[:acc_descr] = stmt[:acc_descr]
+            when :axes
+              result[:axes] = stmt[:axes]
+            when :curve
+              result[:curves] << stmt
+            when :option
+              result[:options][stmt[:key]] = stmt[:value]
+            end
+          end
+
+          result
+        end
+      end
+    end
+  end
+end

data/lib/sirena/parser/transforms/requirement.rb

@@ -0,0 +1,272 @@
+# frozen_string_literal: true
+
+require 'parslet'
+require_relative '../../diagram/requirement'
+
+module Sirena
+  module Parser
+    module Transforms
+      # Transform for converting requirement diagram parse trees to diagram models.
+      #
+      # Handles transformation of requirements, elements, relationships,
+      # styling directives, and class definitions from Parslet parse trees
+      # into RequirementDiagram objects.
+      class Requirement < Parslet::Transform
+        # Requirement type mapping (for shorthand to full type)
+        REQUIREMENT_TYPE_MAP = {
+          'functionalRequirement' => 'functionalRequirement',
+          'interfaceRequirement' => 'interfaceRequirement',
+          'performanceRequirement' => 'performanceRequirement',
+          'physicalRequirement' => 'physicalRequirement',
+          'designConstraint' => 'designConstraint',
+          'requirement' => 'requirement'
+        }.freeze
+
+        # Process parsed diagram
+        def self.apply(tree, diagram = nil)
+          diagram ||= Diagram::RequirementDiagram.new
+
+          # The tree is an array of statement hashes
+          statements = tree.is_a?(Array) ? tree : [tree]
+
+          # Filter out header
+          statements = statements.reject { |s| s.is_a?(Hash) && s[:header] }
+
+          process_statements(diagram, statements)
+
+          diagram
+        end
+
+        def self.process_statements(diagram, statements)
+          statements.each do |stmt|
+            next unless stmt.is_a?(Hash)
+
+            if stmt[:req_type]
+              # Requirement statement
+              requirement = create_requirement(stmt)
+              diagram.add_requirement(requirement)
+            elsif stmt[:elem_keyword]
+              # Element statement
+              element = create_element(stmt)
+              diagram.add_element(element)
+            elsif stmt[:rel_source] && stmt[:rel_target]
+              # Relationship statement
+              relationship = create_relationship(stmt)
+              diagram.add_relationship(relationship)
+            elsif stmt[:style_keyword]
+              # Style statement
+              style = create_style(stmt)
+              diagram.add_style(style)
+            elsif stmt[:classdef_keyword]
+              # Class definition
+              klass = create_class_definition(stmt)
+              diagram.add_class(klass)
+            elsif stmt[:class_keyword]
+              # Class assignment
+              assignment = create_class_assignment(stmt)
+              diagram.add_class_assignment(assignment)
+            end
+          end
+        end
+
+        def self.create_requirement(stmt)
+          Diagram::Requirement.new.tap do |req|
+            req.name = stmt[:req_name].to_s
+            req.type = stmt[:req_type].to_s
+
+            # Process properties
+            if stmt[:req_properties]
+              props = stmt[:req_properties]
+              props = [props] unless props.is_a?(Array)
+
+              props.each do |prop|
+                next unless prop.is_a?(Hash)
+
+                key = prop[:key][:prop_key].to_s if prop[:key]
+                value = prop[:value].to_s.strip if prop[:value]
+
+                case key
+                when 'id'
+                  req.id = value
+                when 'text'
+                  req.text = value
+                when 'risk'
+                  req.risk = value
+                when 'verifymethod'
+                  req.verifymethod = value
+                end
+              end
+            end
+
+            # Process class shorthand
+            if stmt[:req_classes]
+              classes = extract_class_names(stmt[:req_classes])
+              classes.each { |c| req.add_class(c) }
+            end
+          end
+        end
+
+        def self.create_element(stmt)
+          Diagram::RequirementElement.new.tap do |elem|
+            elem.name = stmt[:elem_name].to_s
+
+            # Process properties
+            if stmt[:elem_properties]
+              props = stmt[:elem_properties]
+              props = [props] unless props.is_a?(Array)
+
+              props.each do |prop|
+                next unless prop.is_a?(Hash)
+
+                key = prop[:key][:prop_key].to_s if prop[:key]
+                value = prop[:value].to_s.strip if prop[:value]
+
+                case key
+                when 'type'
+                  elem.type = value
+                when 'docref'
+                  elem.docref = value
+                end
+              end
+            end
+
+            # Process class shorthand
+            if stmt[:elem_classes]
+              classes = extract_class_names(stmt[:elem_classes])
+              classes.each { |c| elem.add_class(c) }
+            end
+          end
+        end
+
+        def self.create_relationship(stmt)
+          Diagram::RequirementRelationship.new.tap do |rel|
+            rel.source = stmt[:rel_source].to_s
+            rel.target = stmt[:rel_target].to_s
+
+            if stmt[:rel_type] && stmt[:rel_type][:type]
+              rel.type = stmt[:rel_type][:type].to_s
+            end
+          end
+        end
+
+        def self.create_style(stmt)
+          Diagram::RequirementStyle.new.tap do |style|
+            # Process targets
+            if stmt[:style_targets]
+              targets = stmt[:style_targets]
+              targets = [targets] unless targets.is_a?(Array)
+
+              targets.each do |target|
+                style.add_target(target.to_s)
+              end
+            end
+
+            # Process properties
+            if stmt[:style_props]
+              props = stmt[:style_props]
+              props = [props] unless props.is_a?(Array)
+
+              props.each do |prop|
+                prop_str = prop.to_s.strip
+                # Split by comma if it contains multiple properties
+                prop_parts = prop_str.split(',')
+
+                prop_parts.each do |part|
+                  part = part.strip
+                  if part.start_with?('fill:')
+                    style.fill = part.sub('fill:', '').strip
+                  elsif part.start_with?('stroke:')
+                    style.stroke = part.sub('stroke:', '').strip
+                  elsif part.start_with?('stroke-width:')
+                    style.stroke_width = part.sub('stroke-width:', '').strip
+                  else
+                    style.add_property(part) unless part.empty?
+                  end
+                end
+              end
+            end
+          end
+        end
+
+        def self.create_class_definition(stmt)
+          Diagram::RequirementClass.new.tap do |klass|
+            klass.name = stmt[:class_name].to_s
+
+            # Process properties
+            if stmt[:class_props]
+              props = stmt[:class_props]
+              props = [props] unless props.is_a?(Array)
+
+              props.each do |prop|
+                prop_str = prop.to_s.strip
+                # Split by comma if it contains multiple properties
+                prop_parts = prop_str.split(',')
+
+                prop_parts.each do |part|
+                  part = part.strip
+                  if part.start_with?('fill:')
+                    klass.fill = part.sub('fill:', '').strip
+                  elsif part.start_with?('stroke:')
+                    klass.stroke = part.sub('stroke:', '').strip
+                  elsif part.start_with?('stroke-width:')
+                    klass.stroke_width = part.sub('stroke-width:', '').strip
+                  else
+                    klass.add_property(part) unless part.empty?
+                  end
+                end
+              end
+            end
+          end
+        end
+
+        def self.create_class_assignment(stmt)
+          Diagram::RequirementClassAssignment.new.tap do |assignment|
+            # Process targets
+            if stmt[:class_targets]
+              targets = stmt[:class_targets]
+              targets = [targets] unless targets.is_a?(Array)
+
+              targets.each do |target|
+                assignment.add_target(target.to_s)
+              end
+            end
+
+            # Process class names
+            if stmt[:class_names]
+              names = stmt[:class_names]
+              names = [names] unless names.is_a?(Array)
+
+              names.each do |name|
+                assignment.add_class(name.to_s)
+              end
+            end
+          end
+        end
+
+        def self.extract_class_names(class_data)
+          # Extract class names from shorthand syntax
+          classes = []
+
+          if class_data.is_a?(String)
+            classes = class_data.split(',').map(&:strip)
+          elsif class_data.is_a?(Array)
+            class_data.each do |item|
+              if item.is_a?(String)
+                classes << item.strip
+              elsif item.is_a?(Hash) && item[:string]
+                classes << item[:string].to_s.strip
+              else
+                classes << item.to_s.strip
+              end
+            end
+          elsif class_data.is_a?(Hash)
+            # Could be a single identifier or complex structure
+            classes << class_data.to_s.strip
+          end
+
+          classes
+        end
+      end
+    end
+  end
+end

data/lib/sirena/parser/transforms/sankey.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require_relative "../../diagram/sankey"
+
+module Sirena
+  module Parser
+    module Transforms
+      # Transform for converting Parslet parse tree to Sankey diagram model.
+      #
+      # Converts the parse tree output from Grammars::Sankey into a
+      # fully-formed Diagram::SankeyDiagram object with nodes and flows.
+      class Sankey
+        # Transform parse tree into Sankey diagram.
+        #
+        # @param tree [Array, Hash] Parslet parse tree
+        # @return [Diagram::SankeyDiagram] the sankey diagram model
+        def apply(tree)
+          diagram = Diagram::SankeyDiagram.new
+
+          # Tree structure: array with header and statements
+          if tree.is_a?(Array)
+            tree.each do |item|
+              next unless item.is_a?(Hash)
+
+              process_item(diagram, item)
+            end
+          elsif tree.is_a?(Hash)
+            process_item(diagram, tree)
+
+            if tree[:statements]
+              process_statements(diagram, tree[:statements])
+            end
+          end
+
+          # Auto-discover nodes from flows if not explicitly declared
+          ensure_nodes_from_flows(diagram)
+
+          diagram
+        end
+
+        private
+
+        def process_item(diagram, item)
+          return unless item.is_a?(Hash)
+
+          process_header(diagram, item) if item.key?(:header)
+          process_node_declaration(diagram, item) if item.key?(:node_declaration)
+          process_flow_entry(diagram, item) if item.key?(:flow_entry)
+        end
+
+        def process_statements(diagram, statements)
+          Array(statements).each do |stmt|
+            process_item(diagram, stmt) if stmt.is_a?(Hash)
+          end
+        end
+
+        def process_header(diagram, item)
+          # Header is just the 'sankey-beta' keyword, nothing to extract
+        end
+
+        def process_node_declaration(diagram, item)
+          node_data = item[:node_declaration]
+          return unless node_data
+
+          node_id = extract_text(node_data[:node_id])
+          node_label = extract_text(node_data[:node_label])
+
+          # Check if node already exists
+          existing_node = diagram.nodes.find { |n| n.id == node_id }
+          if existing_node
+            # Update label if provided
+            existing_node.label = node_label unless node_label.empty?
+          else
+            # Create new node
+            node = Diagram::SankeyNode.new(node_id, node_label)
+            diagram.nodes << node
+          end
+        end
+
+        def process_flow_entry(diagram, item)
+          flow_data = item[:flow_entry]
+          return unless flow_data
+
+          source = extract_text(flow_data[:source])
+          target = extract_text(flow_data[:target])
+          value_str = extract_text(flow_data[:value])
+          value = value_str.to_f
+
+          flow = Diagram::SankeyFlow.new(source, target, value)
+          diagram.flows << flow
+        end
+
+        # Ensure all nodes referenced in flows exist in the nodes collection
+        def ensure_nodes_from_flows(diagram)
+          node_ids_from_flows = diagram.flows.flat_map do |flow|
+            [flow.source, flow.target]
+          end.uniq
+
+          node_ids_from_flows.each do |node_id|
+            # Check if node already exists
+            unless diagram.nodes.any? { |n| n.id == node_id }
+              # Create node with id as label
+              node = Diagram::SankeyNode.new(node_id, node_id)
+              diagram.nodes << node
+            end
+          end
+        end
+
+        def extract_text(value)
+          case value
+          when Hash
+            value.values.first.to_s
+          when String
+            value
+          else
+            value.to_s
+          end.strip
+        end
+      end
+    end
+  end
+end