sirena 0.1.0

data/lib/sirena/parser/architecture.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "grammars/architecture"
+require_relative "transforms/architecture"
+
+module Sirena
+  module Parser
+    # Parser for architecture diagrams
+    class Architecture < Base
+      def parse(input)
+        input = input.strip
+
+        grammar = Grammars::Architecture.new
+        tree = grammar.parse(input)
+
+        transform = Transforms::Architecture.new
+        transform.apply(tree)
+      rescue Parslet::ParseFailed => e
+        raise ParseError, format_error(e, input)
+      end
+
+      private
+
+      def format_error(error, input)
+        lines = input.split("\n")
+        line_no = error.parse_failure_cause.source.line_and_column[0]
+        column = error.parse_failure_cause.source.line_and_column[1]
+
+        context = []
+        context << lines[line_no - 2] if line_no > 1
+        context << lines[line_no - 1] if line_no > 0
+        context << " " * (column - 1) + "^"
+
+        "Parse error at line #{line_no}, column #{column}:\n" \
+        "#{context.join("\n")}\n" \
+        "#{error.parse_failure_cause.message}"
+      end
+    end
+  end
+end

data/lib/sirena/parser/base.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Sirena
+  module Parser
+    # Abstract base class for diagram parsers.
+    #
+    # This class defines the interface that all diagram-specific parsers
+    # must implement. Parsers are responsible for converting source code
+    # into a typed diagram model using Parslet grammars.
+    #
+    # @example Define a custom parser
+    #   class FlowchartParser < Parser::Base
+    #     def parse(source)
+    #       grammar = Grammars::Flowchart.new
+    #       tree = grammar.parse(source)
+    #       transform = Transforms::Flowchart.new
+    #       transform.apply(tree)
+    #     end
+    #   end
+    #
+    # @abstract Subclass and implement #parse
+    class Base
+
+      # Parses Mermaid source code into a diagram model.
+      #
+      # This method should be overridden by subclasses to implement
+      # diagram-specific parsing logic using Parslet grammars.
+      #
+      # @param source [String] the Mermaid source code to parse
+      # @return [Diagram::Base] the parsed diagram model
+      # @raise [NotImplementedError] if not implemented by subclass
+      def parse(source)
+        raise NotImplementedError,
+              "#{self.class} must implement #parse(source)"
+      end
+    end
+
+    # Error raised during parsing.
+    class ParseError < StandardError; end
+  end
+end

data/lib/sirena/parser/block.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+require_relative 'grammars/block'
+require_relative 'transforms/block'
+require_relative '../diagram/block'
+
+module Sirena
+  module Parser
+    # Block diagram parser for Mermaid block diagram syntax.
+    #
+    # Parses block diagrams with support for:
+    # - Column-based layouts
+    # - Blocks with various shapes (rectangle, circle)
+    # - Block width specifications
+    # - Compound/nested blocks
+    # - Space placeholders
+    # - Arrow blocks with directions
+    # - Connections between blocks
+    # - Styling directives
+    #
+    # @example Parse a simple block diagram
+    #   parser = BlockParser.new
+    #   diagram = parser.parse("block-beta\n  columns 2\n  A\n  B")
+    class BlockParser < Base
+      # Parses block diagram source into a BlockDiagram model.
+      #
+      # @param source [String] the Mermaid block diagram source
+      # @return [Diagram::BlockDiagram] the parsed block diagram
+      # @raise [ParseError] if syntax is invalid
+      def parse(source)
+        grammar = Grammars::Block.new
+
+        begin
+          tree = grammar.parse(source)
+          diagram = Transforms::Block.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/c4.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+require_relative 'grammars/c4'
+require_relative 'transforms/c4'
+require_relative '../diagram/c4'
+
+module Sirena
+  module Parser
+    # C4 parser for Mermaid C4 diagram syntax.
+    #
+    # Uses Parslet grammar-based parsing to handle C4 diagram syntax including
+    # elements, relationships, and boundaries.
+    #
+    # Parses C4 diagrams with support for:
+    # - Multiple C4 levels (Context, Container, Component, Dynamic, Deployment)
+    # - Person, System, Container, Component elements
+    # - External variants (_Ext suffix)
+    # - Database and Queue variants (SystemDb, ContainerQueue, etc.)
+    # - Relationships (Rel, BiRel)
+    # - Boundaries (Enterprise_Boundary, System_Boundary, Boundary)
+    # - Nested boundaries
+    # - Element attributes (sprite, link, tags)
+    # - Layout configuration
+    #
+    # @example Parse a simple C4 Context diagram
+    #   parser = C4Parser.new
+    #   diagram = parser.parse("C4Context\ntitle My System\nPerson(user, \"User\")")
+    class C4Parser < Base
+      # Parses C4 diagram source into a C4 diagram model.
+      #
+      # @param source [String] the Mermaid C4 diagram source
+      # @return [Diagram::C4] the parsed C4 diagram
+      # @raise [ParseError] if syntax is invalid
+      def parse(source)
+        grammar = Grammars::C4.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::C4.new
+        diagram = transform.apply(parse_tree)
+
+        diagram
+      end
+    end
+  end
+end

data/lib/sirena/parser/class_diagram.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+require_relative 'grammars/class_diagram'
+require_relative 'transforms/class_diagram'
+require_relative '../diagram/class_diagram'
+
+module Sirena
+  module Parser
+    # Class diagram parser for Mermaid class diagram syntax.
+    #
+    # Parses class diagrams with support for:
+    # - Class declarations with stereotypes
+    # - Attributes with visibility modifiers
+    # - Methods with parameters and return types
+    # - Relationships (inheritance, composition, aggregation, association)
+    # - Generic types (e.g., List~String~)
+    # - Namespaces
+    # - Cardinality labels
+    #
+    # @example Parse a simple class diagram
+    #   parser = ClassDiagramParser.new
+    #   diagram = parser.parse("classDiagram\nAnimal <|-- Dog")
+    class ClassDiagramParser < Base
+      # Parses class diagram source into a ClassDiagram model.
+      #
+      # @param source [String] the Mermaid class diagram source
+      # @return [Diagram::ClassDiagram] the parsed class diagram
+      # @raise [ParseError] if syntax is invalid
+      def parse(source)
+        grammar = Grammars::ClassDiagram.new
+        transform = Transforms::ClassDiagram.new
+
+        begin
+          parse_tree = grammar.parse(source)
+          diagram = transform.apply(parse_tree)
+          diagram
+        rescue Parslet::ParseFailed => e
+          raise ParseError, format_parse_error(e, source)
+        end
+      end
+
+      private
+
+      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 = if line_num <= lines.length
+                    lines[line_num - 1].chomp
+                  else
+                    '(end of input)'
+                  end
+
+        "Parse error at line #{line_num}, column #{col_num}:\n" \
+          "#{context}\n" \
+          "#{' ' * (col_num - 1)}^\n" \
+          "Expected: #{error.parse_failure_cause.message}"
+      end
+    end
+  end
+end

data/lib/sirena/parser/er_diagram.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+require_relative '../diagram/er_diagram'
+require_relative 'grammars/er_diagram'
+require_relative 'transforms/er_diagram'
+
+module Sirena
+  module Parser
+    # ER diagram parser for Mermaid ER diagram syntax.
+    #
+    # Parses ER diagrams with support for:
+    # - Entity declarations with attributes
+    # - Attribute types and key markers (PK, FK, UK)
+    # - Relationships with cardinality notation
+    # - Identifying and non-identifying relationships
+    #
+    # @example Parse a simple ER diagram
+    #   parser = ErDiagramParser.new
+    #   diagram = parser.parse("erDiagram\nCUSTOMER ||--o{ ORDER : places")
+    class ErDiagramParser < Base
+      # Parses ER diagram source into an ErDiagram model.
+      #
+      # @param source [String] the Mermaid ER diagram source
+      # @return [Diagram::ErDiagram] the parsed ER diagram
+      # @raise [ParseError] if syntax is invalid
+      def parse(source)
+        grammar = Grammars::ErDiagram.new
+        transform = Transforms::ErDiagram.new
+
+        tree = grammar.parse(source)
+        diagram = transform.apply(tree)
+
+        diagram
+      rescue Parslet::ParseFailed => e
+        raise ParseError, e.parse_failure_cause.ascii_tree
+      end
+    end
+  end
+end

data/lib/sirena/parser/error.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+require_relative 'grammars/error'
+require_relative 'transforms/error'
+require_relative '../diagram/error'
+
+module Sirena
+  module Parser
+    # Error diagram parser for Mermaid error diagram syntax.
+    #
+    # Uses Parslet grammar-based parsing to handle simple error diagrams.
+    #
+    # Parses error diagrams with support for:
+    # - Basic error keyword
+    # - Optional error message text
+    #
+    # @example Parse a simple error diagram
+    #   parser = ErrorParser.new
+    #   diagram = parser.parse("error")
+    #
+    # @example Parse error diagram with message
+    #   parser = ErrorParser.new
+    #   diagram = parser.parse("Error Diagrams")
+    class ErrorParser < Base
+      # Parses error diagram source into an Error diagram model.
+      #
+      # @param source [String] the Mermaid error diagram source
+      # @return [Diagram::Error] the parsed error diagram
+      # @raise [ParseError] if syntax is invalid
+      def parse(source)
+        grammar = Grammars::Error.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::Error.new
+        diagram = transform.apply(parse_tree)
+
+        diagram
+      end
+    end
+  end
+end

data/lib/sirena/parser/flowchart.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+require_relative 'grammars/flowchart'
+require_relative 'transforms/flowchart'
+require_relative '../diagram/flowchart'
+
+module Sirena
+  module Parser
+    # Flowchart parser for Mermaid flowchart syntax.
+    #
+    # Parses flowchart diagrams with support for:
+    # - Multiple node shapes (rectangle, rounded, rhombus, circle, etc.)
+    # - Multiple edge types (arrow, line, dotted, etc.)
+    # - Node labels with special characters
+    # - Edge chaining (A --> B --> C)
+    # - Subgraphs
+    # - Styling directives
+    # - Direction specification (TD, LR, etc.)
+    #
+    # @example Parse a simple flowchart
+    #   parser = FlowchartParser.new
+    #   diagram = parser.parse("graph TD\nA[Start]-->B[End]")
+    class FlowchartParser < Base
+      # Parses flowchart source into a Flowchart diagram model.
+      #
+      # @param source [String] the Mermaid flowchart source
+      # @return [Diagram::Flowchart] the parsed flowchart
+      # @raise [ParseError] if syntax is invalid
+      def parse(source)
+        grammar = Grammars::Flowchart.new
+
+        begin
+          tree = grammar.parse(source)
+          diagram = Transforms::Flowchart.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/gantt.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "grammars/gantt"
+require_relative "transforms/gantt"
+require_relative "../diagram/gantt"
+
+module Sirena
+  module Parser
+    # Gantt chart parser for Mermaid gantt diagram syntax.
+    #
+    # Uses Parslet grammar-based parsing to handle Gantt chart syntax
+    # with sections, tasks, dependencies, and timeline configuration.
+    #
+    # Parses Gantt charts with support for:
+    # - Title and date format declarations
+    # - Axis formatting and tick intervals
+    # - Excludes (weekends, weekdays, specific dates)
+    # - Section grouping
+    # - Tasks with dates, durations, and dependencies
+    # - Task status tags (done, active, crit, milestone)
+    # - Click handlers for interactivity
+    # - Accessibility features (accTitle, accDescr)
+    # - Comments
+    #
+    # @example Parse a simple Gantt chart
+    #   parser = GanttParser.new
+    #   diagram = parser.parse(<<~GANTT)
+    #     gantt
+    #       title Project Timeline
+    #       dateFormat YYYY-MM-DD
+    #       section Planning
+    #       Task 1 :a1, 2024-01-01, 30d
+    #       Task 2 :after a1, 20d
+    #   GANTT
+    class GanttParser < Base
+      # Parses Gantt chart diagram source into a GanttChart diagram model.
+      #
+      # @param source [String] the Mermaid Gantt chart diagram source
+      # @return [Diagram::GanttChart] the parsed Gantt chart diagram
+      # @raise [ParseError] if syntax is invalid
+      def parse(source)
+        grammar = Grammars::Gantt.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::Gantt.new
+        diagram = transform.apply(parse_tree)
+
+        diagram
+      end
+    end
+  end
+end

data/lib/sirena/parser/git_graph.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "grammars/git_graph"
+require_relative "transforms/git_graph"
+require_relative "../diagram/git_graph"
+
+module Sirena
+  module Parser
+    # Git Graph parser for Mermaid gitGraph diagram syntax.
+    #
+    # Uses Parslet grammar-based parsing to handle git graph syntax
+    # with commits, branches, merges, and cherry-picks.
+    #
+    # Parses git graphs with support for:
+    # - Commit declarations with id, type, and tag
+    # - Branch creation with optional order
+    # - Checkout/switch operations
+    # - Merge operations
+    # - Cherry-pick operations
+    # - Commit types (NORMAL, REVERSE, HIGHLIGHT)
+    #
+    # @example Parse a simple git graph
+    #   parser = GitGraphParser.new
+    #   source = <<~MERMAID
+    #     gitGraph
+    #       commit id: "Initial"
+    #       branch develop
+    #       checkout develop
+    #       commit id: "Feature"
+    #       checkout main
+    #       merge develop
+    #   MERMAID
+    #   diagram = parser.parse(source)
+    class GitGraphParser < Base
+      # Parses git graph diagram source into a GitGraph model.
+      #
+      # @param source [String] the Mermaid git graph diagram source
+      # @return [Diagram::GitGraph] the parsed git graph diagram
+      # @raise [ParseError] if syntax is invalid
+      def parse(source)
+        grammar = Grammars::GitGraph.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::GitGraph.new
+        result = transform.apply(parse_tree)
+
+        # Create the diagram model
+        create_diagram(result)
+      end
+
+      private
+
+      def create_diagram(result)
+        diagram = Diagram::GitGraph.new
+
+        # Add commits
+        result[:commits].each do |commit_data|
+          commit = Diagram::GitGraph::Commit.new(
+            id: commit_data[:id],
+            type: commit_data[:type],
+            tag: commit_data[:tag],
+            branch_name: commit_data[:branch_name],
+            parent_ids: commit_data[:parent_ids],
+            is_merge: commit_data[:is_merge],
+            merge_branch: commit_data[:merge_branch],
+            is_cherry_pick: commit_data[:is_cherry_pick],
+            cherry_pick_parent: commit_data[:cherry_pick_parent]
+          )
+          diagram.commits << commit
+        end
+
+        # Add branches
+        result[:branches].each do |branch_data|
+          branch = Diagram::GitGraph::Branch.new(
+            name: branch_data[:name],
+            order: branch_data[:order],
+            parent_branch: branch_data[:parent_branch],
+            created_at_commit: branch_data[:created_at_commit]
+          )
+          diagram.branches << branch
+        end
+
+        diagram
+      end
+    end
+  end
+end