parsanol 1.3.116 → 1.3.118

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b6be4ab27d5d8c86b4f214b75cefb0bb16a3de4eb9e55402d93ca807fae280aa
-  data.tar.gz: cf56a4e2921063811e55a4016342cce471acf24138825ebe24673f5563cf70ea
+  metadata.gz: 6468b7f70f6c5e61ea1e3661e9a052206730f7f07f71fb9ec9e57777fe777a6d
+  data.tar.gz: 17e99bf63b7b0001499e2844c93e4aabf14f64760a85cfc79a6fdad5c290e51e
 SHA512:
-  metadata.gz: 13957312679b48cf55f8455e8a6311c785915dd95e9c940d974f487bc814ec07de54fe30f860912bfc9b42b7b51645110b95e6d52ccba266951d3d9523d864f7
-  data.tar.gz: 852e7731ce29b534bd383010655cb6380c9bac8840c69204904d1e17de089e5db578c13ad3c65707aa8d686ebd5ffc50ea526035256a474c8cdf7ea555cb1838
+  metadata.gz: 90a1d39c526c512b4d7a55bc328b0530a92ae010c4a4febb91cc8b5408d0d070c20ef4e2cda81695c739fb94bdd29421434eb806c52b6ac060ac85fd8380c615
+  data.tar.gz: '083ed02a83cfbbbe16ef6bd3ec922229a35c52f9d81935458b86fbce4433264038ad390ed958b4602b0a414a7aad7dadf06e052e1fdb9f40c935465c74665308'

data/Cargo.lock

@@ -307,9 +307,9 @@ checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
 
 [[package]]
 name = "parsanol"
-version = "0.19.12"
+version = "0.19.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2d8c6e0a21c9ee8cc6e661e4109a70d1c8f4f62c963eb12230b8d7035ebb63ee"
+checksum = "f14e6d53cab2665d789adc8e28ff2181899501ef56afc4d65100f09a6d9c8101"
 dependencies = [
  "ahash",
  "getrandom 0.3.4",
@@ -326,9 +326,9 @@ dependencies = [
 
 [[package]]
 name = "parsanol-derive"
-version = "0.19.12"
+version = "0.19.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2662678735acff3124dc2514d4792cc4a82cfaff50ed3b0a88c2a5662ecb9818"
+checksum = "a5066e2da7badb25efb562dbebb6d0fc287e6e4dc7bd06b1da4b502bf349d94d"
 dependencies = [
  "proc-macro2",
  "quote",

data/lib/parsanol/parg/artifact.rb

@@ -86,6 +86,12 @@ module Parsanol
 
       def compiler_version = envelope["compiler_version"]
 
+      # The behavior fingerprint (ruby#377): stable across producer
+      # metadata, so freshness gates can tell "re-baked by a newer
+      # compiler" from "the grammar changed". nil on artifacts baked
+      # before the field existed.
+      def semantics_hash = envelope["semantics_hash"]
+
       def fresh_against?(source_text)
         return false if source_hash.nil?
 

data/lib/parsanol/parg/bindings.rb

@@ -20,7 +20,7 @@ module Parsanol
           assign_scalar(out, artifact, binding, captures)
         end
         arrays.group_by { |binding| binding["path"].split("[]").first }.each do |prefix, group|
-          assign_array(out, artifact, prefix, group, captures)
+          assign_array(out, artifact, prefix, group, captures, shape)
         end
         out
       end
@@ -63,7 +63,32 @@ module Parsanol
         out[leaf_key(binding)] = finalize(artifact, binding, value)
       end
 
-      def assign_array(out, artifact, prefix, group, captures)
+      def assign_array(out, artifact, prefix, group, captures, shape = nil)
+        # Position-aware pairing (parsanol-ruby#381): when the shape
+        # nests the group's instances under the prefix key, each
+        # instance's subtree owns its captures — pairing by OCCURRENCE
+        # index landed a sparse capture (one that fires in only some
+        # instances) on the wrong instance. Per-instance collection
+        # fixes the pairing and is identical to the old flat pairing
+        # when every instance fires every capture. Captures outside
+        # any instance keep the legacy occurrence pairing.
+        instances = shape && group_instances(shape, prefix)
+        if instances
+          list = (out[prefix.to_sym] ||= [])
+          instances.each do |instance|
+            found = collect_captures(instance)
+            element = {}
+            group.each do |binding|
+              value = found[binding["capture"].to_sym].first
+              next if value.nil?
+
+              element[leaf_key(binding)] = finalize(artifact, binding, value)
+            end
+            list << element
+          end
+          return
+        end
+
         count = group.map { |binding| captures[binding["capture"].to_sym].length }.max || 0
         return if count.zero?
 
@@ -82,6 +107,27 @@ module Parsanol
         end
       end
 
+      # The `prefix[]` group's instance subtrees: the first array under
+      # a key naming the prefix, walked in collect_captures' BFS order.
+      # A repetition-root entry's shape IS the instances array (the wire
+      # has no key for it) — that is the fallback when no key matches.
+      def group_instances(shape, prefix)
+        queue = [shape]
+        until queue.empty?
+          node = queue.shift
+          case node
+          when Hash
+            node.each do |key, value|
+              return value if key.to_s == prefix && value.is_a?(Array)
+
+              queue << value if value.is_a?(Hash) || value.is_a?(Array)
+            end
+          when Array then queue.concat(node)
+          end
+        end
+        shape if shape.is_a?(Array) && shape.any?(Hash)
+      end
+
       def validate_path!(binding)
         path = binding["path"].to_s
         return unless path.include?(".") || path.include?("[")
@@ -139,9 +185,31 @@ module Parsanol
 
           value.to_s
         when "boolean" then value == true || value.to_s.casecmp("true").zero?
+        when "any"
+          # The ONE plain shape on every engine (ruby#383): scalars and
+          # capture leaves render as their text, named groups as plain
+          # string-keyed hashes, repeats as arrays — so (any)-bound keys
+          # survive a cross-engine gate without consumer shims.
+          plain(value)
         else value
         end
       end
+
+      # The engine-neutral reduction behind (any): capture leaves
+      # (Parsanol::Slice, native wire objects) and scalars render as
+      # their text, hashes as string-keyed plain hashes, arrays
+      # recurse. Nil passes through (absent captures stay absent —
+      # assign_scalar/assign_array skip them upstream).
+      def plain(value)
+        case value
+        when nil then nil
+        when String then value
+        when Hash
+          value.to_h { |key, item| [key.to_s, plain(item)] }
+        when Array then value.map { |item| plain(item) }
+        else value.to_s
+        end
+      end
     end
   end
 end

data/lib/parsanol/parg/compiler.rb

@@ -32,6 +32,18 @@ module Parsanol
         "sha256:#{Digest::SHA256.hexdigest(JSON.generate(canonicalize(payload)))}"
       end
 
+      # Producer metadata: the checksum pins the exact producer, but the
+      # semantics hash (ruby#377) skips these fields so a re-bake by a
+      # newer compiler — or a different Ruby patch stamping
+      # unicode_tables — is byte-stable when the grammar's behavior is
+      # unchanged. Mirrors the cross-engine parity view.
+      SEMANTICS_EXCLUDED = %w[checksum compiler_version unicode_tables semantics_hash].freeze
+
+      def self.semantics_hash(envelope)
+        payload = envelope.except(*SEMANTICS_EXCLUDED)
+        "sha256:#{Digest::SHA256.hexdigest(JSON.generate(canonicalize(payload)))}"
+      end
+
       def self.canonicalize(obj)
         case obj
         when Hash then obj.sort.to_h.transform_values { |value| canonicalize(value) }
@@ -137,14 +149,24 @@ module Parsanol
 
         artifact = Artifact.from_json(JSON.generate(envelope), tables_dir: tables_dir)
         default = envelope["default_entry"] || artifact.entries.first
+        # `Native.available?` is true under either engine tier, but the
+        # JSON-grammar fast path rides the MRI C-API extension's
+        # `_parse_raw` — an ffi-cdylib install is available without it.
+        # Probe rather than assume (same doctrine as
+        # Native.reference_available?): without the C-API symbol the
+        # self-test runs through the artifact's own parse lane, which
+        # picks native-or-pure-Ruby honestly instead of raising
+        # NoMethodError mid-run.
+        json_capable = Native.respond_to?(:_parse_raw)
         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) },
-          )
+          parse_with =
+            if json_capable
+              grammar_json = (grammars[entry] ||= JSON.generate(artifact.entry(entry)["grammar"]))
+              ->(input) { Native.parse_json_grammar(grammar_json, input) }
+            end
+          artifact.run_test_list([test], parse_with: parse_with)
         end.flatten
       end
 
@@ -1352,6 +1374,7 @@ module Parsanol
         envelope["customs"] = @document.customs unless @document.customs.empty?
         envelope["states"] = @document.states unless @document.states.empty?
         envelope["dynamic"] = true if @dynamic
+        envelope["semantics_hash"] = Compiler.semantics_hash(envelope)
         envelope["checksum"] = Compiler.checksum(envelope)
         envelope
       end

data/lib/parsanol/parg/parser.rb

@@ -571,11 +571,16 @@ module Parsanol
 
       def parse_postfixed
         sign, behind = parse_guard_sign
-        node = capture_postfix(parse_primary)
+        node = parse_primary
         if sign.nil?
-          node
+          capture_postfix(node)
         else
-          Node.new(:pred, sign, node, behind ? :behind : nil)
+          # The capture binds the GUARD, not the guarded primary
+          # (parsanol-ruby#380): `!digit as year` is `( !digit ) as
+          # year` — a capture inside the lookahead would never bind
+          # (a negated guard consumes nothing), so `as` must wrap the
+          # pred, matching the rep path's postfix order (ruby#197).
+          capture_postfix(Node.new(:pred, sign, node, behind ? :behind : nil))
         end
       end
 

data/lib/parsanol/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: parsanol
 version: !ruby/object:Gem::Version
-  version: 1.3.116
+  version: 1.3.118
 platform: ruby
 authors:
 - Ribose Inc.