parsanol 1.3.120 → 1.3.122

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e61dcbc90916d0c5bc6d82ecfa1f4c1f76987df549b49460a20e01622bb0a159
-  data.tar.gz: 3a4214dcc35b10e44819910f78cc1905dce036c1789ab7162c8819f92ffc15a6
+  metadata.gz: 4a2162ac62e96201b3ab45cba32e5b69f8162ec37b266a52fa5be0b16e85823f
+  data.tar.gz: db0e6ef317d68d558eb06e36b0fcbe50b1f556786065d87dd599154671d8df73
 SHA512:
-  metadata.gz: b9be0ac6018e475fbaba69dc3f95a0ca55567f8664049aaab3b7ffa20a5dafc7c2508da7d3aa66768010373a6b926426761e134ce39b490e0663b0394ea0ffb7
-  data.tar.gz: 0373d7ad8a5e0c5dad37702b59c22e12fd75646a2de59fbe1dbaa7d02dcd9a297b099c8a32759a3a048acf0c63e9d7b7a8f212a616e4f7c8caf41fa8be29776c
+  metadata.gz: 7bdb62867da115b8372fd37b2f4532d44ad48e47571c1aab897845313b4f6bf585aa25e1efcf386aba83305c610256f871c7a5052c631e0c085a03ab1b85560b
+  data.tar.gz: dbfdf3281e65e86abba50653461bb572c4246499bf8a629b269c4898fc824f8b951714db3bb3a48e5609cecb72d9d10230ac571c73575be195a66d95105ec595

data/Cargo.lock

@@ -307,9 +307,9 @@ checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
 
 [[package]]
 name = "parsanol"
-version = "0.19.17"
+version = "0.19.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "761b572291fd7bad4514b55492cc402d297dd1586e48d1daad6ca25a927968b1"
+checksum = "7ec17007676a476ef23db64b69c3bf5b36d741763ac11ced3089b90a96c9a716"
 dependencies = [
  "ahash",
  "getrandom 0.3.4",
@@ -326,9 +326,9 @@ dependencies = [
 
 [[package]]
 name = "parsanol-derive"
-version = "0.19.17"
+version = "0.19.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3831668982431ef76e72800bd4cb399c38f0b51554541d4e4263a09fe461f460"
+checksum = "fc342af122d8854b8916eaacc6a6c2ad911419c605ea47b74b575c2ca24ab23d"
 dependencies = [
  "proc-macro2",
  "quote",

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