parsanol 1.3.92-arm-linux → 1.3.93-arm-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 94ab60f4150519a940dd2084dcc399fe2e2691c94865d0673c128ef13e551e6c
-  data.tar.gz: f032f98ca251fbbff68a71dce5b143a64602b9956b91d5ab3da97b0cbccb8310
+  metadata.gz: 38e6903eee4c564df8586705d284a07671cbf0935ed4c7641e8b44015c4c510e
+  data.tar.gz: c6f1c81c282193fd596386c717e756aa35d87ffd22d5c3c1554ba3b09d4e0e02
 SHA512:
-  metadata.gz: f4f5e09e4f5e30fb52b3704e1348341ee2bdfab777392acdd11f98fce87e8aa0d9f69992abce1ecb137856857cac9d0d68b84717470db9235fb736e599bb54fe
-  data.tar.gz: 7d14b295b9e53af62f279c4c66201a492e5cf5b57a550077d69d2d40355d55b65e107e6c0b35b71d3e1ccb8b31231a4fc598c6da3228ef27fbeada7a08a9965d
+  metadata.gz: 94c5b1eb30a297566ca23877a53b1d63be7cff2fa04a92084fb1e9ff0102b238723fba755469daadb5d38b2113638cf0a02697f06a65671d04e631b2bd8647bf
+  data.tar.gz: ce29e977d953b08817a2f425f86090d4272cde2fc41e29d0d68b90571765e01951cdd3b90242671d0e9de018bc36f3aa8e52fc5359e5578a7b0ce8bd14554cab

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: 34018692 bytes
-sha256: 73a0d5df2c8be448527b97be77cf17d2d32406a6fa95bad552ac33c93a3f53de
+size: 34333284 bytes
+sha256: 46c18a5ba0af8926c012eb98c6417dfca64931a837629b317fb7c3cc430b9085

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: 34203972 bytes
-sha256: c076da7d2462c80cffdaa4fee81a97622f90fd996cddc885ed0c1947bda237f4
+size: 34518452 bytes
+sha256: 0752c79e340c4c722b106443ff1faf6ff6d6d7c5800570906d1c548585e06a58

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: 34198132 bytes
-sha256: 42ec5b96bfe8efb05a8377c9ae8410635f8916e9e3ea84e2f9e6a8d741159b58
+size: 34512620 bytes
+sha256: 9b0744875d02d5c1957b82cdf9249129ce62214696606b84886609243342e23f

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: 34207868 bytes
-sha256: 56addd9fe8da96b569b0e50b2b30a1a28c382ce12cc035a0debf42d7679d197e
+size: 34522276 bytes
+sha256: 834bad07a21ef4ccaeb47fbfaf85c567866142fb141f6d93205d5d9958e0c2f2

data/lib/parsanol/native/parser.rb

@@ -167,59 +167,58 @@ module Parsanol
         end
 
         def grammar_structure_hash(atom)
-          Digest::MD5.hexdigest(atom_structure(atom).to_s)
+          Digest::MD5.hexdigest(append_atom_structure(atom))
         end
 
-        def atom_structure(atom, visited = {})
-          # Cycle detection - return a placeholder if we've seen this atom before
-          obj_id = atom.object_id
-          if visited[obj_id]
-            return [:cycle, atom.class.name]
+        def append_atom_structure(atom, visited = {}.compare_by_identity, output = +"")
+          if visited[atom]
+            return output << "[:cycle, " << atom.class.name.inspect << "]"
           end
 
-          visited[obj_id] = true
-
+          visited[atom] = true
           case atom
-          when ::Parsanol::Atoms::Entity
-            # Recursively resolve entity to get actual structure for hash
-            atom_structure(atom.parslet, visited)
-          when ::Parsanol::Atoms::Str
-            [:str, atom.str]
-          when ::Parsanol::Atoms::Re
-            [:re, atom.match]
-          when ::Parsanol::Atoms::Sequence
-            [:seq, atom.parslets.map { |p| atom_structure(p, visited) }]
-          when ::Parsanol::Atoms::Alternative
-            [:alt, atom.alternatives.map { |p| atom_structure(p, visited) }]
-          when ::Parsanol::Atoms::Repetition
-            [:rep, atom.min, atom.max, atom_structure(atom.parslet, visited)]
-          when ::Parsanol::Atoms::Named
-            [:named, atom.name.to_s, atom_structure(atom.parslet, visited)]
-          when ::Parsanol::Atoms::Lookahead
-            [:lookahead, atom.positive,
-             atom_structure(atom.bound_parslet, visited)]
-          when ::Parsanol::Atoms::Constant
-            # The value differentiates otherwise-identical constant
-            # atoms — without it every Constant hashes alike and the
-            # grammar cache serves the first wire forever.
-            [:constant, atom.value.inspect]
-          when ::Parsanol::Atoms::Lookbehind
-            [:lookbehind, atom.count, atom.pattern, atom.positive]
-          # Subclass first: TriviaCapture < Trivia < Ignored (the same
-          # dispatch discipline as the serializer's).
-          when ::Parsanol::Atoms::TriviaCapture
-            # The capturer table differentiates capture-carrying
-            # grammars from plain-trivia ones — without it the grammar
-            # cache serves one variant's wire to every other and the
-            # wrong marker table reaches the engine (parsanol-ruby#180).
-            [:trivia_capture, atom.capturers.to_a.sort,
-             atom_structure(atom.wrapped_atom, visited)]
-          when ::Parsanol::Atoms::Trivia
-            [:trivia, atom_structure(atom.wrapped_atom, visited)]
-          when ::Parsanol::Atoms::Ignored
-            [:ignored, atom_structure(atom.wrapped_atom, visited)]
+          when Parsanol::Atoms::Entity
+            append_atom_structure(atom.parslet, visited, output)
+          when Parsanol::Atoms::Str
+            output << "[:str, " << atom.str.inspect << "]"
+          when Parsanol::Atoms::Re
+            output << "[:re, " << atom.match.inspect << "]"
+          when Parsanol::Atoms::Sequence, Parsanol::Atoms::Alternative
+            children = atom.is_a?(Parsanol::Atoms::Sequence) ? atom.parslets : atom.alternatives
+            output << (atom.is_a?(Parsanol::Atoms::Sequence) ? "[:seq, [" : "[:alt, [")
+            index = 0
+            while index < children.length
+              output << ", " unless index.zero?
+              append_atom_structure(children[index], visited, output)
+              index += 1
+            end
+            output << "]]"
+          when Parsanol::Atoms::Repetition
+            output << "[:rep, " << atom.min.inspect << ", " << atom.max.inspect << ", "
+            append_atom_structure(atom.parslet, visited, output) << "]"
+          when Parsanol::Atoms::Named
+            output << "[:named, " << atom.name.to_s.inspect << ", "
+            append_atom_structure(atom.parslet, visited, output) << "]"
+          when Parsanol::Atoms::Lookahead
+            output << "[:lookahead, " << atom.positive.inspect << ", "
+            append_atom_structure(atom.bound_parslet, visited, output) << "]"
+          when Parsanol::Atoms::Constant
+            # The inspected constant remains a string inside the fingerprint.
+            output << "[:constant, " << atom.value.inspect.inspect << "]"
+          when Parsanol::Atoms::Lookbehind
+            output << "[:lookbehind, " << atom.count.inspect << ", " << atom.pattern.inspect << ", " << atom.positive.inspect << "]"
+          # Capturing trivia must precede its Trivia and Ignored parents.
+          when Parsanol::Atoms::TriviaCapture
+            output << "[:trivia_capture, " << atom.capturers.to_a.sort.inspect << ", "
+            append_atom_structure(atom.wrapped_atom, visited, output) << "]"
+          when Parsanol::Atoms::Trivia
+            output << "[:trivia, "
+            append_atom_structure(atom.wrapped_atom, visited, output) << "]"
+          when Parsanol::Atoms::Ignored
+            output << "[:ignored, "
+            append_atom_structure(atom.wrapped_atom, visited, output) << "]"
           else
-            [:unknown, atom.class.name]
+            output << "[:unknown, " << atom.class.name.inspect << "]"
           end
         end
       end

data/lib/parsanol/parg/artifact.rb

@@ -157,16 +157,33 @@ module Parsanol
           hash = test.is_a?(Document::Test) ? test_to_hash(test) : test
           entry_name = hash["entry"] || entries.first
           begin
-            bound = parse_and_bind(entry_name, hash["input"], mode: mode)
-            if hash["kind"] == "reject"
+            shape = parse(entry_name, hash["input"], mode: mode)
+            case hash["kind"]
+            when "reject"
               "test #{hash['input'].inspect}: expected the input to be rejected"
-            elsif hash["kind"] == "example"
+            when "example"
+              bound = apply_bindings(entry_name, shape)
               expect = hash["expect"].to_h { |key, value| [key.to_sym, value] }
-              mismatched = expect.reject { |key, value| bound.key?(key) && bound[key] == value }
+              mismatched = expect.reject do |key, value|
+                bound.key?(key) && Bindings.canonical(bound[key]) == Bindings.canonical(value)
+              end
               next if mismatched.empty?
 
               "test #{hash['input'].inspect}: expected captures " \
                 "#{mismatched.transform_values(&:inspect).inspect}, got #{bound.inspect}"
+            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)
+              end
+              next if mismatched.empty?
+
+              actuals = mismatched.keys.to_h do |key|
+                [key, Bindings.canonical(captures[key.to_sym]&.first)]
+              end
+              "test #{hash['input'].inspect}: expected captures " \
+                "#{mismatched.transform_values(&:inspect).inspect}, got #{actuals.inspect}"
             end
           rescue Parsanol::ParseFailed
             unless hash["kind"] == "reject"

data/lib/parsanol/parg/bindings.rb

@@ -23,6 +23,19 @@ module Parsanol
         out
       end
 
+      # Canonical test-value form: one equality surface for capture and
+      # example expectations on both sides of the comparison (Slice vs
+      # source literal was comparing heterogeneous types). Terminals
+      # reduce to their text; structure recurses; keys stringify.
+      def canonical(value)
+        case value
+        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
+        else String(value)
+        end
+      end
+
       def collect_captures(shape)
         found = Hash.new { |hash, key| hash[key] = [] }
         queue = [shape]

data/lib/parsanol/parg/compiler.rb

@@ -314,22 +314,43 @@ module Parsanol
       def run_tests
         return [] if @document.tests.empty?
 
-        default_entry = resolve_default_entry
         view = test_view
         @document.tests.filter_map do |test|
           entry_name = test.entry || default_entry
           rule = @document.entries.fetch(entry_name)
           begin
             shape = atom_for(rule).parse(test.input)
-            if test.kind == :reject
+            case test.kind
+            when :reject
               "test #{test.input.inspect}: expected the input to be rejected"
-            elsif test.kind == :example
-              bound = Bindings.apply(view, { "bindings" => binding_list(rule) }, shape)
-              mismatched = test.expect.reject { |key, value| bound.key?(key) && bound[key] == value }
+            when :example
+              bindings = binding_list(rule)
+              if bindings.empty?
+                raise CompileError,
+                      "example tests need a bindings section (use `capture` " \
+                      "for raw-capture assertions)"
+              end
+              bound = Bindings.apply(view, { "bindings" => bindings }, shape)
+              mismatched = test.expect.reject do |key, value|
+                bound.key?(key) && Bindings.canonical(bound[key]) == Bindings.canonical(value)
+              end
               next if mismatched.empty?
 
               "test #{test.input.inspect}: expected captures " \
                 "#{mismatched.transform_values(&:inspect).inspect}, got #{bound.inspect}"
+            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)
+              end
+              next if mismatched.empty?
+
+              actuals = mismatched.keys.to_h do |key|
+                [key, Bindings.canonical(captures[key.to_sym]&.first)]
+              end
+              "test #{test.input.inspect}: expected captures " \
+                "#{mismatched.transform_values(&:inspect).inspect}, got #{actuals.inspect}"
             end
           rescue Parsanol::ParseFailed
             unless test.kind == :reject
@@ -339,6 +360,13 @@ module Parsanol
         end
       end
 
+      # Only consulted when a test omits its entry: a multi-entry
+      # grammar whose tests are all explicit must compile (parsanol-
+      # ruby#216). Memoized so the raise happens once, on first need.
+      def default_entry
+        @default_entry ||= resolve_default_entry
+      end
+
       def resolve_default_entry
         own = @document.own_entries
         return own.first if own && own.size == 1

data/lib/parsanol/parg/document.rb

@@ -5,7 +5,15 @@ module Parsanol
     # Parsed PARG document: grammar rules plus the binding sections.
     class Document
       Binding = Struct.new(:capture, :path, :type, :card, :preprocess)
-      TEST_KINDS = %i[accept reject example].freeze
+      # `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.
+      # `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 whose expectations are `{ key: value }` pairs.
+      PAIR_KINDS = %w[example capture].freeze
 
       Test = Struct.new(:entry, :kind, :input, :expect)
 

data/lib/parsanol/parg/parser.rb

@@ -83,7 +83,7 @@ module Parsanol
           kind = ident.value
           input = unquote(expect(:str).value)
           expect_pairs = {}
-          if kind == "example" && peek&.type == :punct && peek.value == "{"
+          if 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.92"
+  VERSION = "1.3.93"
 end

data/lib/parsanol/vm.rb

@@ -146,7 +146,12 @@ module Parsanol
           # The shared program's compile-time analysis (heavy-memo
           # seeding) covered this structure; the fresh root inherits
           # it so its first parse memoizes like the original's.
-          (@heavy ||= {}.compare_by_identity)[root] = true if @heavy_by_hash&.[](hash_key)
+          if @heavy_by_hash&.[](hash_key)
+            (@heavy ||= {}.compare_by_identity)[root] = true
+            trim_cache(@heavy)
+          end
+          cache[root] = shared
+          trim_cache(cache)
           return shared
         end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: parsanol
 version: !ruby/object:Gem::Version
-  version: 1.3.92
+  version: 1.3.93
 platform: arm-linux
 authors:
 - Ribose Inc.
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2026-10-15 00:00:00.000000000 Z
+date: 2026-10-16 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