sirena 0.1.0

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

@@ -0,0 +1,227 @@
+# frozen_string_literal: true
+
+require "parslet"
+
+module Sirena
+  module Parser
+    module Transforms
+      # Transform for Mindmap diagrams
+      class Mindmap < Parslet::Transform
+        # Helper class to build mindmap tree from indented nodes
+        class TreeBuilder
+          attr_reader :root, :all_nodes
+
+          def initialize
+            @all_nodes = []
+            @root = nil
+            @level_stack = []
+            @pending_icon = nil
+            @pending_classes = []
+            @min_indent = nil
+          end
+
+          def add_node(node_data)
+            # Handle icon and class declarations - apply to PREVIOUS node
+            if node_data[:icon]
+              icon = node_data[:icon].to_s
+              if @all_nodes.last
+                @all_nodes.last[:icon] = icon
+              end
+              return
+            end
+
+            if node_data[:classes]
+              classes_str = node_data[:classes].to_s
+              classes = classes_str.split(/\s+/)
+              if @all_nodes.last
+                @all_nodes.last[:classes] = classes
+              end
+              return
+            end
+
+            # Track minimum indentation for relative level calculation
+            indent_size = get_indent_size(node_data[:indent])
+            @min_indent = indent_size if @min_indent.nil? || indent_size < @min_indent
+
+            # Calculate level from indentation (will be adjusted later)
+            level = calculate_level(node_data[:indent])
+
+            # Create the node
+            content = extract_content(node_data)
+            shape = extract_shape(node_data)
+
+            node = {
+              id: "node-#{@all_nodes.size}",
+              content: content,
+              level: level,
+              shape: shape,
+              icon: nil,
+              classes: [],
+              children: [],
+              _indent_size: indent_size  # Store for later adjustment
+            }
+
+            @all_nodes << node
+
+            # Build hierarchy
+            if level == 0
+              @root = node
+              @level_stack = [node]
+            else
+              # Find parent at previous level
+              parent = find_parent(level)
+              if parent
+                parent[:children] << node
+                node[:parent] = parent
+              end
+
+              # Update stack
+              @level_stack = @level_stack[0..level - 1] + [node]
+            end
+          end
+
+          def finalize
+            # Adjust all levels to be relative to minimum indentation
+            return if @min_indent.nil?
+
+            @all_nodes.each do |node|
+              indent_size = node.delete(:_indent_size)
+              node[:level] = calculate_relative_level(indent_size, @min_indent)
+            end
+
+            # Rebuild hierarchy with corrected levels
+            rebuild_hierarchy
+          end
+
+          private
+
+          def rebuild_hierarchy
+            @root = nil
+            @level_stack = []
+
+            @all_nodes.each do |node|
+              level = node[:level]
+
+              # Clear old parent/children relationships
+              node[:children] = []
+              node.delete(:parent)
+
+              if level == 0
+                @root = node
+                @level_stack = [node]
+              else
+                # Find parent at previous level
+                parent = @level_stack[level - 1]
+                if parent
+                  parent[:children] << node
+                  node[:parent] = parent
+                end
+
+                # Update stack
+                @level_stack = @level_stack[0..level - 1] + [node]
+              end
+            end
+          end
+
+          def get_indent_size(indent_data)
+            return 0 if indent_data.nil?
+            return 0 if indent_data.is_a?(Array) && indent_data.empty?
+
+            indent_str = if indent_data.is_a?(Array)
+                          indent_data.join('')
+                        else
+                          indent_data.to_s
+                        end
+
+            indent_str.length
+          end
+
+          def calculate_relative_level(indent_size, min_indent)
+            relative_indent = indent_size - min_indent
+            return 0 if relative_indent <= 0
+
+            # Try 2-space indentation first
+            level = relative_indent / 2
+            # If not evenly divisible, try 4-space
+            level = relative_indent / 4 if relative_indent % 2 != 0
+
+            level
+          end
+
+          private
+
+          def calculate_level(indent_data)
+            # Handle empty array or nil
+            return 0 if indent_data.nil?
+            return 0 if indent_data.is_a?(Array) && indent_data.empty?
+
+            # Convert to string and count length
+            indent_str = if indent_data.is_a?(Array)
+                          indent_data.join('')
+                        else
+                          indent_data.to_s
+                        end
+
+            return 0 if indent_str.empty?
+
+            # Count spaces (2 or 4 spaces per level)
+            spaces = indent_str.length
+            # Try 2-space indentation first
+            level = spaces / 2
+            # If not evenly divisible, try 4-space
+            level = spaces / 4 if spaces % 2 != 0
+
+            level
+          end
+
+          def extract_content(node_data)
+            return node_data[:content].to_s if node_data[:content]
+            ""
+          end
+
+          def extract_shape(node_data)
+            # Determine shape based on which parser rule matched
+            return "circle" if node_data[:shape_circle]
+            return "bang" if node_data[:shape_bang]
+            return "cloud" if node_data[:shape_cloud]
+            return "hexagon" if node_data[:shape_hexagon]
+            return "square" if node_data[:shape_square]
+            "default"
+          end
+
+          def find_parent(level)
+            return nil if level == 0
+            # Parent is the last node at level - 1
+            @level_stack[level - 1]
+          end
+        end
+
+        # Transform the nodes array into a tree structure
+        rule(nodes: subtree(:nodes)) do
+          builder = TreeBuilder.new
+          nodes_array = Array(nodes)
+
+          nodes_array.each do |node_data|
+            next unless node_data.is_a?(Hash)
+
+            # Skip if no actual node data (just whitespace)
+            next unless node_data[:content] || node_data[:icon] || node_data[:classes] ||
+                       node_data[:shape_circle] || node_data[:shape_bang] ||
+                       node_data[:shape_cloud] || node_data[:shape_hexagon] ||
+                       node_data[:shape_square]
+
+            builder.add_node(node_data)
+          end
+
+          # Finalize to adjust levels and rebuild hierarchy
+          builder.finalize
+
+          {
+            root: builder.root,
+            nodes: builder.all_nodes
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "parslet"
+
+module Sirena
+  module Parser
+    module Transforms
+      # Transform for Packet diagrams
+      class Packet < Parslet::Transform
+        # Transform field definition
+        rule(
+          bit_start: simple(:bit_start),
+          bit_end: simple(:bit_end),
+          label: simple(:label)
+        ) do
+          {
+            type: :field,
+            bit_start: bit_start.to_s.to_i,
+            bit_end: bit_end.to_s.to_i,
+            label: label.to_s
+          }
+        end
+
+        # Transform title
+        rule(title: simple(:title)) do
+          { type: :title, title: title.to_s }
+        end
+
+        # Transform the entire diagram
+        rule(statements: subtree(:statements)) do
+          result = {
+            title: nil,
+            fields: []
+          }
+
+          # Handle nil or empty statements
+          stmts = statements.nil? ? [] : Array(statements)
+
+          stmts.each do |stmt|
+            next unless stmt.is_a?(Hash)
+
+            case stmt[:type]
+            when :title
+              result[:title] = stmt[:title]
+            when :field
+              result[:fields] << stmt
+            end
+          end
+
+          result
+        end
+
+        # Handle empty diagram (no statements)
+        rule(statements: nil) do
+          {
+            title: nil,
+            fields: []
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+require_relative '../../diagram/pie'
+
+module Sirena
+  module Parser
+    module Transforms
+      # Transform for converting Parslet parse tree to Pie diagram model.
+      #
+      # Converts the parse tree output from Grammars::Pie into a
+      # fully-formed Diagram::Pie object with slices and metadata.
+      class Pie
+        # Transform parse tree into Pie diagram.
+        #
+        # @param tree [Array, Hash] Parslet parse tree
+        # @return [Diagram::Pie] the pie chart diagram model
+        def apply(tree)
+          diagram = Diagram::Pie.new
+
+          # Tree structure: array with header and statements
+          if tree.is_a?(Array)
+            tree.each do |item|
+              next unless item.is_a?(Hash)
+
+              process_header(diagram, item) if item.key?(:header)
+              process_title(diagram, item) if item.key?(:title)
+              process_show_data(diagram, item) if item.key?(:show_data)
+              process_statement(diagram, item) if statement?(item)
+            end
+          elsif tree.is_a?(Hash)
+            process_header(diagram, tree) if tree.key?(:header)
+            process_title(diagram, tree) if tree.key?(:title)
+            process_show_data(diagram, tree) if tree.key?(:show_data)
+
+            if tree[:statements]
+              process_statements(diagram, tree[:statements])
+            end
+          end
+
+          diagram
+        end
+
+        private
+
+        def statement?(item)
+          item.key?(:data_entry) ||
+            item.key?(:acc_title) ||
+            item.key?(:acc_descr) ||
+            item.key?(:standalone_title)
+        end
+
+        def process_header(diagram, item)
+          # Header is just the 'pie' keyword, nothing to extract
+        end
+
+        def process_title(diagram, item)
+          title_data = item[:title]
+          return unless title_data
+
+          # Extract title text
+          title_text = if title_data.is_a?(Hash)
+                         extract_text(title_data[:title])
+                       else
+                         extract_text(title_data)
+                       end
+
+          diagram.title = title_text unless title_text.empty?
+        end
+
+        def process_show_data(diagram, item)
+          show_data = item[:show_data]
+          return unless show_data
+
+          # showData flag is present if this key exists
+          diagram.show_data = true
+        end
+
+        def process_statements(diagram, statements)
+          Array(statements).each do |stmt|
+            process_statement(diagram, stmt) if stmt.is_a?(Hash)
+          end
+        end
+
+        def process_statement(diagram, stmt)
+          return unless stmt.is_a?(Hash)
+
+          if stmt[:data_entry]
+            add_data_entry(diagram, stmt)
+          elsif stmt[:acc_title]
+            diagram.acc_title = extract_text(stmt[:acc_title])
+          elsif stmt[:acc_descr]
+            diagram.acc_description = extract_text(stmt[:acc_descr])
+          elsif stmt[:standalone_title]
+            diagram.title = extract_text(stmt[:standalone_title])
+          end
+        end
+
+        def add_data_entry(diagram, stmt)
+          label = extract_text(stmt[:label])
+          value = extract_numeric_value(stmt[:value])
+
+          return if label.empty?
+
+          slice = Diagram::PieSlice.new.tap do |s|
+            s.label = label
+            s.value = value
+          end
+
+          diagram.slices << slice
+        end
+
+        def extract_text(value)
+          case value
+          when Hash
+            if value[:string]
+              value[:string].to_s
+            elsif value[:title]
+              value[:title].to_s
+            else
+              value.values.first.to_s
+            end
+          when String
+            value
+          else
+            value.to_s
+          end.strip
+        end
+
+        def extract_numeric_value(value)
+          # Value can be a simple string or a complex structure
+          value_str = if value.is_a?(Hash)
+                        value.values.first.to_s
+                      else
+                        value.to_s
+                      end
+
+          # Parse as float to handle both integers and decimals
+          value_str.to_f
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+require_relative '../../diagram/quadrant'
+
+module Sirena
+  module Parser
+    module Transforms
+      # Transform for converting Parslet parse tree to QuadrantChart model.
+      #
+      # Converts the parse tree output from Grammars::Quadrant into a
+      # fully-formed Diagram::QuadrantChart object with points and labels.
+      class Quadrant
+        # Transform parse tree into QuadrantChart diagram.
+        #
+        # @param tree [Array, Hash] Parslet parse tree
+        # @return [Diagram::QuadrantChart] the quadrant chart diagram model
+        def apply(tree)
+          diagram = Diagram::QuadrantChart.new
+
+          # Tree structure: array with header and statements
+          if tree.is_a?(Array)
+            tree.each do |item|
+              next unless item.is_a?(Hash)
+
+              process_header(diagram, item) if item.key?(:header)
+              process_title(diagram, item) if item.key?(:title)
+              process_x_axis(diagram, item) if item.key?(:x_axis_left)
+              process_y_axis(diagram, item) if item.key?(:y_axis_bottom)
+              process_quadrant_label(diagram, item) if item.key?(:quadrant_label)
+              process_data_point(diagram, item) if item.key?(:data_point)
+            end
+          elsif tree.is_a?(Hash)
+            process_header(diagram, tree) if tree.key?(:header)
+            process_title(diagram, tree) if tree.key?(:title)
+            process_x_axis(diagram, tree) if tree.key?(:x_axis_left)
+            process_y_axis(diagram, tree) if tree.key?(:y_axis_bottom)
+
+            if tree[:statements]
+              process_statements(diagram, tree[:statements])
+            end
+          end
+
+          diagram
+        end
+
+        private
+
+        def process_header(diagram, item)
+          # Header is just the 'quadrantChart' keyword
+        end
+
+        def process_title(diagram, item)
+          title_data = item[:title]
+          return unless title_data
+
+          title_text = extract_text(title_data)
+          diagram.title = title_text unless title_text.empty?
+        end
+
+        def process_x_axis(diagram, item)
+          diagram.x_axis_left = extract_text(item[:x_axis_left])
+          diagram.x_axis_right = extract_text(item[:x_axis_right])
+        end
+
+        def process_y_axis(diagram, item)
+          diagram.y_axis_bottom = extract_text(item[:y_axis_bottom])
+          diagram.y_axis_top = extract_text(item[:y_axis_top])
+        end
+
+        def process_quadrant_label(diagram, item)
+          quadrant_num = item[:quadrant_number].to_s
+          label_text = extract_text(item[:quadrant_label])
+
+          case quadrant_num
+          when '1'
+            diagram.quadrant_1_label = label_text
+          when '2'
+            diagram.quadrant_2_label = label_text
+          when '3'
+            diagram.quadrant_3_label = label_text
+          when '4'
+            diagram.quadrant_4_label = label_text
+          end
+        end
+
+        def process_statements(diagram, statements)
+          Array(statements).each do |stmt|
+            next unless stmt.is_a?(Hash)
+
+            process_title(diagram, stmt) if stmt.key?(:title)
+            process_x_axis(diagram, stmt) if stmt.key?(:x_axis_left)
+            process_y_axis(diagram, stmt) if stmt.key?(:y_axis_bottom)
+            process_quadrant_label(diagram, stmt) if stmt.key?(:quadrant_label)
+            process_data_point(diagram, stmt) if stmt.key?(:data_point)
+          end
+        end
+
+        def process_data_point(diagram, item)
+          label = extract_text(item[:label])
+          coords = item[:coordinates]
+          styling = item[:styling]
+
+          return if label.empty? || coords.nil?
+
+          x = extract_float(coords[:x])
+          y = extract_float(coords[:y])
+
+          point = Diagram::QuadrantPoint.new.tap do |p|
+            p.label = label
+            p.x = x
+            p.y = y
+
+            # Process optional styling parameters
+            if styling
+              style_hash = extract_styling(styling)
+              p.radius = style_hash[:radius] if style_hash[:radius]
+              p.color = style_hash[:color] if style_hash[:color]
+              p.stroke_color = style_hash[:stroke_color] if style_hash[:stroke_color]
+              p.stroke_width = style_hash[:stroke_width] if style_hash[:stroke_width]
+            end
+          end
+
+          diagram.points << point
+        end
+
+        def extract_styling(styling)
+          result = {}
+
+          # Styling can be a Hash or Array depending on parse tree structure
+          items = if styling.is_a?(Array)
+                    styling
+                  elsif styling.is_a?(Hash)
+                    [styling]
+                  else
+                    []
+                  end
+
+          items.each do |item|
+            next unless item.is_a?(Hash)
+
+            result[:radius] = extract_float(item[:radius]) if item[:radius]
+            result[:color] = extract_text(item[:color]) if item[:color]
+            result[:stroke_color] = extract_text(item[:stroke_color]) if item[:stroke_color]
+            result[:stroke_width] = extract_float(item[:stroke_width]) if item[:stroke_width]
+          end
+
+          result
+        end
+
+        def extract_text(value)
+          case value
+          when Hash
+            if value[:string]
+              value[:string].to_s
+            else
+              value.values.first.to_s
+            end
+          when String
+            value
+          else
+            value.to_s
+          end.strip
+        end
+
+        def extract_float(value)
+          value_str = if value.is_a?(Hash)
+                        value.values.first.to_s
+                      else
+                        value.to_s
+                      end
+
+          value_str.to_f
+        end
+      end
+    end
+  end
+end