parsanol 1.3.120-arm-linux → 1.3.122-arm-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 77711562d9591e8a438d229e2fb8dac148a7b8b522d7f1c2c4c0b94eea1fde0e
-  data.tar.gz: bcdc10500b54b5ae24dde57248d547cfd931a0d6fc52d71d1667575441c5974c
+  metadata.gz: e6d37024ae75900c7fe4fd31f8c92119dd42ccb7af254240155b264be432c1fe
+  data.tar.gz: f78c1fa51c5ed6a72de5cbdd4e6124173f122d32a730b47b77d30ca5c385d6d6
 SHA512:
-  metadata.gz: c727d8109a8622bcb3c8e863632b2e7b728aa64e4f6b42bf9e8c342bd3a5e4f1b09f62b009e46816aec4fcd8f22acc165a7c18eb6522d3040f389a1fd80fb19a
-  data.tar.gz: ab7d8a0ec2269fe160898483356f6d41a022e22f497b27ce0bce80c5c142bbbc3ef700c582cb5cc0c704f556e9c111712e5e6ee5228855efd8f839fa22382ef1
+  metadata.gz: b5d12a29c0ef17c9f3895d814192b33b74fe3366262d988af73fdf1e5d1603f17cff7925ac77f45cde7f21799f97f832604c4bddffaca686b3a72fb1eb70a2f4
+  data.tar.gz: 8b1c7627fd9b3c946ce9a76b7445dfe6c1ebbb0ceb3fff7b061cf6a781e3d2ed498c1e205d321038a2195d7ebc050ffdd632e2ef8b71501de76a2b344016cb87

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: 39543680 bytes
-sha256: cb23ae5b9e3c6d9e196ba94c32b99ff12ceac4d65f9803f11768b78d4755fcc4
+size: 39740052 bytes
+sha256: b70dc2b64af8f8c052309c13ef755d8a156697af55b2017eec94d1ad43eef2f2

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: 39728972 bytes
-sha256: 591bb9417818c14220442123b595a34b95e695b6333ae1659bb52af80c8569b6
+size: 39925296 bytes
+sha256: 3d60d5cad8c1bf5f3ae6463c82d31f8a1027a779dc4c35be5004997d2557c862

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: 39723064 bytes
-sha256: ac2443455cc3d52d53c1060ea134d91a7b39e4b97d8eee4fdf5c2d71e010cdc4
+size: 39919396 bytes
+sha256: ccea4473a43405abe096c873c2c695ba93c271245db30d1b77f04b27df7b47a3

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: 39732740 bytes
-sha256: d183ddfcb7c9a08e75711fcd852bef72e7a7f65b27a14bb8fdc5c365b73df9c1
+size: 39929152 bytes
+sha256: 4d612343474dca5ded544fa60a9fc23bbc28d7a935ccec5546db3cbd62676540

data/lib/parsanol/native/libparsanol.so

@@ -1,4 +1,4 @@
 [diffend] Oversized file quarantined before diffing.
 name: data/lib/parsanol/native/libparsanol.so
-size: 35864872 bytes
-sha256: e0bbe3d01539221af1af284ab8c0c04eeb2437f7f45e2dd44286b65c2f2a0038
+size: 36060976 bytes
+sha256: 2ee2499abdc8e1b8707658bddd5a8a861961057ff0d5276849b33ec2f1e67f31

data/lib/parsanol/native/parser.rb

@@ -178,13 +178,27 @@ module Parsanol
 
         def append_atom_structure(atom, visited = {}.compare_by_identity, output = +"")
           if visited[atom]
+            # An Entity's self-reference keeps its name in the
+            # fingerprint, mirroring the non-visited branch (ruby#404).
+            if atom.is_a?(Parsanol::Atoms::Entity)
+              return output << "[:entity, " << atom.rule_name.to_s.inspect << ", [:cycle, " << atom.class.name.inspect << "]]"
+            end
+
             return output << "[:cycle, " << atom.class.name.inspect << "]"
           end
 
           visited[atom] = true
           case atom
           when Parsanol::Atoms::Entity
-            append_atom_structure(atom.parslet, visited, output)
+            # The rule name belongs in the fingerprint (rs#404-class
+            # collision): Entity is transparent in the serialized graph's
+            # STRUCTURE only when the target is spelled out, but the JSON
+            # keeps the Entity node itself — two webs whose Entities point
+            # at different rules share a transparent fingerprint while
+            # serializing differently, and the serializer cache then
+            # serves one grammar's JSON for the other.
+            output << "[:entity, " << atom.rule_name.to_s.inspect << ", "
+            append_atom_structure(atom.parslet, visited, output) << "]"
           when Parsanol::Atoms::Str
             output << "[:str, " << atom.str.inspect << "]"
           when Parsanol::Atoms::Re

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/compiler.rb

@@ -261,6 +261,10 @@ module Parsanol
         # the declaration means the tree never sees this subtree named,
         # inside or out.
         return atom if glue_rule?(rule_name)
+        # A capture spans the rules it references (ruby#400): their
+        # bodies compile unwrapped so the capture's value equals its
+        # edition-1 value.
+        return atom if captured_reachable?(rule_name)
 
         wrap_uncaptured(atom)
       end
@@ -273,6 +277,57 @@ module Parsanol
         @document.glue_rules.include?(name.to_s)
       end
 
+      # The rules a text capture transitively spans (ruby#400): a
+      # capture on a reference captures the referenced rule's whole
+      # match, so every rule under a capture atom — the direct
+      # reference and everything its body transitively references —
+      # compiles unwrapped. Edition 2's Named leaves then attach only
+      # to non-captured structure, and a capture's value equals its
+      # edition-1 value (`{num: "123"}`, never a leaf array).
+      def captured_reachable?(name)
+        @capture_reachable ||= begin
+          seeds = []
+          @document.rules.each_value do |node|
+            collect_refs_under_captures(node, seeds)
+          end
+          reachable = []
+          until seeds.empty?
+            rule = seeds.pop
+            next if reachable.include?(rule) || !@document.rules.key?(rule)
+
+            reachable << rule
+            collect_all_refs(@document.rules[rule], seeds)
+          end
+          reachable
+        end
+        @capture_reachable.include?(name.to_s)
+      end
+
+      def collect_refs_under_captures(node, out)
+        walk = lambda do |n, in_capture|
+          case n.kind
+          when :ref then out << n.a if in_capture
+          when :cap then walk.call(n.b, true)
+          when :pred then walk.call(n.b, in_capture)
+          when :alt, :seq then n.a.each { |child| walk.call(child, in_capture) }
+          when :rep, :opt then walk.call(n.a, in_capture)
+          end
+        end
+        walk.call(node, false)
+      end
+
+      def collect_all_refs(node, out)
+        walk = lambda do |n|
+          case n.kind
+          when :ref then out << n.a
+          when :alt, :seq then n.a.each { |child| walk.call(child) }
+          when :cap, :pred then walk.call(n.b)
+          when :rep, :opt then walk.call(n.a)
+          end
+        end
+        walk.call(node)
+      end
+
       def wrap_uncaptured(atom)
         case atom
         when Atoms::Named
@@ -289,6 +344,7 @@ module Parsanol
           # agree by design.
           if trivia_only?(atom.rule_name.to_s, { atom.rule_name.to_s => true }) ||
               glue_rule?(atom.rule_name.to_s) ||
+              captured_reachable?(atom.rule_name.to_s) ||
               produces_capture?(atom.parslet)
             atom
           else
@@ -476,9 +532,12 @@ module Parsanol
         when Atoms::Named then nil
         when Atoms::Entity
           # Mirror wrap_uncaptured's verdicts: trivia glue, declared
-          # glue, and capture-producing refs all stay bare.
+          # glue, capture-reachable refs (ruby#400 — a capture spans
+          # them, so modern mode never names them), and
+          # capture-producing refs all stay bare.
           unless trivia_only?(atom.rule_name.to_s, { atom.rule_name.to_s => true }) ||
               glue_rule?(atom.rule_name.to_s) ||
+              captured_reachable?(atom.rule_name.to_s) ||
               produces_capture?(atom.parslet)
             lines << "rule #{site}: reference to #{atom.rule_name} produces no capture -- " \
                      "modern mode would name it #{atom.rule_name}"

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.120"
+  VERSION = "1.3.122"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: parsanol
 version: !ruby/object:Gem::Version
-  version: 1.3.120
+  version: 1.3.122
 platform: arm-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