parsanol 1.3.98 → 1.3.100

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 141dfea6902c1018accd9962fc346017dbb8d070303323df0d98e5f16bf12516
-  data.tar.gz: ec3ae0172d80d7c6c84743376958fb2ceb7dffd9072afbfe641fcf4e0267e079
+  metadata.gz: 6006d5eac0900781aae6db62350af96b3635055c0ad96f5509b448a4e6e37bcb
+  data.tar.gz: cb3b2196ae881b7e1ca07b99911428fcdaeeab9e70eb159b217ffe436130e44a
 SHA512:
-  metadata.gz: 40e41398c910b644fe3be0a7042d0a2ed763e2e622d61e98d3efa01d5bf74301c2adc61dbfdd689f99987c6677a7737402d97f013050b4cd6080c3706ee656b9
-  data.tar.gz: 46e233a13a96163779eb6eca5d07687cc6fe9c7fbd3e88c81e20d2af9aa43939ddca682e1210b3d2e5cc5b1555c2660aad8cecc01d9ff45f0adc25b6d0fc9ff7
+  metadata.gz: 3b9117bf8dd677c3b7350100a7f49d8f6ec0196c07f7bffbe2115f6e6e5d5cc03d0d01418d4d1cf271a5738f08f1978336ef3282f2bcd72fc41958b125de70ac
+  data.tar.gz: 92426461df5f4825154c0afbaa75315c5b3fe25d0fa4fbe544c445bbecd69dc2d96b973e23a59263e6f055d4b636bb89034134e11c31a6db0094aebce68c2e6d

data/Cargo.lock

@@ -307,9 +307,9 @@ checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
 
 [[package]]
 name = "parsanol"
-version = "0.18.10"
+version = "0.18.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "54bbd6459639572bc085c504112bc9a4acbca47719736aebad19d9113549bdad"
+checksum = "d237b2a3835d553b0e069245741b264fd21e89c509d6c4c2c017a2013ea142e5"
 dependencies = [
  "ahash",
  "getrandom 0.3.4",
@@ -326,9 +326,9 @@ dependencies = [
 
 [[package]]
 name = "parsanol-derive"
-version = "0.18.10"
+version = "0.18.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "40adc63c6d2afcd1b095518d55f0095c5c04445f46994592161f0fa60cf6331b"
+checksum = "3125de14cee1ab1dfd0daf9307d02899f9d23c824e64b9179e4c26fc56ade9b0"
 dependencies = [
  "proc-macro2",
  "quote",

data/lib/parsanol/atoms/base.rb

@@ -236,9 +236,15 @@ module Parsanol
       end
 
       # Reports detailed error by reparsing with reporter.
+      #
+      # The default reporter is Deepest (parsanol-ruby#265): the native
+      # engine's failure diagnostics report the furthest failure, and a
+      # consumer's file:line:col degrades to "line 1 char 1" when the
+      # interpreter raises the outermost sequence instead. Explicit
+      # reporters (Tree for full cause trees) are honored unchanged.
       def report_detailed_error(input, consume_all, reporter, _initial_error)
         input.bytepos = 0
-        error_reporter = reporter || Parsanol::ErrorReporter::Tree.new
+        error_reporter = reporter || Parsanol::ErrorReporter::Deepest.new
         success, cause = run_with_context(input, error_reporter, consume_all)
 
         # Second parse should also fail

data/lib/parsanol/error_reporter/deepest.rb

@@ -98,12 +98,16 @@ module Parsanol
       # @return [Array<Integer, Parsanol::Cause>] [depth, deepest_leaf]
       #
       def find_deepest_leaf(node, rank = 0)
+        return [rank, node] if node.nil?
+
         best_node = node
         best_rank = rank
 
         kids = node.children
         if kids && !kids.empty?
           kids.each do |kid|
+            next if kid.nil?
+
             kid_rank, kid_node = find_deepest_leaf(kid, rank + 1)
 
             if kid_rank > best_rank

data/lib/parsanol/native.rb

@@ -282,8 +282,10 @@ module Parsanol
         if parsanol_grammar
           # No native diagnostics (e.g. incomplete-input errors): one
           # interpreter pass with the reporter attached — a success
-          # recovers the tree, a failure raises the cause tree.
-          reporter = Parsanol::ErrorReporter::Tree.new
+          # recovers the tree, a failure raises the cause tree. Deepest
+          # keeps the fallback's diagnostics at parity with the direct
+          # interpreter path (parsanol-ruby#265).
+          reporter = Parsanol::ErrorReporter::Deepest.new
           source = Parsanol::Source.new(input)
           success, value = grammar.run_with_context(source, reporter, true)
           return grammar.finalize_result(value) if success

data/lib/parsanol/parg/artifact.rb

@@ -165,6 +165,13 @@ module Parsanol
             case hash["kind"]
             when "reject"
               "test #{hash['input'].inspect}: expected the input to be rejected"
+            when "shape"
+              actual = Bindings.canonical(shape)
+              expected = Bindings.canonical(hash["expect"])
+              next if actual == expected
+
+              "test #{hash['input'].inspect}: expected shape #{expected.inspect}, " \
+                "got #{actual.inspect}"
             when "example"
               bound = apply_bindings(entry_name, shape)
               expect = hash["expect"].to_h { |key, value| [key.to_sym, value] }

data/lib/parsanol/parg/bindings.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "json"
+
 module Parsanol
   module PARG
     # Applies an entry's artifact bindings to a parsanol-shape parse tree,
@@ -32,6 +34,7 @@ module Parsanol
         when Hash then value.to_h { |key, item| [key.to_s, canonical(item)] }
         when Array then value.map { |item| canonical(item) }
         when nil, true, false, Integer then value
+        when Float then JSON.generate(value) # B6: the JSON number text
         else String(value)
         end
       end

data/lib/parsanol/parg/compiler.rb

@@ -53,8 +53,13 @@ module Parsanol
         @dynamic = false
         @tables = {}
         @warnings = []
+        @expanded = false
       end
 
+      # Reserved prefix for the tier rules synthesized by the direct
+      # left-recursion expansion (see expand_left_recursion!).
+      LEFT_RECURSION_PREFIX = "__left_"
+
       # QoL shorthands (ABNF core rules): materialized on reference when
       # the grammar does not define its own rule of that name.
       BUILTIN_CLASSES = {
@@ -67,6 +72,7 @@ module Parsanol
       }.freeze
 
       def compile
+        expand_left_recursion!
         @document.rules.each_key { |name| atom_for(name) }
         errors = Lints.errors(@document, self)
         raise CompileError, errors.join("\n") unless errors.empty?
@@ -121,6 +127,7 @@ module Parsanol
       end
 
       def atom_for(name)
+        expand_left_recursion! unless @expanded
         @atom_cache[name] ||= begin
           atom = build_atom(fetch_rule(name))
           # Atomic rules build without injection entirely: token-shaped
@@ -348,6 +355,106 @@ module Parsanol
       # In-file grammar tests run at compile time: the build fails when an
       # accept/example test does not parse or an example's expected capture
       # pairs do not match the bound result.
+      # Direct left recursion (owner decision 2026-10-21, parsanol-ruby#251):
+      # rewrite `r = r op1 r / r op2 r / ... / primary` into a chain of
+      # ordinary left-folding tier rules — the ANTLR 4 model. Branches in
+      # source order are precedence tiers, earlier binding tighter; the
+      # non-recursive alternatives are the primary (loosest operand). The
+      # rewritten tiers are plain rules, so every engine inherits the
+      # feature through the unchanged artifact format and the fold value is
+      # exactly the flattening of the equivalent loop grammar (V1/V3).
+      # Indirect left recursion keeps its compile error.
+      def expand_left_recursion!
+        return if @expanded
+
+        @expanded = true
+        if @document.rules.any? { |name, _| name.start_with?(LEFT_RECURSION_PREFIX) }
+          raise CompileError,
+                "rule names beginning with #{LEFT_RECURSION_PREFIX.inspect} are reserved " \
+                "for the compiler's left-recursion expansion"
+        end
+
+        # Snapshot: expansion adds tier rules to @document.rules.
+        @document.rules.dup.each_key do |name|
+          body = @document.rules[name]
+          next unless left_recursive_body?(name, body)
+
+          expand_left_recursive_rule(name, body)
+        end
+      end
+
+      def left_recursive_body?(name, body)
+        branches = body.kind == :alt ? body.a : [body]
+        branches.any? { |branch| leftmost_refs(branch, foldable: true).include?(name) }
+      end
+
+      def expand_left_recursive_rule(name, body)
+        branches = body.kind == :alt ? body.a : [body]
+        left, primary =
+          branches.partition { |branch| leftmost_refs(branch, foldable: true).include?(name) }
+        if primary.empty?
+          raise CompileError,
+                "rule #{name.inspect} is left-recursive and has no " \
+                "non-recursive alternative to anchor the rewrite"
+        end
+
+        rules = @document.rules
+        prev = "#{LEFT_RECURSION_PREFIX}#{name}_primary"
+        rules[prev] = primary.length == 1 ? primary.first : Node.new(:alt, primary)
+        left.each_with_index do |branch, index|
+          tier = "#{LEFT_RECURSION_PREFIX}#{name}_#{index + 1}"
+          suffix = left_recursive_suffix(name, branch)
+          suffix = substitute_refs(suffix, name, prev)
+          rules[tier] = Node.new(:seq, [Node.new(:ref, prev), Node.new(:rep, suffix, 0, nil)])
+          prev = tier
+        end
+        rules[name] = Node.new(:ref, prev)
+      end
+
+      # A left-recursive alternative must BEGIN with a bare reference to the
+      # rule itself; everything after that reference is the per-iteration
+      # suffix, which must consume input (a nullable suffix would loop
+      # forever at the fold).
+      def left_recursive_suffix(name, branch)
+        if branch.kind == :ref
+          raise CompileError,
+                "left-recursive alternative in rule #{name.inspect} consists only of the " \
+                "recursive reference and would loop forever"
+        end
+        unless branch.kind == :seq && (head = branch.a.first)&.kind == :ref && head.a == name
+          raise CompileError,
+                "left-recursive alternative in rule #{name.inspect} must begin with a " \
+                "bare reference to #{name.inspect} (write `#{name} <rest>`; captures and " \
+                "predicates around the leading reference are not supported)"
+        end
+
+        rest = branch.a[1..]
+        rest_node = rest.length == 1 ? rest.first : Node.new(:seq, rest)
+        if nullable?(rest_node)
+          raise CompileError,
+                "left-recursive alternative in rule #{name.inspect} can match empty after " \
+                "the leading reference and would loop forever at the fold"
+        end
+        rest_node
+      end
+
+      def substitute_refs(node, from, to)
+        if node.kind == :ref
+          return Node.new(:ref, to) if node.a == from
+
+          return node
+        end
+        case node.kind
+        when :seq then Node.new(:seq, node.a.map { |child| substitute_refs(child, from, to) })
+        when :alt then Node.new(:alt, node.a.map { |child| substitute_refs(child, from, to) })
+        when :rep then Node.new(:rep, substitute_refs(node.a, from, to), node.b, node.c)
+        when :opt then Node.new(:opt, substitute_refs(node.a, from, to))
+        when :pred then Node.new(:pred, node.a, substitute_refs(node.b, from, to), node.c)
+        when :cap then Node.new(:cap, node.a, substitute_refs(node.b, from, to))
+        else node
+        end
+      end
+
       def run_tests
         return [] if @document.tests.empty?
 
@@ -360,6 +467,13 @@ module Parsanol
             case test.kind
             when :reject
               "test #{test.input.inspect}: expected the input to be rejected"
+            when :shape
+              actual = Bindings.canonical(shape)
+              expected = Bindings.canonical(test.expect)
+              next if actual == expected
+
+              "test #{test.input.inspect}: expected shape #{expected.inspect}, " \
+                "got #{actual.inspect}"
             when :example
               bindings = binding_list(rule)
               if bindings.empty?
@@ -704,19 +818,24 @@ module Parsanol
         nil
       end
 
-      def leftmost_refs(node)
+      # A self-reference under a predicate cannot anchor a fold (and the
+      # lookbehind validation rejects rule bodies outright), so the
+      # rewrite's scan stops there; cycle detection still walks through.
+      def leftmost_refs(node, foldable: false)
         case node.kind
         when :ref then [node.a]
         when :seq
           refs = []
           node.a.each do |item|
-            refs.concat(leftmost_refs(item))
+            refs.concat(leftmost_refs(item, foldable: foldable))
             break unless nullable?(item)
           end
           refs.uniq
-        when :alt then node.a.flat_map { |branch| leftmost_refs(branch) }.uniq
-        when :rep, :opt then leftmost_refs(node.a)
-        when :pred, :cap then leftmost_refs(node.b)
+        when :alt then node.a.flat_map { |branch| leftmost_refs(branch, foldable: foldable) }.uniq
+        when :rep, :opt then leftmost_refs(node.a, foldable: foldable)
+        when :pred
+          foldable ? [] : leftmost_refs(node.b)
+        when :cap then leftmost_refs(node.b, foldable: foldable)
         else []
         end
       end
@@ -790,6 +909,17 @@ module Parsanol
 
       # ---- artifact envelope ----------------------------------------------
 
+      # Test expectations are JSON-shaped: pair expectations are maps with
+      # symbol keys; `shape` expectations may be any value. Normalize keys
+      # recursively so the envelope is plain JSON.
+      def normalize_expect(value)
+        case value
+        when Hash then value.to_h { |key, item| [key.to_s, normalize_expect(item)] }
+        when Array then value.map { |item| normalize_expect(item) }
+        else value
+        end
+      end
+
       def build_envelope
         entries = @document.entries.to_h do |name, rule|
           [name, entry_envelope(rule)]
@@ -819,7 +949,7 @@ module Parsanol
               "entry" => test.entry || (@document.own_entries.first if @document.own_entries.size == 1),
               "kind" => test.kind.to_s,
               "input" => test.input,
-              "expect" => test.expect.transform_keys(&:to_s),
+              "expect" => normalize_expect(test.expect),
             }
           end,
           "docs" => @document.docs,

data/lib/parsanol/parg/document.rb

@@ -11,7 +11,7 @@ module Parsanol
       # `capture` = phase 1 (grammar layer): asserts the raw capture tree,
       # no bindings section needed. `example` = phase 2 (bindings layer):
       # asserts the bound, preprocessed attribute hash.
-      TEST_KINDS = %i[accept reject example capture].freeze
+      TEST_KINDS = %i[accept reject example capture shape].freeze
       # Test kinds whose expectations are `{ key: value }` pairs.
       PAIR_KINDS = %w[example capture].freeze
 

data/lib/parsanol/parg/parser.rb

@@ -83,7 +83,12 @@ module Parsanol
           kind = ident.value
           input = unquote(expect(:str).value)
           expect_pairs = {}
-          if Document::PAIR_KINDS.include?(kind) && peek&.type == :punct && peek.value == "{"
+          if kind == "shape"
+            # Whole-tree assertion: the expectation is an arbitrary value
+            # (text, array, object), not a capture-name map.
+            expect_pairs = parse_test_value
+          elsif Document::PAIR_KINDS.include?(kind) &&
+              peek&.type == :punct && peek.value == "{"
             advance
             skip_newlines
             until peek&.type == :punct && peek.value == "}"

data/lib/parsanol/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Parsanol
-  VERSION = "1.3.98"
+  VERSION = "1.3.100"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: parsanol
 version: !ruby/object:Gem::Version
-  version: 1.3.98
+  version: 1.3.100
 platform: ruby
 authors:
 - Ribose Inc.