parsanol 1.3.121-aarch64-linux → 1.3.123-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b59325cb49756928a21a99177042caeb687bf5720f02ca3c4992efaf259b3975
-  data.tar.gz: 6049d358d43d93dd8b7146a293c6bf424343871778b99be986ed54bda2a81699
+  metadata.gz: 6a05aa3803a0a35921ce270f05e7375af46c1c008c9b2afb98ed7e63701fe014
+  data.tar.gz: bb80e21f834f580e0a21f604fde26208d49679dcd889730da0f8f670d703eb82
 SHA512:
-  metadata.gz: 1aaf59d820edb6f97326c61053cd06acb40036d86d5da669925718710f01ebd70310371fb72aef0f102e983efdd178d9adf96ff9528692ef101a0cc88421b66a
-  data.tar.gz: 422219a69dcb76b014fbd317bfd58ade7721acf55c12ffcd5d126c682547d37d94395c4c23b8c8b59445bcafec936d977ef52605cb90e4b33474ad7f7a094713
+  metadata.gz: 5c307c932d5e3aa2927b03c090e23b50cc1de8cf1979100a3e120ac928b38b88dd16af55eee668e491467b70b33f250f77e673356cdc10f67c67222679abb773
+  data.tar.gz: bb2b3e5fe203e6e97594209576e7651e62d38b61f86f3c1a4860c6a06a1369a0e7b4784b6cb82ef29812766d77a98347482f9e38b5c61c6691b94e039cf3d8f9

data/lib/parsanol/parg/bindings.rb

@@ -13,6 +13,16 @@ module Parsanol
       def apply(artifact, entry, shape)
         bindings = entry["bindings"] || []
         captures = collect_captures(shape)
+        # Snapshot before the assignment pass: reading a missing key off
+        # `captures` inserts it (default-proc hash), which would make the
+        # #413 lost-check below see phantom presence. Presence means a
+        # NON-NIL value somewhere in the tree: a fired-but-empty optional
+        # capture binds null in the parslet shape, and binding nothing for
+        # null is legitimate optionality, not loss (parsanol-ruby#418 —
+        # CIE trailing_lang, JIS reaffirmed).
+        present = captures.keys.select do |key|
+          captures[key].any? { |value| !value.nil? }
+        end
         out = {}
         scalar, arrays = bindings.partition { |binding| !binding["path"].to_s.include?("[]") }
         scalar.each do |binding|
@@ -22,9 +32,38 @@ module Parsanol
         arrays.group_by { |binding| binding["path"].split("[]").first }.each do |prefix, group|
           assign_array(out, artifact, prefix, group, captures, shape)
         end
+        # Every declared capture that the tree carries must reach the
+        # bound map (parsanol-ruby#413): a capture present in the parse
+        # but bound nowhere is silent data loss, the one case the
+        # binding layer's other checks miss. Absence in the TREE is
+        # legitimate optionality and never raises.
+        lost = bindings.select do |binding|
+          capture = binding["capture"].to_sym
+          present.include?(capture) && !bound?(out, binding)
+        end
+        unless lost.empty?
+          raise BindError,
+                "entry #{entry['name'].inspect}: capture #{lost.map { |b| b['capture'].inspect }.join(', ')} " \
+                "is present in the parse tree but bound nowhere"
+        end
         out
       end
 
+      # Did this binding contribute anything to the bound map? Scalars
+      # bind under their leaf key; array groups bind under their prefix.
+      def bound?(out, binding)
+        path = binding["path"].to_s
+        if path.include?("[]")
+          prefix = path.split("[]").first.to_sym
+          rows = out[prefix]
+          rows.is_a?(Array) && rows.any? do |row|
+            row.is_a?(Hash) && row.key?(leaf_key(binding))
+          end
+        else
+          out.key?(leaf_key(binding))
+        end
+      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
@@ -65,24 +104,30 @@ module Parsanol
 
       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
+        # 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.
+        # when every instance fires every capture.
+        #
+        # Identification is strictly keyed: the bare top array of a
+        # repetition-root entry is NOT claimed as instances
+        # (parsanol-ruby#408/#412 — that fallback claimed per-token rule
+        # siblings as group instances, splitting paired captures into
+        # single-field rows and sprouting phantom rows for unrelated
+        # siblings). A capture outside a keyed instance array keeps the
+        # legacy occurrence pairing. Phantom rows materialize as {}
+        # (the #408 contract: the engines agree by always emitting the
+        # row; the contracted phantom representation is {} , never nil).
         instances = shape && group_instances(shape, prefix)
         if instances
-          # The occurrence path's `return if count.zero?`: a repetition
-          # that fired zero iterations (the tree carries `parts: []`)
+          # parsanol-rs#370: a repetition that fired zero iterations
           # binds no key — the recorded native expectations and the
-          # pubid builders rely on the absent reading (the empty-array
-          # binding regression, caught by the pubid corpus gate; see
-          # parsanol-rs#370).
+          # pubid builders rely on the absent reading.
           return if instances.empty?
 
-          list = (out[prefix.to_sym] ||= [])
+          list = []
           instances.each do |instance|
             found = collect_captures(instance)
             element = {}
@@ -94,6 +139,7 @@ module Parsanol
             end
             list << element
           end
+          out[prefix.to_sym] = list
           return
         end
 
@@ -115,10 +161,12 @@ 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.
+      # The `prefix[]` group's instance subtrees: the array under a key
+      # naming the prefix, walked in collect_captures' BFS order. There
+      # is deliberately NO fallback for a repetition-root entry — a bare
+      # top array cannot be told apart from per-token rule siblings
+      # (#408/#412), so claiming it is magic; those shapes pair by
+      # occurrence instead.
       def group_instances(shape, prefix)
         queue = [shape]
         until queue.empty?
@@ -133,7 +181,7 @@ module Parsanol
           when Array then queue.concat(node)
           end
         end
-        shape if shape.is_a?(Array) && shape.any?(Hash)
+        nil
       end
 
       def validate_path!(binding)
@@ -199,10 +247,42 @@ module Parsanol
           # string-keyed hashes, repeats as arrays — so (any)-bound keys
           # survive a cross-engine gate without consumer shims.
           plain(value)
+        when "text"
+          # The matched span as text (ruby#382): a capture whose body
+          # carries inner captures binds a hash of them; (text) returns
+          # the span those captures jointly matched while the inner
+          # captures still fire as their own bindings.
+          span_text(value)
         else value
         end
       end
 
+      # The matched span of a capture value: the byte range from the
+      # first to the last slice in the subtree, cut from the input the
+      # slices carry. A plain Slice or String is already its span.
+      def span_text(value)
+        return value.to_s if value.is_a?(Parsanol::Slice) || value.is_a?(String)
+
+        slices = []
+        walk = lambda do |node|
+          case node
+          when Parsanol::Slice then slices << node
+          when Hash then node.each_value { |item| Array(item).each(&walk) }
+          when Array then node.each(&walk)
+          end
+        end
+        walk.call(value)
+        return plain(value) if slices.empty?
+
+        start = slices.map(&:offset).min
+        stop = slices.map { |slice| slice.offset + slice.content.bytesize }.max
+        input = slices.first.input
+        return plain(value) unless input
+
+        span = input.byteslice(start, stop - start)
+        span&.force_encoding(Encoding::UTF_8)
+      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

data/lib/parsanol/parg/error.rb

@@ -14,5 +14,9 @@ module Parsanol
 
     # Raised when an artifact envelope is corrupt or its checksum mismatches.
     class ArtifactError < Error; end
+
+    # A declared capture is present in the parse tree but reached the
+    # bound map nowhere (parsanol-ruby#413): silent data loss made loud.
+    class BindError < ArtifactError; end
   end
 end

data/lib/parsanol/parg.rb

@@ -17,6 +17,7 @@ module Parsanol
     autoload :ParseError, "parsanol/parg/error"
     autoload :CompileError, "parsanol/parg/error"
     autoload :ArtifactError, "parsanol/parg/error"
+    autoload :BindError, "parsanol/parg/error"
     autoload :Node, "parsanol/parg/node"
     autoload :Export, "parsanol/parg/export"
     autoload :Lexer, "parsanol/parg/lexer"

data/lib/parsanol/version.rb

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

metadata

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