sirena 0.1.0

data/lib/sirena/parser/mindmap.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "grammars/mindmap"
+require_relative "transforms/mindmap"
+require_relative "../diagram/mindmap"
+
+module Sirena
+  module Parser
+    # Mindmap parser for Mermaid mindmap diagram syntax.
+    #
+    # Uses Parslet grammar-based parsing to handle mindmap syntax
+    # with hierarchical nodes, shapes, icons, and classes.
+    #
+    # Parses mindmaps with support for:
+    # - Indentation-based hierarchy
+    # - Multiple node shapes (circle, cloud, bang, hexagon, square)
+    # - Icons (::icon(name))
+    # - Classes (:::className)
+    #
+    # @example Parse a simple mindmap
+    #   parser = MindmapParser.new
+    #   source = <<~MERMAID
+    #     mindmap
+    #       root((Central Idea))
+    #         Branch 1
+    #           Sub-item 1.1
+    #         Branch 2
+    #   MERMAID
+    #   diagram = parser.parse(source)
+    class MindmapParser < Base
+      # Parses mindmap diagram source into a Mindmap model.
+      #
+      # @param source [String] the Mermaid mindmap diagram source
+      # @return [Diagram::Mindmap] the parsed mindmap diagram
+      # @raise [ParseError] if syntax is invalid
+      def parse(source)
+        grammar = Grammars::Mindmap.new
+
+        begin
+          parse_tree = grammar.parse(source)
+        rescue Parslet::ParseFailed => e
+          raise ParseError, "Syntax error at #{e.parse_failure_cause.pos}: " \
+                           "#{e.parse_failure_cause}"
+        end
+
+        # Transform parse tree to diagram model
+        transform = Transforms::Mindmap.new
+        result = transform.apply(parse_tree)
+
+        # Create the diagram model
+        create_diagram(result)
+      end
+
+      private
+
+      def create_diagram(result)
+        diagram = Diagram::Mindmap.new
+
+        # Build node hierarchy
+        if result[:root]
+          root = build_node(result[:root])
+          diagram.root = root
+          diagram.add_node(root)
+        end
+
+        # Add all nodes to diagram
+        result[:nodes]&.each do |node_data|
+          next if node_data == result[:root]
+          node = find_or_create_node(diagram, node_data)
+          diagram.add_node(node) unless diagram.nodes.include?(node)
+        end
+
+        diagram
+      end
+
+      def build_node(node_data, parent = nil)
+        node = Diagram::Mindmap::MindmapNode.new(
+          id: node_data[:id],
+          content: node_data[:content],
+          level: node_data[:level],
+          shape: node_data[:shape] || "default",
+          icon: node_data[:icon],
+          classes: node_data[:classes] || []
+        )
+
+        node.parent = parent if parent
+
+        # Build children recursively
+        node_data[:children]&.each do |child_data|
+          child = build_node(child_data, node)
+          node.add_child(child)
+        end
+
+        node
+      end
+
+      def find_or_create_node(diagram, node_data)
+        existing = diagram.nodes.find { |n| n.id == node_data[:id] }
+        return existing if existing
+
+        build_node(node_data)
+      end
+    end
+  end
+end

data/lib/sirena/parser/packet.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "grammars/packet"
+require_relative "transforms/packet"
+require_relative "../diagram/packet"
+
+module Sirena
+  module Parser
+    # Packet diagram parser for Mermaid packet-beta diagram syntax.
+    #
+    # Uses Parslet grammar-based parsing to handle packet diagram syntax
+    # with bit ranges and field labels.
+    #
+    # Parses packet diagrams with support for:
+    # - Title metadata
+    # - Field definitions with bit ranges
+    # - Field labels
+    #
+    # @example Parse a simple packet diagram
+    #   parser = PacketParser.new
+    #   source = <<~MERMAID
+    #     packet-beta
+    #       title Hello world
+    #       0-10: "hello"
+    #   MERMAID
+    #   diagram = parser.parse(source)
+    class PacketParser < Base
+      # Parses packet diagram source into a PacketDiagram model.
+      #
+      # @param source [String] the Mermaid packet diagram source
+      # @return [Diagram::PacketDiagram] the parsed packet diagram
+      # @raise [ParseError] if syntax is invalid
+      def parse(source)
+        grammar = Grammars::Packet.new
+
+        begin
+          parse_tree = grammar.parse(source)
+        rescue Parslet::ParseFailed => e
+          raise ParseError, "Syntax error at #{e.parse_failure_cause.pos}: " \
+                           "#{e.parse_failure_cause}"
+        end
+
+        # Transform parse tree to intermediate representation
+        transform = Transforms::Packet.new
+        result = transform.apply(parse_tree)
+
+        # Create the diagram model
+        create_diagram(result)
+      end
+
+      private
+
+      def create_diagram(result)
+        diagram = Diagram::PacketDiagram.new
+
+        # Handle case where result is not a hash (empty diagram)
+        return diagram unless result.is_a?(Hash)
+
+        diagram.title = result[:title]
+
+        # Create fields
+        Array(result[:fields]).each do |field_data|
+          field = Diagram::PacketField.new(
+            field_data[:bit_start],
+            field_data[:bit_end],
+            field_data[:label]
+          )
+          diagram.add_field(field)
+        end
+
+        diagram
+      end
+    end
+  end
+end

data/lib/sirena/parser/pie.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+require_relative 'grammars/pie'
+require_relative 'transforms/pie'
+require_relative '../diagram/pie'
+
+module Sirena
+  module Parser
+    # Pie chart parser for Mermaid pie diagram syntax.
+    #
+    # Uses Parslet grammar-based parsing to handle pie chart syntax
+    # with labeled data entries and numeric values.
+    #
+    # Parses pie charts with support for:
+    # - Title declarations
+    # - showData flag for displaying values
+    # - Data entries with quoted labels and numeric values
+    # - Accessibility features (accTitle, accDescr)
+    # - Comments
+    #
+    # @example Parse a simple pie chart
+    #   parser = PieParser.new
+    #   diagram = parser.parse("pie\n  \"Apples\" : 42\n  \"Oranges\" : 58")
+    class PieParser < Base
+      # Parses pie chart diagram source into a Pie diagram model.
+      #
+      # @param source [String] the Mermaid pie chart diagram source
+      # @return [Diagram::Pie] the parsed pie chart diagram
+      # @raise [ParseError] if syntax is invalid
+      def parse(source)
+        grammar = Grammars::Pie.new
+
+        begin
+          parse_tree = grammar.parse(source)
+        rescue Parslet::ParseFailed => e
+          raise ParseError, "Syntax error at #{e.parse_failure_cause.pos}: " \
+                           "#{e.parse_failure_cause}"
+        end
+
+        # Transform parse tree to diagram model
+        transform = Transforms::Pie.new
+        diagram = transform.apply(parse_tree)
+
+        diagram
+      end
+    end
+  end
+end

data/lib/sirena/parser/quadrant.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+require_relative 'grammars/quadrant'
+require_relative 'transforms/quadrant'
+require_relative '../diagram/quadrant'
+
+module Sirena
+  module Parser
+    # Quadrant chart parser for Mermaid quadrant diagram syntax.
+    #
+    # Uses Parslet grammar-based parsing to handle quadrant chart syntax
+    # with axis labels, quadrant labels, and data points.
+    #
+    # Parses quadrant charts with support for:
+    # - Title declarations
+    # - X-axis and Y-axis labels
+    # - Quadrant labels (1-4)
+    # - Data points with normalized coordinates
+    # - Point styling (radius, color, stroke)
+    # - Comments
+    #
+    # @example Parse a simple quadrant chart
+    #   parser = QuadrantParser.new
+    #   source = <<~MERMAID
+    #     quadrantChart
+    #       title Product Analysis
+    #       x-axis Low Cost --> High Cost
+    #       y-axis Low Value --> High Value
+    #       Product A: [0.3, 0.7]
+    #   MERMAID
+    #   diagram = parser.parse(source)
+    class QuadrantParser < Base
+      # Parses quadrant chart diagram source into a QuadrantChart model.
+      #
+      # @param source [String] the Mermaid quadrant chart diagram source
+      # @return [Diagram::QuadrantChart] the parsed quadrant chart diagram
+      # @raise [ParseError] if syntax is invalid
+      def parse(source)
+        grammar = Grammars::Quadrant.new
+
+        begin
+          parse_tree = grammar.parse(source)
+        rescue Parslet::ParseFailed => e
+          raise ParseError, "Syntax error at #{e.parse_failure_cause.pos}: " \
+                           "#{e.parse_failure_cause}"
+        end
+
+        # Transform parse tree to diagram model
+        transform = Transforms::Quadrant.new
+        diagram = transform.apply(parse_tree)
+
+        diagram
+      end
+    end
+  end
+end

data/lib/sirena/parser/radar.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "grammars/radar"
+require_relative "transforms/radar"
+require_relative "../diagram/radar"
+
+module Sirena
+  module Parser
+    # Radar chart parser for Mermaid radar-beta diagram syntax.
+    #
+    # Uses Parslet grammar-based parsing to handle radar chart syntax
+    # with axes and multiple data curves.
+    #
+    # Parses radar charts with support for:
+    # - Title and accessibility metadata
+    # - Axis definitions with labels
+    # - Multiple data curves/datasets
+    # - Configuration options (ticks, legend, graticule, min/max)
+    #
+    # @example Parse a simple radar chart
+    #   parser = RadarParser.new
+    #   source = <<~MERMAID
+    #     radar-beta
+    #       title Skills Assessment
+    #       axis A, B, C
+    #       curve mycurve{1, 2, 3}
+    #   MERMAID
+    #   diagram = parser.parse(source)
+    class RadarParser < Base
+      # Parses radar diagram source into a RadarChart model.
+      #
+      # @param source [String] the Mermaid radar diagram source
+      # @return [Diagram::RadarChart] the parsed radar chart
+      # @raise [ParseError] if syntax is invalid
+      def parse(source)
+        grammar = Grammars::Radar.new
+
+        begin
+          parse_tree = grammar.parse(source)
+        rescue Parslet::ParseFailed => e
+          raise ParseError, "Syntax error at #{e.parse_failure_cause.pos}: " \
+                           "#{e.parse_failure_cause}"
+        end
+
+        # Transform parse tree to intermediate representation
+        transform = Transforms::Radar.new
+        result = transform.apply(parse_tree)
+
+        # Create the diagram model
+        create_diagram(result)
+      end
+
+      private
+
+      def create_diagram(result)
+        diagram = Diagram::RadarChart.new
+        diagram.title = result[:title]
+        diagram.acc_title = result[:acc_title]
+        diagram.acc_descr = result[:acc_descr]
+        diagram.options = result[:options]
+
+        # Create axes
+        result[:axes].each do |axis_data|
+          axis = Diagram::RadarAxis.new(
+            axis_data[:id],
+            axis_data[:label]
+          )
+          diagram.axes << axis
+        end
+
+        # Create curves
+        result[:curves].each do |curve_data|
+          curve = Diagram::RadarCurve.new(
+            curve_data[:id],
+            curve_data[:label]
+          )
+
+          # Add values - handle both positional and named formats
+          values = Array(curve_data[:values])
+
+          if values.first.is_a?(Hash) && values.first[:axis]
+            # Named format: { axis: "A", value: 1.0 }
+            values.each do |val|
+              curve.add_value(val[:axis], val[:value])
+            end
+          else
+            # Positional format: [1.0, 2.0, 3.0]
+            values.each_with_index do |val, idx|
+              next unless diagram.axes[idx]
+
+              axis_id = diagram.axes[idx].id
+              curve.add_value(axis_id, val)
+            end
+          end
+
+          diagram.curves << curve
+        end
+
+        diagram
+      end
+    end
+  end
+end

data/lib/sirena/parser/requirement.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+require_relative 'grammars/requirement'
+require_relative 'transforms/requirement'
+require_relative '../diagram/requirement'
+
+module Sirena
+  module Parser
+    # Requirement diagram parser for Mermaid requirement diagram syntax.
+    #
+    # Parses requirement diagrams with support for:
+    # - Requirements with properties (id, text, risk, verifymethod)
+    # - Multiple requirement types (requirement, functionalRequirement, etc.)
+    # - Elements with properties (type, docref)
+    # - Relationships (contains, copies, derives, satisfies, verifies, refines, traces)
+    # - Styling directives
+    # - Class definitions and assignments
+    #
+    # @example Parse a simple requirement diagram
+    #   parser = RequirementParser.new
+    #   diagram = parser.parse("requirementDiagram\n  requirement test_req { id: 1 }")
+    class RequirementParser < Base
+      # Parses requirement diagram source into a RequirementDiagram model.
+      #
+      # @param source [String] the Mermaid requirement diagram source
+      # @return [Diagram::RequirementDiagram] the parsed requirement diagram
+      # @raise [ParseError] if syntax is invalid
+      def parse(source)
+        grammar = Grammars::Requirement.new
+
+        begin
+          tree = grammar.parse(source)
+          diagram = Transforms::Requirement.apply(tree)
+          diagram
+        rescue Parslet::ParseFailed => e
+          raise ParseError, format_parse_error(e, source)
+        end
+      end
+
+      private
+
+      # Formats a Parslet parse error with context.
+      #
+      # @param error [Parslet::ParseFailed] the parse error
+      # @param source [String] the source that failed to parse
+      # @return [String] formatted error message
+      def format_parse_error(error, source)
+        lines = source.lines
+        line_num = error.parse_failure_cause.source.line_and_column[0]
+        col_num = error.parse_failure_cause.source.line_and_column[1]
+
+        context = []
+        context << "Parse error at line #{line_num}, column #{col_num}:"
+
+        # Show the problematic line
+        if line_num > 0 && line_num <= lines.length
+          context << lines[line_num - 1].chomp
+          context << (' ' * (col_num - 1)) + '^'
+        end
+
+        context << error.parse_failure_cause.to_s
+        context.join("\n")
+      rescue StandardError
+        # Fallback to simple error message
+        "Parse error: #{error.message}"
+      end
+    end
+  end
+end

data/lib/sirena/parser/sankey.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "grammars/sankey"
+require_relative "transforms/sankey"
+require_relative "../diagram/sankey"
+
+module Sirena
+  module Parser
+    # Sankey parser for Mermaid sankey diagram syntax.
+    #
+    # Uses Parslet grammar-based parsing to handle Sankey diagram syntax
+    # with flows between nodes and optional node labels.
+    #
+    # Parses Sankey diagrams with support for:
+    # - Flow definitions (CSV format: source,target,value)
+    # - Optional node declarations with labels
+    # - Automatic node discovery from flows
+    # - Numeric flow values (integer or float)
+    # - Comments
+    #
+    # @example Parse a simple Sankey diagram
+    #   parser = SankeyParser.new
+    #   diagram = parser.parse(<<~SANKEY)
+    #     sankey-beta
+    #     A,B,10
+    #     B,C,20
+    #     A,D,5
+    #   SANKEY
+    #
+    # @example Parse Sankey with node labels
+    #   parser = SankeyParser.new
+    #   diagram = parser.parse(<<~SANKEY)
+    #     sankey-beta
+    #     Source [Energy Source]
+    #     Process [Processing Plant]
+    #     Source,Process,100
+    #     Process,Output,70
+    #   SANKEY
+    class SankeyParser < Base
+      # Parses Sankey diagram source into a SankeyDiagram model.
+      #
+      # @param source [String] the Mermaid Sankey diagram source
+      # @return [Diagram::SankeyDiagram] the parsed Sankey diagram
+      # @raise [ParseError] if syntax is invalid
+      def parse(source)
+        grammar = Grammars::Sankey.new
+
+        begin
+          parse_tree = grammar.parse(source)
+        rescue Parslet::ParseFailed => e
+          raise ParseError, "Syntax error at #{e.parse_failure_cause.pos}: " \
+                           "#{e.parse_failure_cause}"
+        end
+
+        # Transform parse tree to diagram model
+        transform = Transforms::Sankey.new
+        diagram = transform.apply(parse_tree)
+
+        diagram
+      end
+    end
+  end
+end

data/lib/sirena/parser/sequence.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+require_relative 'grammars/sequence'
+require_relative 'transforms/sequence'
+require_relative '../diagram/sequence'
+
+module Sirena
+  module Parser
+    # Sequence parser for Mermaid sequence diagram syntax.
+    #
+    # Uses Parslet grammar-based parsing to correctly handle complex arrow
+    # patterns with activation modifiers (e.g., `->>+`, `-->>-`) that cannot
+    # be parsed accurately with regex-based lexers.
+    #
+    # Parses sequence diagrams with support for:
+    # - Participant declarations (participant, actor)
+    # - Multiple message types with activation modifiers
+    # - Activations and deactivations
+    # - Notes (left of, right of, over)
+    # - Control structures (loop, alt, opt, par, critical, break)
+    # - Box grouping
+    #
+    # @example Parse a simple sequence diagram
+    #   parser = SequenceParser.new
+    #   diagram = parser.parse("sequenceDiagram\nAlice->>Bob: Hello")
+    class SequenceParser < Base
+      # Parses sequence diagram source into a Sequence diagram model.
+      #
+      # @param source [String] the Mermaid sequence diagram source
+      # @return [Diagram::Sequence] the parsed sequence diagram
+      # @raise [ParseError] if syntax is invalid
+      def parse(source)
+        grammar = Grammars::Sequence.new
+
+        begin
+          parse_tree = grammar.parse(source)
+        rescue Parslet::ParseFailed => e
+          raise ParseError, "Syntax error at #{e.parse_failure_cause.pos}: " \
+                           "#{e.parse_failure_cause}"
+        end
+
+        # Transform parse tree to diagram model
+        transform = Transforms::Sequence.new
+        diagram = transform.apply(parse_tree)
+
+        diagram
+      end
+    end
+  end
+end

data/lib/sirena/parser/state_diagram.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+require_relative 'grammars/state_diagram'
+require_relative 'transforms/state_diagram'
+require_relative '../diagram/state_diagram'
+
+module Sirena
+  module Parser
+    # State diagram parser for Mermaid state diagram syntax.
+    #
+    # Parses state diagrams with support for:
+    # - Normal states with labels
+    # - Special states (start [*], end [*], choice, fork, join)
+    # - Transitions with triggers and guard conditions
+    # - Composite/nested states
+    # - Direction specification (TD, LR, etc.)
+    #
+    # @example Parse a simple state diagram
+    #   parser = StateDiagramParser.new
+    #   diagram = parser.parse("stateDiagram-v2\n[*]-->Idle\nIdle-->Active")
+    class StateDiagramParser < Base
+      # Parses state diagram source into a StateDiagram model.
+      #
+      # @param source [String] the Mermaid state diagram source
+      # @return [Diagram::StateDiagram] the parsed state diagram
+      # @raise [ParseError] if syntax is invalid
+      def parse(source)
+        grammar = Grammars::StateDiagram.new
+        transform = Transforms::StateDiagram.new
+
+        begin
+          tree = grammar.parse(source)
+          transform.apply(tree)
+        rescue Parslet::ParseFailed => e
+          raise ParseError, format_parse_error(e, source)
+        end
+      end
+
+      private
+
+      def format_parse_error(error, source)
+        # Get the failure cause and position
+        cause = error.parse_failure_cause
+        pos = cause.pos
+
+        # Get line and column - handle boundary conditions
+        return "Parse error: #{error.message}" if pos.nil? || pos < 0 || pos > source.length
+
+        lines = source[0...pos].split("\n")
+        line_num = lines.size
+        col_num = lines.last&.size || 0
+
+        # Get the problematic line
+        all_lines = source.split("\n")
+        problem_line = all_lines[line_num - 1] || ''
+
+        # Build error message
+        msg = "Parse error at line #{line_num}, column #{col_num}\n"
+        msg += "  #{problem_line}\n"
+        msg += "  #{' ' * col_num}^\n" if col_num >= 0
+        msg += "Expected: #{cause.expected_string}"
+        msg
+      rescue StandardError => e
+        "Parse error: #{error.message} (#{e.message})"
+      end
+    end
+  end
+end