etassia 0.1.0

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

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require "parslet"
+require_relative "common"
+
+module Etassia
+  module Parser
+    module Grammars
+      # Grammar for parsing Mermaid xychart-beta syntax
+      class XyChart < Common
+        rule(:diagram_type) { str("xychart-beta") >> space? }
+
+        # Common line patterns
+        rule(:eol) { line_end }
+        rule(:indent?) { space? }
+        rule(:comment_line) { comment >> newline }
+        rule(:empty_line) { space? >> newline }
+        rule(:text) { match['[^"\n\r]'].repeat(1) }
+
+        rule(:title_line) do
+          str("title") >> space >> quoted_string.as(:title) >> eol
+        end
+
+        # X-axis: x-axis [jan, feb, mar] or x-axis "Label" [1, 2, 3]
+        rule(:axis_value) do
+          space? >>
+            (integer.as(:value) | identifier.as(:value)) >>
+            space?
+        end
+
+        rule(:axis_values) do
+          str("[") >>
+            axis_value >> (str(",") >> axis_value).repeat >>
+            str("]")
+        end
+
+        rule(:x_axis_line) do
+          str("x-axis") >>
+            (space >> quoted_string.as(:x_label)).maybe >>
+            space >> axis_values.as(:x_values) >>
+            eol
+        end
+
+        # Y-axis: y-axis "Label" min --> max or y-axis min --> max
+        rule(:range_separator) { str("-->") }
+
+        rule(:y_axis_line) do
+          str("y-axis") >>
+            (space >> quoted_string.as(:y_label)).maybe >>
+            space >> integer.as(:y_min) >>
+            space >> range_separator >>
+            space >> integer.as(:y_max) >>
+            eol
+        end
+
+        # Dataset values: [1, 2, 3, 4] or [1.5, 2.7, 3.2]
+        rule(:number_value) do
+          space? >>
+            (
+              integer >> (str(".") >> match["0-9"].repeat(1)).maybe
+            ).as(:value) >>
+            space?
+        end
+
+        rule(:value_array) do
+          str("[") >>
+            number_value >> (str(",") >> number_value).repeat >>
+            str("]")
+        end
+
+        # Line dataset: line [values]
+        rule(:line_dataset) do
+          str("line") >>
+            space >> value_array.as(:line_values) >>
+            eol
+        end
+
+        # Bar dataset: bar [values]
+        rule(:bar_dataset) do
+          str("bar") >>
+            space >> value_array.as(:bar_values) >>
+            eol
+        end
+
+        # Named dataset: dataset "Name" [values]
+        rule(:named_dataset) do
+          str("dataset") >>
+            space >> quoted_string.as(:dataset_label) >>
+            space >> value_array.as(:dataset_values) >>
+            eol
+        end
+
+        rule(:dataset_line) do
+          line_dataset | bar_dataset | named_dataset
+        end
+
+        rule(:statement) do
+          indent? >> (
+            title_line |
+            x_axis_line |
+            y_axis_line |
+            dataset_line |
+            comment_line |
+            empty_line
+          )
+        end
+
+        rule(:body) { statement.repeat }
+
+        rule(:xychart_diagram) do
+          diagram_type >> eol >>
+            body.as(:statements)
+        end
+
+        root(:xychart_diagram)
+      end
+    end
+  end
+end

data/lib/etassia/parser/info.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "grammars/info"
+require_relative "builders/info"
+require_relative "native/builders/info"
+require_relative "../diagram/info"
+
+module Etassia
+  module Parser
+    # Info diagram parser for Mermaid info diagram syntax.
+    #
+    # Uses Parslet grammar-based parsing to handle simple info diagrams.
+    #
+    # Parses info diagrams with support for:
+    # - Basic info keyword
+    # - Optional showInfo flag
+    #
+    # @example Parse a simple info diagram
+    #   parser = Info.new
+    #   diagram = parser.parse("info")
+    #
+    # @example Parse info diagram with showInfo
+    #   parser = Info.new
+    #   diagram = parser.parse("info showInfo")
+    class Info < Base
+      grammar Grammars::Info
+      builder Builders::Info
+      native :info, builder: Native::Builders::Info
+    end
+  end
+end

data/lib/etassia/parser/kanban.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "grammars/kanban"
+require_relative "builders/kanban"
+require_relative "native/builders/kanban"
+require_relative "../diagram/kanban"
+
+module Etassia
+  module Parser
+    # Kanban parser for Mermaid kanban diagram syntax.
+    #
+    # Uses Parslet grammar-based parsing to handle kanban syntax
+    # with columns, cards, and metadata.
+    #
+    # Parses kanban boards with support for:
+    # - Column definitions: id[Title], or a bare id
+    # - Card definitions: id[Text], or a bare id
+    # - Metadata: @{ key: 'value' }, with or without a bracket label
+    # - Properties: assigned, ticket, icon, label, priority
+    #
+    # @example Parse a simple kanban board
+    #   parser = Kanban.new
+    #   source = <<~MERMAID
+    #     kanban
+    #       id1[Todo]
+    #         docs[Create Documentation]
+    #       id2[Done]
+    #         release[Release v1.0]
+    #   MERMAID
+    #   diagram = parser.parse(source)
+    class Kanban < Base
+      COLUMN_ATTRIBUTES = %i[id title icon classes].freeze
+      CARD_ATTRIBUTES = %i[
+        id text assigned ticket icon label priority classes
+      ].freeze
+
+      # The native engine joins what each line captured, so its time grows
+      # with the source's bytes times its lines; the Parslet grammar scans
+      # the same source in linear time. A board is a few KB, so a source
+      # this large goes straight to Parslet.
+      NATIVE_BYTE_LIMIT = 100_000
+      private_constant :NATIVE_BYTE_LIMIT
+
+      grammar Grammars::Kanban
+      builder Builders::Kanban
+      native :kanban, builder: Native::Builders::Kanban
+
+      # Parses kanban diagram source into a Kanban model.
+      #
+      # @param source [String] the Mermaid kanban diagram source
+      # @return [Diagram::Kanban] the parsed kanban diagram
+      # @raise [ParseError] if syntax is invalid
+      # @raise [ArgumentError] if source is not a String
+      def parse(source)
+        unless source.is_a?(String)
+          raise ArgumentError,
+                "kanban source must be a String, got #{source.class}"
+        end
+
+        super(readable_source(source))
+      end
+
+      # The diagram for a builder's result: every column with its cards.
+      #
+      # @param result [Hash] the builder's +:columns+
+      # @return [Diagram::Kanban] the kanban diagram model
+      def create_diagram(result)
+        diagram = Diagram::Kanban.new
+
+        # Build columns and cards
+        result[:columns].each do |column_data|
+          column = build_column(column_data)
+          diagram.add_column(column)
+        end
+
+        diagram
+      end
+
+      private
+
+      def native_diagram(source)
+        return nil if source.bytesize > NATIVE_BYTE_LIMIT
+
+        super
+      end
+
+      def readable_source(source)
+        normalize_line_ends(transcode_to_utf8(source))
+      end
+
+      # The grammar and builder regexps carry non-ASCII (`\u`) classes, so
+      # matching them against a binary or ISO-8859-1 string raises
+      # Encoding::CompatibilityError instead of a parse result. A UTF-8 string
+      # with invalid bytes is re-encoded too: Parslet raises ArgumentError on
+      # it. A binary or US-ASCII string holds the bytes of a file read as
+      # UTF-8, so it is retagged, as `Source.split` does, not transcoded.
+      def transcode_to_utf8(source)
+        if [Encoding::BINARY, Encoding::US_ASCII].include?(source.encoding)
+          return source.dup.force_encoding(Encoding::UTF_8).scrub
+        end
+
+        recoded = source.encode(Encoding::UTF_8,
+                                invalid: :replace, undef: :replace)
+        recoded.b.force_encoding(Encoding::UTF_8).scrub
+      rescue Encoding::ConverterNotFoundError
+        raise ParseError,
+              "Cannot read a #{source.encoding} source: " \
+              "it has no UTF-8 converter."
+      end
+
+      # mermaid folds a CRLF and a lone CR into a newline before it lexes
+      # anything, so a bare `\r` ends a line and a comment. The grammar's
+      # `newline` knows `\n` and `\r\n` only.
+      def normalize_line_ends(source)
+        source.gsub(/\r\n?/, "\n")
+      end
+
+      def build_column(column_data)
+        attributes = column_data.slice(*COLUMN_ATTRIBUTES)
+        column = Diagram::KanbanColumn.new(**attributes)
+        column_data[:cards].each { |data| column.add_card(build_card(data)) }
+        column
+      end
+
+      def build_card(card_data)
+        Diagram::KanbanCard.new(**card_data.slice(*CARD_ATTRIBUTES))
+      end
+    end
+  end
+end

data/lib/etassia/parser/mermaid_shapes.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+# GENERATED by scripts/generate_shape_table.rb — do not edit by hand.
+#
+# The `@{ shape: ... }` names mmdc 11.12.0 draws as a shape
+# etassia also draws, checked by comparing mermaid's own drawing of the
+# name against its drawing of the classic bracket syntax for that shape.
+# Names that mermaid draws identically share a mapping.
+#
+# A name is absent either because mermaid rejects it or because mermaid
+# draws something etassia has no shape for — `bang`, `cloud` and `doc` are
+# all real mermaid shapes and none of them is a rectangle. The parser
+# refuses both kinds, so an unsupported shape fails where it can be seen
+# instead of quietly coming out as a rectangle.
+#
+# Regenerate with:
+#   ruby scripts/generate_shape_table.rb scripts/probes/shape_names.txt \
+#     > lib/etassia/parser/mermaid_shapes.rb
+
+module Etassia
+  module Parser
+    # Shape names etassia draws the way mermaid draws them.
+    MERMAID_SHAPES = {
+      "circ" => "circle",
+      "circle" => "circle",
+      "cyl" => "cylindrical",
+      "cylinder" => "cylindrical",
+      "data-store" => "rect",
+      "database" => "cylindrical",
+      "datastore" => "rect",
+      "db" => "cylindrical",
+      "dbl-circ" => "double_circle",
+      "decision" => "rhombus",
+      "diam" => "rhombus",
+      "diamond" => "rhombus",
+      "double-circle" => "double_circle",
+      "doublecircle" => "double_circle",
+      "event" => "rounded",
+      "fr-rect" => "subroutine",
+      "framed-rectangle" => "subroutine",
+      "hex" => "hexagon",
+      "hexagon" => "hexagon",
+      "in-out" => "parallelogram",
+      "inv-trapezoid" => "trapezoid_alt",
+      "lean-l" => "parallelogram_alt",
+      "lean-left" => "parallelogram_alt",
+      "lean-r" => "parallelogram",
+      "lean-right" => "parallelogram",
+      "manual" => "trapezoid_alt",
+      "odd" => "asymmetric",
+      "out-in" => "parallelogram_alt",
+      "pill" => "stadium",
+      "prepare" => "hexagon",
+      "priority" => "trapezoid",
+      "proc" => "rect",
+      "process" => "rect",
+      "question" => "rhombus",
+      "rect" => "rect",
+      "rectangle" => "rect",
+      "rounded" => "rounded",
+      "stadium" => "stadium",
+      "subproc" => "subroutine",
+      "subprocess" => "subroutine",
+      "subroutine" => "subroutine",
+      "terminal" => "stadium",
+      "trap-b" => "trapezoid",
+      "trap-t" => "trapezoid_alt",
+      "trapezoid" => "trapezoid",
+      "trapezoid-bottom" => "trapezoid",
+      "trapezoid-top" => "trapezoid_alt",
+    }.freeze
+
+    # Names mermaid draws and etassia has no shape for. Kept apart from the
+    # names mermaid does not know at all, because the two are different
+    # errors and mermaid's own message for the second one is quoted by a
+    # corpus case.
+    UNDRAWABLE_SHAPES = %w[
+      anchor bang bolt bow-rect
+      bow-tie-rectangle brace brace-l brace-r
+      braces card choice cloud
+      collate com-link comment constructor
+      cross-circ crossed-circle curv-trap curved-trapezoid
+      das delay disk display
+      div-proc div-rect divided-process divided-rectangle
+      doc docs document documents
+      extract f-circ filled-circle flag
+      flip-tri flipped-triangle fork fr-circ
+      framed-circle h-cyl half-rounded-rectangle horizontal-cylinder
+      hourglass icon internal-storage join
+      junction lightning-bolt lin-cyl lin-doc
+      lin-proc lin-rect lined-cylinder lined-document
+      lined-process lined-rectangle loop-limit manual-file
+      manual-input notch-pent notch-rect notched-pentagon
+      notched-rectangle note paper-tape processes
+      procs shaded-process sl-rect sloped-rectangle
+      sm-circ small-circle st-doc st-rect
+      stacked-document stacked-rectangle start state
+      stop stored-data summary tag-doc
+      tag-proc tag-rect tagged-document tagged-process
+      tagged-rectangle text tri triangle
+      win-pane window-pane
+    ].freeze
+
+    private_constant :MERMAID_SHAPES, :UNDRAWABLE_SHAPES
+  end
+end