parsanol 1.3.97-aarch64-linux → 1.3.99-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f259ea55092d5673e2d9b3604df6fb9adba3807dba48500b765562de3b1b6aee
-  data.tar.gz: d6c1ba491efa08d1ccc551d79899558577c72138909a17d46a39560ca818b80a
+  metadata.gz: e06421f8e5c544c7b5075efef008185c9fa67abaa6aa30e74c1f829f3778bd5b
+  data.tar.gz: 56f37f201e95b55f636feb91bde17721f83d7b5f2ea83e25305654a568cf2344
 SHA512:
-  metadata.gz: 066d798f2dc0b057a46db9f077aee2e0d4a424b076c836cce9152ef1d969b2f3d587b0071ed9f1b3524a0534c223aa9cd58b2d43d8511ec58eb8d867438a8fd9
-  data.tar.gz: 8bce87d1b44af2a4ec860b5a1072837bda1ac171a6aee8d1fd1dd505cac84a3ae84f7529f413430014de1dd902ce69197d2c8f9ae6cb16c465591d520a36af37
+  metadata.gz: 917dbbb4c00e3ac7e3ee1ba9bdf223200f5f4bec1f926e9019ce952b3e70b2063793c12afc71c846b38ba5441b526629acd50db20e8b93b93f6de1a7fa6da06c
+  data.tar.gz: 434bc70187d37e1c927652952ff88030b0db72485f8e90c9baa837725a2bb75fa0a804a7423bf40cbe9f8eacfde19045bdadb669492f302eb16cf492a23af375

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: 40739336 bytes
-sha256: 4cad7bf4894a1cea08ee2b319696f166f2e7cc38ed6eef38dee79057f9fd684a
+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: 40974392 bytes
-sha256: 25df57a50ccd92bd51baaf86008559487f4259b81a899c30c61e8e023ff7ec23
+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: 40961728 bytes
-sha256: e6e8cae20b2ffc4754570fd4e4e19081e24e4b5c37ccc0e122619ada30ca7d97
+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: 40971784 bytes
-sha256: 4c426cf8bfd77fb270f32e171664208d9b3fd3414bcf22b2d677fddc2ec14e9f
+size: 41064400 bytes
+sha256: 3921a83255cd10483c05b9d8c65d170d4dce6379aee2415adc56b85c3dabdf77

data/lib/parsanol/native/libparsanol.so

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

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] }
@@ -178,8 +185,9 @@ module Parsanol
             when "capture"
               captures = Bindings.collect_captures(shape)
               mismatched = hash["expect"].reject do |key, value|
-                actual = captures[key.to_sym]&.first
-                !actual.nil? && Bindings.canonical(actual) == Bindings.canonical(value)
+                values = captures[key.to_sym]
+                values && !values.empty? &&
+                  Bindings.canonical(values.first) == Bindings.canonical(value)
               end
               next if mismatched.empty?
 

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
@@ -64,7 +67,9 @@ module Parsanol
         count = group.map { |binding| captures[binding["capture"].to_sym].length }.max || 0
         return if count.zero?
 
-        list = (out[prefix] ||= [])
+        # Field names are symbols everywhere else (scalar bindings, element
+        # fields); the array prefix must match or `example` lookups miss it.
+        list = (out[prefix.to_sym] ||= [])
         count.times do |index|
           element = {}
           group.each do |binding|

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?
@@ -378,8 +492,9 @@ module Parsanol
             when :capture
               captures = Bindings.collect_captures(shape)
               mismatched = test.expect.reject do |key, value|
-                actual = captures[key.to_sym]&.first
-                !actual.nil? && Bindings.canonical(actual) == Bindings.canonical(value)
+                values = captures[key.to_sym]
+                values && !values.empty? &&
+                  Bindings.canonical(values.first) == Bindings.canonical(value)
               end
               next if mismatched.empty?
 
@@ -703,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
@@ -789,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)]
@@ -818,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/lexer.rb

@@ -23,7 +23,7 @@ module Parsanol
       | (?<arrow>->)
       | (?<num>\d+)
       | (?<ident>[A-Za-z_][A-Za-z0-9_]*)
-      | (?<punct>[=\/()\[\]{}*!&:,.<])
+      | (?<punct>[=\/()\[\]{}*!&:,.<-])
       /x
 
       def initialize(text)

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 == "}"
@@ -91,6 +96,8 @@ module Parsanol
               punct(":")
               expect_pairs[key.to_sym] = parse_test_value
               skip_newlines
+              advance if peek&.type == :punct && peek.value == ","
+              skip_newlines
             end
             punct("}")
           end
@@ -101,18 +108,84 @@ module Parsanol
         skip_newlines
       end
 
+      # Expectation values: strings, numbers, true/false/null, arrays, and
+      # nested objects. Nested structure is what pins array bindings,
+      # absent-optional nil, and flatten/merge results in the corpus;
+      # before this the test grammar only accepted scalars.
       def parse_test_value
-        token = advance
+        token = peek
         case token&.type
-        when :str then unquote(token.value)
-        when :num then token.value.to_i
-        when :ident
-          raise ParseError, "expected true or false" unless %w[true false].include?(token.value)
+        when :str then unquote(advance.value)
+        when :num then parse_test_number
+        when :punct
+          case token.value
+          when "[" then parse_test_array
+          when "{" then parse_test_object
+          when "-"
+            advance
+            unless peek&.type == :num
+              raise ParseError, "expected a number after '-' in a test value"
+            end
 
-          token.value == "true"
+            -parse_test_number
+          else
+            raise ParseError,
+                  "expected a test value (string, number, true, false, null, array, object)"
+          end
+        when :ident
+          advance
+          case token.value
+          when "true" then true
+          when "false" then false
+          when "null" then nil
+          else
+            raise ParseError,
+                  "expected true, false, or null, got #{token.value.inspect}"
+          end
         else
-          raise ParseError, "expected a string, number, true or false"
+          raise ParseError,
+                "expected a test value (string, number, true, false, null, array, object)"
+        end
+      end
+
+      # The lexer emits integers only; a decimal is num "." num.
+      def parse_test_number
+        text = advance.value
+        if peek&.type == :punct && peek.value == "." && @tokens[@pos + 1]&.type == :num
+          advance
+          text = "#{text}.#{advance.value}"
         end
+        text.include?(".") ? Float(text) : Integer(text, 10)
+      end
+
+      def parse_test_array
+        punct("[")
+        values = []
+        skip_newlines
+        until peek&.type == :punct && peek.value == "]"
+          values << parse_test_value
+          skip_newlines
+          advance if peek&.type == :punct && peek.value == ","
+          skip_newlines
+        end
+        punct("]")
+        values
+      end
+
+      def parse_test_object
+        punct("{")
+        value = {}
+        skip_newlines
+        until peek&.type == :punct && peek.value == "}"
+          key = ident.value
+          punct(":")
+          value[key.to_sym] = parse_test_value
+          skip_newlines
+          advance if peek&.type == :punct && peek.value == ","
+          skip_newlines
+        end
+        punct("}")
+        value
       end
 
       def eof? = @pos >= @tokens.length

data/lib/parsanol/parg/selfhost.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "json"
+
 module Parsanol
   module PARG
     # F10 phase 2 (gate slice): every .parg source must parse under the parg

data/lib/parsanol/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: parsanol
 version: !ruby/object:Gem::Version
-  version: 1.3.97
+  version: 1.3.99
 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