parsanol 1.3.92 → 1.3.93

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 11b0c549ac99782284291222059dfe02d3281a83a8fe854967cee08266846bbd
-  data.tar.gz: 06f587dfe6a5cfe5981ac12c432729560dcdd8501a2fa91936c28be9fb0c401f
+  metadata.gz: f7081ebdd8fe55e2b6144cb065f5d3dc082fc190be716f63938389d79b8ade40
+  data.tar.gz: cd656fbeaefe6990a5561496ec4bcf4fce282aec0339bd0a2152dcbfa4d2cd70
 SHA512:
-  metadata.gz: a8d385dae7c5100df8012111dd75da2e2bed6ba93689849ec505259c65ab69f3c41eeb37112c5ec8e4ba44feca7503985d04fe494295ff0844f1a3bf4bd4605b
-  data.tar.gz: af78fe7842a3c7b25b3ad17718e95c2d5dbcea3a2fb23f8b26d63d55ca095188f75c911459eafb8866fcf7545c11853f8680ff4898db85cbaed4f57e85763f1d
+  metadata.gz: bf4c27ab92936b01428a5c0367999049843bca750ecac9518307562f669b9736fca68d961c5ebcb450e7d32dc4e850526005a6ef6bd05c9ff974500a3017c3fa
+  data.tar.gz: bffe515b3b11ab613f72da6f8c2bd78bce1548b320923b05bb47e69aaf88bf5399c6f4aa825d01eb51dd13b1012c6ce078ca77475c554e0d650760d5f6d874d2

data/Cargo.lock

@@ -307,9 +307,9 @@ checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
 
 [[package]]
 name = "parsanol"
-version = "0.18.6"
+version = "0.18.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "621395999299ffdf8757b0004bf68eee4ee499051d608f756c223508981e1f44"
+checksum = "92651c1fc80fad436b29aa642bec9f652bb0170f8ff0dc2a9f5b1411532fe732"
 dependencies = [
  "ahash",
  "getrandom 0.3.4",
@@ -326,9 +326,9 @@ dependencies = [
 
 [[package]]
 name = "parsanol-derive"
-version = "0.18.6"
+version = "0.18.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "48597b847c17492e8ee96d842f9784538fe2b523ada73bf0f0976a60287d5a71"
+checksum = "4423949424ed9894fe79f6df7fec71d5fa7549249390e9d52e34c77a78cdad13"
 dependencies = [
  "proc-macro2",
  "quote",

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,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: parsanol
 version: !ruby/object:Gem::Version
-  version: 1.3.92
+  version: 1.3.93
 platform: ruby
 authors:
 - Ribose Inc.