parsanol 1.3.98-aarch64-linux → 1.3.100-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 59eaaf30f6cc627ef3dc9e80b8e33ac3b2c3d8855e699848a7b730fef8569016
-  data.tar.gz: 45ed8be2284f602b832849f17ac00ee8f4fa19b8e6cf7d7bd081c3aa2b68a954
+  metadata.gz: ffe9cf736fae27a11f941c38eaa1ec8f5ad6a67af74a81952d6a2a39478cd69d
+  data.tar.gz: 5a35dd607a8ca943fb12da09ce8f90a6e9c15efaddb589e3861ab6b71ed646f6
 SHA512:
-  metadata.gz: 9bed617e17bee7ef49a9abbe7df5640dc1c7cdea910fbcaf8da7c1ea215b47f7f9a4939e080484b4ed403c474723a4750ec4240d1e80e5eae225dad464869559
-  data.tar.gz: c31194ecf89c3d809a1166a92b497103da9ce0ebe06d86a39bb6736a09eb7626681a2aa643d3ee47232c407602410cbe1314cb516a6b2eacc56b1a9a2a36491c
+  metadata.gz: 4426f5e8c9a6073f95582e6ffbaec7d3efdd4b2cea1525db7cadc6baf1b64b4394ff1da62758b72b171c86a4d9134c09b0b104f408f35ec871b7eeaead0853d6
+  data.tar.gz: 8196495a9b452106dd4f1ef500b16e5dedadb06984b605629ae473051af4a4fb18a79fbe53b04f8c325f6c6f9142b904d6ee34b51d5e10e2c0bb1546d2841d11

data/lib/parsanol/3.2/parsanol_native.so

@@ -1,4 +1,4 @@
 [diffend] Oversized file quarantined before diffing.
 name: data/lib/parsanol/3.2/parsanol_native.so
-size: 40739648 bytes
-sha256: 25301e0ded598dd4a79bdce7a3b30ec4f4666b4d14850d15ec33fb03437d925f
+size: 40823664 bytes
+sha256: 74eadd193ef8d65d50ee57835773ce7c815f6ce9ce795ffebb039c2db1fb1292

data/lib/parsanol/3.3/parsanol_native.so

@@ -1,4 +1,4 @@
 [diffend] Oversized file quarantined before diffing.
 name: data/lib/parsanol/3.3/parsanol_native.so
-size: 40974736 bytes
-sha256: 713b7c4b9a55b2da5e65f05c40a5f0fa132de7ad23cf2db1ef4b8b2efba56c11
+size: 41058696 bytes
+sha256: b6a5f7b526422c4766de9b1d45eaa82c99cf59c7fa330aa2af832b607a2f71f8

data/lib/parsanol/3.4/parsanol_native.so

@@ -1,4 +1,4 @@
 [diffend] Oversized file quarantined before diffing.
 name: data/lib/parsanol/3.4/parsanol_native.so
-size: 40966176 bytes
-sha256: 84d2b4d7e0700e410ad8d95f68d4c2bf29354de1e28faf55a38bbb20ae0b5668
+size: 41054344 bytes
+sha256: 1c95bcd0337a6961284fed89522e1a446cc90e21369a2994a5f62414c98ccf85

data/lib/parsanol/4.0/parsanol_native.so

@@ -1,4 +1,4 @@
 [diffend] Oversized file quarantined before diffing.
 name: data/lib/parsanol/4.0/parsanol_native.so
-size: 40976224 bytes
-sha256: 30615ee206ca278c00f2cb8ffb4deae4e74e3f4aed2afb3dcae40a84a22af494
+size: 41064400 bytes
+sha256: 3921a83255cd10483c05b9d8c65d170d4dce6379aee2415adc56b85c3dabdf77

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/libparsanol.so

@@ -1,4 +1,4 @@
 [diffend] Oversized file quarantined before diffing.
 name: data/lib/parsanol/native/libparsanol.so
-size: 36519752 bytes
-sha256: 88291bd6f470adb9d6057e726f14c108c3336b5a053597bb51b444a9327fc7ba
+size: 36611864 bytes
+sha256: db77c7d151957854ca658a95d3edbf03bbf0df6032a9f16779b57816b2c83068

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,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: parsanol
 version: !ruby/object:Gem::Version
-  version: 1.3.98
+  version: 1.3.100
 platform: aarch64-linux
 authors:
 - Ribose Inc.
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2026-10-20 00:00:00.000000000 Z
+date: 2026-10-21 00:00:00.000000000 Z
 dependencies: []
 description: A small Ruby library for constructing parsers in the PEG (Parsing Expression
   Grammar) fashion. Parsanol provides Parslet-compatible API with additional features