parsanol 1.3.121 → 1.3.122

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6b2308bfe0b4b5787cbfac5725e10e2afd01ade41f3ae373dd09df250dbaebd3
-  data.tar.gz: b49dc9c6b767be5c8ec34492b3e1a63683aa8bba12f8a4d194ddd107169b51da
+  metadata.gz: 4a2162ac62e96201b3ab45cba32e5b69f8162ec37b266a52fa5be0b16e85823f
+  data.tar.gz: db0e6ef317d68d558eb06e36b0fcbe50b1f556786065d87dd599154671d8df73
 SHA512:
-  metadata.gz: 280e47f635e0319aa01a2b5b4936ddc3aa62c9eae8e6f3c13f07600a5904bafb2e7bbd7521f984e5689f5e550eb964c09ac23c8ca36ab7913d4c776f83fafea4
-  data.tar.gz: bab0183da6fcf3b5c837ba9f46e675269b5b567e77a3333ea8b5c41c5c85f5390a3f82cc8d9778b63cd57308fa7b0053d67da12d055f9a70c18e0c7c397b1c7f
+  metadata.gz: 7bdb62867da115b8372fd37b2f4532d44ad48e47571c1aab897845313b4f6bf585aa25e1efcf386aba83305c610256f871c7a5052c631e0c085a03ab1b85560b
+  data.tar.gz: dbfdf3281e65e86abba50653461bb572c4246499bf8a629b269c4898fc824f8b951714db3bb3a48e5609cecb72d9d10230ac571c73575be195a66d95105ec595

data/lib/parsanol/parg/bindings.rb

@@ -13,6 +13,10 @@ 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.
+        present = captures.keys
         out = {}
         scalar, arrays = bindings.partition { |binding| !binding["path"].to_s.include?("[]") }
         scalar.each do |binding|
@@ -22,9 +26,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 +98,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 +133,7 @@ module Parsanol
             end
             list << element
           end
+          out[prefix.to_sym] = list
           return
         end
 
@@ -115,10 +155,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 +175,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 +241,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.122"
 end

metadata

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