parsanol 1.3.116-aarch64-linux → 1.3.118-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3866cf90352343093d7788b2554ae997619cd229a6a8c95affacd72d484ef058
-  data.tar.gz: 75517165b8d0b7ecaf649696830a2d1e787fbd567a44c04f72c80d1db4e95ce0
+  metadata.gz: 528e8dbd52f42bdf29e0692ec6b78b45811d6200234a024be6d0239f260cffdd
+  data.tar.gz: 34113c97e3669e08bf58f4a1bc212c0bf4046000614f014dc8c961322bfbc57f
 SHA512:
-  metadata.gz: 5fd74eb4265e6800f99e86b68e7af5bc87a26746c77c40997d37068eb0d3a02c5b0ec7e7dc2cc1e287539d8df230b0c40a5e1d456bfb46c06af5920eef24fe01
-  data.tar.gz: b0d14e98182f6a8240929116ac2e28cac8cae3cb33fb968974b9c67cc46f89b1d91cf44b640f7ff77456f41b86b03131eeaf859ef7f6e7373fff0cb4f0e243e9
+  metadata.gz: 3ff05e12878bdfb59ac439f50dcf782d8738a38ccc885bb3de83b833de9980ab6112835386e96e5c06e9e88df831cea52f05748db4e86ea94cab13c29c62ccbc
+  data.tar.gz: f49ed696b260077f0f77a6e0d21acba191af25c0b39a4eecfaa84c0c5bf78e7760d1c812545ace2bc722841073bd6efdc150672a8146159534849c6f9ab3d9ea

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: 46473512 bytes
-sha256: 8830bace23447e874a0cb0beb18aefaea01e741127d417eab672ba509b6ccd05
+size: 46566584 bytes
+sha256: 870a9bf97e079764ecc2ea3d1af4fbfc24081e4fb0e8e2d5d21e454a7bc842db

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: 46708568 bytes
-sha256: ce64172e86ce450056b62c19d2576bedec7328882ba0a6b85d1daeb0f714ae60
+size: 46805760 bytes
+sha256: ce41490479d101f992a192d3ad9cb8d3ad550e128590797acd7cc17422c61bde

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: 46708400 bytes
-sha256: 1f46812ffca0a5c50bc2cfd85e60165f53f6c37c022646d50a9839a6398aafb4
+size: 46809816 bytes
+sha256: 449cec2f4d18b089ef179ba27214fbb7c7dd8f113e7fb77b2edfaed76ebaddbe

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: 46718376 bytes
-sha256: 4bd9b9a37f71b06587de7c46717e27bac5c92395b428ef21fa415d9ba7961b4c
+size: 46819800 bytes
+sha256: 7933405b216e4fba9a41ec2771c6239b73ee32645f67145c9370f9daa0bb8aa3

data/lib/parsanol/native/libparsanol.so

@@ -1,4 +1,4 @@
 [diffend] Oversized file quarantined before diffing.
 name: data/lib/parsanol/native/libparsanol.so
-size: 42172384 bytes
-sha256: 01059d0afea9e965e6cfe5d09aeb5573667b3ea860a227f6cebcef30d3581b09
+size: 42275976 bytes
+sha256: 3d3dc209b794a4b5927b609bb1ff442d18bfc40bcd349cee57c3a6dc1302a442

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