parsanol 1.3.97-arm-linux → 1.3.99-arm-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ba796c36445f5830ba53adb2d9d6c7423144702135b2fe6dbe999cc3b48ec02d
-  data.tar.gz: 1cbe38d5b55134e7a5e1e5b1fa0205fe486704e63b5d1b6513c4a28336abe122
+  metadata.gz: '0449928649d5a003cea029230dccdb8d4a1cf5e15a3115d713396f256e5a4cbf'
+  data.tar.gz: 6f78bd36cb506e26a808d16d0e82cab33d1d4af239ff2850247b9ff29925e51a
 SHA512:
-  metadata.gz: 9c5e89505e328023fd10183fb5fae55147b07a549c5e263507e44e86d4521f58bb0b853e28cb83a000f1e07de3e637c2f074402baffd0b7c8236839514c4b55d
-  data.tar.gz: 6080805a38b9c604012a4bcc44954816eb16e59b7eefeb1fcbd269bbdff9a2d04ec69c2a4f266761ae45a75df5fbd1f7fa6fd8b6b8cc735d52a7e58524938a49
+  metadata.gz: dc51f046f4d0e11b562f8dc35d37eed3476cb6d6bc77f0692d5363b87a8707444f04f4416a1dfef85db1a6e3dbb551f3477145831e2daa1cf21159646c086ef6
+  data.tar.gz: 02bcffde2c4565099de61ffc31de674f24c244bbb1ac2bb5820ae5c4636d780f775ce092f57c64c2d8a47706a275899e7ea4358ffe26a93ee6b204a7b9609859

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: 34469476 bytes
-sha256: 7aafcff9614529975999b15cff2a3e73ae9a85afcabe8f9e58c13038cab73a23
+size: 34547268 bytes
+sha256: 5ffe08395738b583a3472e832256ff294510921a25ff6e53dc90c951905191ec

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: 34654656 bytes
-sha256: fa31365628d79247b120a2c0a354730afefdab03fe0d4562571887317a919dcd
+size: 34732408 bytes
+sha256: c187d2bd208b1d8aef9c66f4d3188496789e48b93dc6fb59c65cbbfcd300a6ca

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: 34648844 bytes
-sha256: d5fce27c9af76ff94d7a28b4ac70ac36cb39ede3a5f1c3ece385a07fb238e233
+size: 34726616 bytes
+sha256: 14dcfeb7a0bad418583ac54f7430c5212c273c5df0a3e0ae3eaba8ed14156907

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: 34658520 bytes
-sha256: 0de52572076fa045d63465d34b4aaa245ff76291e742820ae58769f71fa14866
+size: 34736332 bytes
+sha256: 8eb3b9649e9070ee5ec045863c45cdc50a4ae76faf0c0c45fa6f26f15e503db4

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: arm-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