parsanol 1.3.92-aarch64-linux → 1.3.94-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d97e0ef9b1ba9281cfce8b847384654d3420fdc8c0ad4fbd0284af5a35522653
-  data.tar.gz: 9836bdd4bf811c8bc7ef99820e0b0c96a088bfbf33cbf52749ffdf3adb4aa2f3
+  metadata.gz: 9e0c1efcdfb93af513ae908d45c90b6f2d6c42015fb643e474bffbb37ae39316
+  data.tar.gz: 86ad51bce683affc8b5b94426151bf56694c41fa87b91c9e56c98b7e801c1efc
 SHA512:
-  metadata.gz: f0d8078fe690e009410e0c54268468370fe7897007cdbb261de6bca40f64301b1fb45a098f41beffe7beb3bfba1be2fbe0533864484e063d89081ebee4d0f791
-  data.tar.gz: 37346c31aeb72a9e5ca78fbee2135a43d10414134644633b8b224414a6eca32e162292d81bd8b9009dd91e9806617a72365d68681e670699c5f46b9f7b329086
+  metadata.gz: 1b5aea575e016166e39822daa41c36c9ef80da76c121610231c6c359071d31362f4e5ed0efd24b4278d8db896ff70f7702e71cbfdf5d4ff4e2f36469222e5085
+  data.tar.gz: b89fe36dabaa496b63c7bb220bd5c40c5698fbc3ecac8329359d53d2319ec56df283accc410e15fcfe14d8e0729cbfd876e58c6de382079ce716f1f94e795725

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: 40176952 bytes
-sha256: 58f5e7bcb9c7665ab38daba62f63533a89966dbe2b9e2d8c56d2c37bd7afeb37
+size: 40550656 bytes
+sha256: cff224d02b36baf6455b961827d069556a7fed497e0a8e778009065f12613f00

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: 40412064 bytes
-sha256: c2b4e8331d61feecb2146feb05047ff9b20da8543910429eb87c3111b6a871ed
+size: 40785744 bytes
+sha256: ae67525c0f460813aed0b9fccb58809b517da84d72dae383bc232bd3c0c5d4f0

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: 40403520 bytes
-sha256: 35be9d4c9905ab8a9d0fcce4c55d7909850b093d1065cf658f131a2081f9ca31
+size: 40781360 bytes
+sha256: e30f6696ef7f343f3edf49240039e9287277f6973d4e0bfee918939d82684056

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: 40413544 bytes
-sha256: 62c8e268e3990442aa746edfd13a0d24bc2fe40cbd58db8a845c7dfb67efdab0
+size: 40791392 bytes
+sha256: 2f8c4e6eb46bc01f1271aeb19e5b3beb3b1c81ce1deb99b500094fabf3b11517

data/lib/parsanol/native/libparsanol.so

@@ -1,4 +1,4 @@
 [diffend] Oversized file quarantined before diffing.
 name: data/lib/parsanol/native/libparsanol.so
-size: 35960704 bytes
-sha256: 579c6ce133fca3eec741131db52977ea97348767e59d3cb1c8e0149dc6f1bb91
+size: 36352992 bytes
+sha256: fc4e4581f2ff40db6d747bd6b6377e34da0d7389eccc7b1ecb30f485f2e59e25

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

@@ -152,21 +152,42 @@ module Parsanol
 
       # Run an external test list (suite files yield Document::Test
       # structs; embedded tests are artifact-shaped hashes).
-      def run_test_list(tests, mode: :native)
+      # parse_with overrides how the input is turned into a shape
+      # (the envelope self-test drives the baked grammar JSON natively
+      # instead of root_atom's source rebuild); bindings and
+      # expectations still flow through the standard surface.
+      def run_test_list(tests, mode: :native, parse_with: nil)
         tests.filter_map do |test|
           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_with ? parse_with.call(hash["input"]) : 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

@@ -76,9 +76,40 @@ module Parsanol
         raise CompileError, failures.join("\n") unless failures.empty?
 
         envelope = build_envelope
+        failures = self.class.self_test(envelope, tables_dir: @tables_dir)
+        raise CompileError, failures.join("\n") unless failures.empty?
+
         Result.new(@atom_cache, @warnings, envelope)
       end
 
+      # Bake-time self-test (parsanol-ruby#223): replay the grammar's
+      # embedded tests against the BAKED ENVELOPE atom JSON, not the
+      # source this process just compiled. A bake that drops or
+      # rewrites a member (the 1.3.91 ordered-choice class) makes the
+      # envelope disagree with its own tests, and every Ruby-side
+      # parse path would mask it — root_atom rebuilds from the
+      # embedded source, so only the native engine's JSON registration
+      # executes the atom graph a wasm/rs consumer actually runs.
+      # Skips (empty) when the native engine is unavailable; the CI
+      # and release bakes always have it. Returns failure descriptions.
+      def self.self_test(envelope, tables_dir: nil)
+        tests = envelope["tests"].to_a
+        return [] if tests.empty?
+        return [] unless Native.available?
+
+        artifact = Artifact.from_json(JSON.generate(envelope), tables_dir: tables_dir)
+        default = envelope["default_entry"] || artifact.entries.first
+        grammars = {}
+        tests.filter_map do |test|
+          entry = test["entry"] || default
+          grammar_json = (grammars[entry] ||= JSON.generate(artifact.entry(entry)["grammar"]))
+          artifact.run_test_list(
+            [test],
+            parse_with: ->(input) { Native.parse_json_grammar(grammar_json, input) },
+          )
+        end.flatten
+      end
+
       def resolve_custom(name)
         class_name = @document.customs.fetch(name)
         klass = Object.const_get(class_name)
@@ -314,22 +345,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 +391,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.94"
 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.94
 platform: aarch64-linux
 authors:
 - Ribose Inc.
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2026-10-15 00:00:00.000000000 Z
+date: 2026-10-18 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