etassia 0.1.0

data/lib/etassia/parser/grammars/common.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require "parslet"
+require_relative "../atoms/greedy_run"
+require_relative "../atoms/trimmed_run"
+require_relative "../atoms/delimited_run"
+
+module Etassia
+  module Parser
+    module Grammars
+      # Defined directly in this module, not in a class body, so any
+      # grammar class LEXICALLY NESTED inside `Grammars` resolves the
+      # bare constant `GreedyRun` here regardless of that class's own
+      # ancestry or which sibling grammar file loads first -- Ruby
+      # constant lookup checks the enclosing lexical scopes
+      # (`Module.nesting`) before it ever checks superclasses.
+      GreedyRun = Etassia::Parser::Atoms::GreedyRun
+      private_constant :GreedyRun
+
+      # Same reasoning as `GreedyRun` above.
+      TrimmedRun = Etassia::Parser::Atoms::TrimmedRun
+      private_constant :TrimmedRun
+
+      # Same reasoning as `GreedyRun` above.
+      DelimitedRun = Etassia::Parser::Atoms::DelimitedRun
+      private_constant :DelimitedRun
+
+      # Common grammar rules for Mermaid diagrams.
+      #
+      # Provides shared parsing patterns used across all diagram types,
+      # including whitespace handling, comments, identifiers, strings,
+      # and common punctuation.
+      class Common < Parslet::Parser
+        # Whitespace patterns
+        rule(:space) { match[' \t'] }
+        rule(:space?) { space.repeat }
+        rule(:newline) { str("\n") | str("\r\n") }
+        rule(:whitespace) { (space | newline).repeat(1) }
+        rule(:whitespace?) { (space | newline).repeat }
+
+        # Comments
+        # `GreedyRun`, not `(newline.absent? >> any).repeat`: that form
+        # applies once per character and joins the pieces pairwise, so a
+        # 100 KB comment took seconds.
+        rule(:comment) { str("%%") >> GreedyRun.new('[^\n]', min: 0) }
+
+        # Identifiers and keywords
+        rule(:identifier) do
+          match["a-zA-Z_"] >> match["a-zA-Z0-9_"].repeat
+        end
+
+        rule(:quoted_string) do
+          str('"') >> (
+            (str("\\") >> any) | (str('"').absent? >> any)
+          ).repeat.as(:string) >> str('"')
+        end
+
+        rule(:single_quoted_string) do
+          str("'") >> (
+            (str("\\") >> any) | (str("'").absent? >> any)
+          ).repeat.as(:string) >> str("'")
+        end
+
+        rule(:string) { quoted_string | single_quoted_string }
+
+        # Numbers
+        rule(:integer) { match["0-9"].repeat(1) }
+        rule(:float) do
+          integer >> str(".") >> integer
+        end
+        rule(:number) { float | integer }
+
+        # Common punctuation
+        rule(:colon) { str(":") }
+        rule(:semicolon) { str(";") }
+        rule(:comma) { str(",") }
+        rule(:lparen) { str("(") }
+        rule(:rparen) { str(")") }
+        rule(:lbracket) { str("[") }
+        rule(:rbracket) { str("]") }
+        rule(:lbrace) { str("{") }
+        rule(:rbrace) { str("}") }
+        rule(:pipe) { str("|") }
+        rule(:equals) { str("=") }
+        rule(:plus) { str("+") }
+        rule(:minus) { str("-") }
+        rule(:asterisk) { str("*") }
+        rule(:tilde) { str("~") }
+        rule(:hash_char) { str("#") }
+
+        # Line terminators
+        rule(:line_end) do
+          semicolon.maybe >> space? >> ((comment.maybe >> newline) | eof)
+        end
+
+        # Alias for end-of-line (used by some grammars)
+        rule(:eol) { line_end }
+
+        rule(:eof) { any.absent? }
+
+        # Utility: skip whitespace and comments
+        rule(:ws) { (space | newline | comment).repeat }
+        rule(:ws?) { ws.maybe }
+      end
+    end
+  end
+end

data/lib/etassia/parser/grammars/er_diagram.rb

@@ -0,0 +1,232 @@
+# frozen_string_literal: true
+
+require_relative "common"
+
+module Etassia
+  module Parser
+    module Grammars
+      # Parslet grammar for ER diagrams.
+      #
+      # Handles Entity-Relationship diagram syntax including entities,
+      # attributes, relationships with cardinality notation, and both
+      # identifying and non-identifying relationships.
+      class ErDiagram < Common
+        # ECMA-262 LineTerminator: what a JS `.` refuses to cross.
+        JS_LINE_TERMINATOR_CHARS = '\n\r\u2028\u2029'
+        private_constant :JS_LINE_TERMINATOR_CHARS
+
+        # ECMA-262 WhiteSpace + LineTerminator: what JS `\s` matches.
+        JS_WHITESPACE_CHARS = '\t\v\f\x20\u00A0\u1680\u2000-\u200A' \
+                              '\u2028\u2029\u202F\u205F\u3000\uFEFF\n\r'
+        private_constant :JS_WHITESPACE_CHARS
+
+        root(:diagram)
+
+        # Main diagram structure
+        rule(:diagram) do
+          ws? >>
+            header >>
+            ws? >>
+            statements.maybe >>
+            ws?
+        end
+
+        rule(:header) do
+          str("erDiagram").as(:header) >> ws?
+        end
+
+        rule(:statements) do
+          (statement >> ws?).repeat(1)
+        end
+
+        rule(:statement) do
+          class_def_statement |
+            entity_definition |
+            relationship |
+            entity_declaration
+        end
+
+        # Entity with attribute block
+        rule(:entity_definition) do
+          entity_name.as(:entity_id) >>
+            (str(":::") >> class_name_list.as(:entity_classes)).maybe >>
+            space? >>
+            lbrace >> ws? >>
+            attributes.maybe.as(:attributes) >>
+            ws? >> rbrace >>
+            line_end
+        end
+
+        # An entity name as mermaid's lexer reads it: a double-quoted run
+        # (quotes dropped by the builder), a number (`1`, `1.5`), or a word
+        # that may contain `-`, so `ORDER-ITEM` is one entity. Digit-led
+        # words such as `2abc` are not names in a relationship; mermaid
+        # rejects them there, and so does this rule.
+        rule(:entity_name) do
+          (str('"') >> GreedyRun.new('[^"]', min: 1) >> str('"')) |
+            (match["0-9"].repeat(1) >> str(".") >> match["0-9"].repeat(1)) |
+            match["0-9"].repeat(1) |
+            (match["a-zA-Z_"] >> match["a-zA-Z0-9_\\-"].repeat)
+        end
+
+        # Relationship between entities
+        #
+        # The two ends capture under DIFFERENT names. Parslet merges a
+        # statement's captures into one hash, so giving both ends
+        # `:entity_classes` drops the from-end silently, warning only on
+        # stderr. A7 in the parser spec is the guard.
+        rule(:relationship) do
+          entity_name.as(:from_id) >>
+            (str(":::") >> class_name_list.as(:from_classes)).maybe >>
+            space? >>
+            relationship_pattern.as(:pattern) >> space? >>
+            entity_name.as(:to_id) >>
+            (str(":::") >> class_name_list.as(:to_classes)).maybe >>
+            space? >>
+            relationship_label.maybe.as(:label) >>
+            line_end
+        end
+
+        # Stand-alone entity (no body, no relationship)
+        rule(:entity_declaration) do
+          entity_name.as(:entity_id) >>
+            (str(":::") >> class_name_list.as(:entity_classes)).maybe >>
+            line_end
+        end
+
+        # Style class declaration: `classDef name[,name] <styles>`
+        #
+        # The style run ends at `line_end`, not at a newline, and `line_end`
+        # opens with `semicolon.maybe` — so `classDef x fill:#f96;` captures
+        # `fill:#f96` and mermaid's optional trailing `;` is not part of the
+        # style text. A15 pins it.
+        rule(:class_def_statement) do
+          str("classDef") >> space.repeat(1) >>
+            class_name_list.as(:classdef_names) >> space.repeat(1) >>
+            (line_end.absent? >> any).repeat(1).as(:classdef_styles) >>
+            line_end
+        end
+
+        # One or more class names. Names are the inherited `identifier`;
+        # mermaid accepts more, and its `:::` and `classDef` sides disagree
+        # with each other about what. See the plan's declared gap 1.
+        rule(:class_name_list) do
+          identifier >> (comma >> space? >> identifier).repeat
+        end
+
+        # Attributes within entity block
+        rule(:attributes) do
+          (attribute >> ws?).repeat(1)
+        end
+
+        rule(:attribute) do
+          attribute_type.maybe.as(:type) >> space? >>
+            identifier.as(:name) >> space? >>
+            key_list.maybe.as(:key) >>
+            (space? >> note.as(:note)).maybe >>
+            (space? >> comment).maybe
+        end
+
+        # Double-quoted only, no escapes, no embedded quote -- do not widen
+        # this to accept single quotes or `\"` like common.rb's `string`/
+        # `single_quoted_string`; mermaid's own ER COMMENT token rejects both.
+        #
+        # `GreedyRun`, not `match('[^"]').repeat`: the native form folds
+        # one-char Slices back together per character, which is O(n^2) on a
+        # long note.
+        rule(:note) do
+          str('"') >> GreedyRun.new('[^"]', min: 0).as(:string) >> str('"')
+        end
+
+        # A plain identifier, or a `~...~`-quoted type for a name mermaid's
+        # own identifier can't hold, like `~timestamp with time zone~`.
+        rule(:attribute_type) do
+          tilde_type | identifier
+        end
+
+        # Matches mermaid's lexer `/^(?:([^\s]*)[~].*[~]([^\s]*))/i`: no
+        # minimum length between the tildes, `.` cannot cross a JS line
+        # terminator, and a non-whitespace run may sit directly before the
+        # opening tilde and after the closing one. Captures the FULL match
+        # as `:string` -- the builder converts paired tildes to `<`/`>`
+        # via `parse_generic_types`, it must never just strip them.
+        #
+        # JS `.*` is greedy: it matches to the LAST tilde on the line, not
+        # the first (see spec/etassia/parser/er_diagram_spec.rb).
+        # `tilde_marked_run` reproduces that.
+        rule(:tilde_type) do
+          (tilde_prefix >> tilde_marked_run >> tilde_suffix).as(:string)
+        end
+
+        # The `~T~` core, from the opening tilde through the LAST tilde
+        # before a JS line terminator: one-or-more tilde-closed chunks,
+        # `(?:[^~<lineterm>]*~)+`. Needs `DelimitedRun`, not a plain
+        # `GreedyRun` -- this pattern's own trailing tilde requirement
+        # cannot be decided from one chunk in isolation (a run that
+        # reaches a chunk boundary might still find its closing tilde in
+        # the NEXT chunk), so `DelimitedRun` matches segment-by-segment
+        # instead of scanning the whole compound pattern per chunk.
+        rule(:tilde_marked_run) do
+          DelimitedRun.new("~", "[^~#{JS_LINE_TERMINATOR_CHARS}]")
+        end
+
+        # `[^\s]` in mermaid's lexer is JS's `\s`, which is the full
+        # ECMA-262 WhiteSpace + LineTerminator set -- not just space, tab
+        # and `\n`. `JS_WHITESPACE_CHARS` is the same set already used for
+        # this in `lib/etassia/parser/grammars/flowchart.rb`
+        # (`LINE_SPACE_CHARS`, plus `\n`/`\r` since this rule's `[^\s]`
+        # excludes those too, unlike flowchart's line-space-only class).
+        rule(:tilde_prefix) do
+          GreedyRun.new("[^~#{JS_WHITESPACE_CHARS}]", min: 0)
+        end
+
+        rule(:tilde_suffix) do
+          GreedyRun.new("[^#{JS_WHITESPACE_CHARS}]", min: 0)
+        end
+
+        rule(:key_type) do
+          (str("PK") | str("FK") | str("UK")).as(:key_type)
+        end
+
+        # Mermaid takes comma-separated keys in any combination, spaces
+        # around the comma optional: `PK,FK`, `FK , UK`. Space alone does
+        # not separate them. Parslet yields a Hash for one key and an
+        # Array of Hashes for several.
+        rule(:key_list) do
+          key_type >> (space? >> comma >> space? >> key_type).repeat
+        end
+
+        # Relationship pattern: cardinality(2) + operator(2) + cardinality(2)
+        # Examples: ||--o{, ||==|{, }o..||
+        rule(:relationship_pattern) do
+          cardinality.as(:card_from) >>
+            operator.as(:operator) >>
+            cardinality.as(:card_to)
+        end
+
+        # Cardinality symbols (2 characters)
+        rule(:cardinality) do
+          str("||") | str("o{") | str("|{") | str("}o") | str("}|") |
+            str("o|") | str("|o") |
+            str("{o") | str("{|") | str("}{") | str("{}")
+        end
+
+        # Relationship operators (2 characters)
+        rule(:operator) do
+          str("==") | str("--") | str("..")
+        end
+
+        # Relationship label (after colon)
+        rule(:relationship_label) do
+          colon >> space? >>
+            (line_end.absent? >> any).repeat(1).as(:label_text)
+        end
+
+        # Line terminators for ER diagrams
+        rule(:line_end) do
+          semicolon.maybe >> space? >> ((comment.maybe >> newline) | eof)
+        end
+      end
+    end
+  end
+end

data/lib/etassia/parser/grammars/error.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative "common"
+
+module Etassia
+  module Parser
+    module Grammars
+      # Parslet grammar for error diagrams.
+      #
+      # Mermaid only detects a source that is exactly "error" (any case
+      # in its detector, trimmed); "Error Diagrams" is no diagram there.
+      #
+      # @example Simple error diagram
+      #   error
+      class Error < Common
+        root(:diagram)
+
+        # Main diagram structure
+        rule(:diagram) do
+          ws? >>
+            header >>
+            ws?
+        end
+
+        # Header: error or Error, alone
+        rule(:header) do
+          (str("Error") | str("error")).as(:header) >> ws?
+        end
+      end
+    end
+  end
+end