parsanol 1.3.76 → 1.3.78

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 07d32e869bd7ebe22fa7d2055041821da4dd5d3491dacc3c413c4d8271b08a0b
-  data.tar.gz: 051cdbfae972ba74f9a7a2b4d9bc8fe2cc1f361d363a209178d1f904b2298cfa
+  metadata.gz: 8b7c210627fda0c572855efe7f2e27930aff2e01f632de082abeb68dba5a99f7
+  data.tar.gz: e6bcb584fe1de6cb62f35273980dfe78e8e24688e76ba089a734606338fe94b6
 SHA512:
-  metadata.gz: 0f8bd00470cf0d1ed7341e216c537a6db93116180a448ec3528233b778eb48eadc1b21ab1fb914447807f2706cdb6ee5ed53cb45f1aa4f42e7392f5c1f11c030
-  data.tar.gz: 05e06ba6641d65ba6542fa5919df3e643d338051671b423f002df5a03e43d954b342b751d2b8b60ac76c7b1813b4db33d6f03af4691d1bbc40298d7005482bc9
+  metadata.gz: 49caa14b1f70ecefe02e75e44f572823613f30aabcfcfeb21b9477358cfb20fff09823ff6f2497c90353866de94af3c571072df859ecad702cfb532252547238
+  data.tar.gz: 6822401276fc2af955631834129ee5d75ffb64736f76d5719cba1180139d56a778fe8fad599ef59e8ab73cc634190644b4f148c808e1d92ff9065ed47ec05631

data/Cargo.lock

@@ -307,9 +307,9 @@ checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
 
 [[package]]
 name = "parsanol"
-version = "0.16.0"
+version = "0.17.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f1d2ab38ca1451e326a8e2f711f4b65f4cde5db3c07f42a1f2c6cc53451a830b"
+checksum = "170442a26c6a0b5ac25fbdb9c249dbaee821a2d364d4a42219c32af11f008b3d"
 dependencies = [
  "ahash",
  "getrandom 0.3.4",
@@ -326,9 +326,9 @@ dependencies = [
 
 [[package]]
 name = "parsanol-derive"
-version = "0.16.0"
+version = "0.17.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8bf00288d64331de21d802b98c5fcbb15d916ea4c151b1349b316ae8af8b5678"
+checksum = "c3567bd641f8a18ee4a1e0339d9e1d0bd804764c1d813efc25b8fd7f24ed8ad3"
 dependencies = [
  "proc-macro2",
  "quote",

data/ext/parsanol_cdylib/Cargo.toml

@@ -12,5 +12,5 @@ crate-type = ["cdylib"]
 doc = false
 
 [dependencies]
-# 0.16.0 carries atom-valued capture writes (native scope/continuation)
-parsanol = { version = "0.16.0" }
+# 0.17.0 carries LookSpec + the widened opaque writeback
+parsanol = { version = "0.17.1" }

data/ext/parsanol_native/Cargo.toml

@@ -29,9 +29,10 @@ magnus = { version = "0.9" }
 
 # parsanol parser library (crates.io; 0.12 carries the rs#174 native
 # backtracking fix: dynamic-dependent memoization + outcome cache)
-# parsanol parser library (crates.io; 0.16.0 carries atom-valued capture
-# writes: the native scope/continuation fix, parsanol-ruby#160)
-parsanol = { version = "0.16.0", features = ["ruby"] }
+# parsanol parser library (crates.io; 0.17.0 carries the LookSpec regex
+# lookbehind (rs#163 gap 1) and the widened opaque writeback: the
+# lazy-continuation fix, parsanol-ruby#160)
+parsanol = { version = "0.17.1", features = ["ruby"] }
 
 # Logging
 log = "0.4"

data/lib/parsanol/atoms/lookbehind.rb

@@ -2,30 +2,60 @@
 
 module Parsanol
   module Atoms
-    # Inspects the byte window behind the current position: the
-    # previous +count+ bytes must equal +pattern+ (positive) or
-    # differ (negative). Consumes nothing, yields nil — the
-    # precedes?/does_not_precede? guard shape (coradoc-markdown
-    # parity, rs#137 follow-up).
+    # Inspects the text behind the current position and consumes
+    # nothing, yielding nil.
+    #
+    # Two forms (rs#137/#163):
+    # - Literal: the previous +count+ bytes must equal +pattern+
+    #   (the precedes?/does_not_precede? fixed-window guard).
+    # - Regex: +source+ is searched in the preceding text and must
+    #   end at the position — the CommonMark flanking form, which is
+    #   class-based, multibyte and variable-length.
     class Lookbehind < Base
-      attr_reader :count, :pattern, :positive
+      attr_reader :count, :pattern, :regex_source, :positive
 
       def initialize(count, pattern, positive: true)
         super()
         @count = count
         @pattern = pattern
+        @regex_source = nil
+        @compiled = nil
         @positive = positive
       end
 
+      # Class-based flanking guard: +source+ must match the text
+      # ending at the position.
+      def self.regex(source, positive: true)
+        atom = new(0, "", positive: positive)
+        atom.instance_variable_set(:@regex_source, source)
+        atom
+      end
+
+      def regex?
+        !@regex_source.nil?
+      end
+
       def try(source, _context, _consume_all)
         start = source.bytepos
-        behind = start >= @count ? source.input.byteslice(start - @count, @count) : nil
-        matched = !behind.nil? && behind == @pattern.b
+        if regex?
+          @compiled ||= Regexp.new("(?:#{@regex_source})\\z")
+          matched = @compiled.match?(source.input.byteslice(0, start))
+        else
+          behind =
+            if start >= @count
+              source.input.byteslice(start - @count, @count)
+            end
+          matched = !behind.nil? && behind == @pattern.b
+        end
         [matched == @positive, nil]
       end
 
       def to_s_inner(_prec)
-        "lookbehind(#{@count}, #{@pattern.inspect}, #{@positive ? '+' : '-'})"
+        if regex?
+          "lookbehind(/#{@regex_source}/, #{@positive ? '+' : '-'})"
+        else
+          "lookbehind(#{@count}, #{@pattern.inspect}, #{@positive ? '+' : '-'})"
+        end
       end
     end
   end

data/lib/parsanol/native/dynamic.rb

@@ -132,6 +132,12 @@ module Parsanol
         #
         def invoke_from_rust(callback_id, context)
           block = @mutex.synchronize { @callbacks[callback_id]&.dig(:block) }
+          if ENV["PARSANOL_INVOKE_TRACE"]
+            cont = context[:captures][:cont]
+            warn "INVOKE id=#{callback_id} pos=#{context[:pos]} " \
+                 "block=#{context[:captures][:block].inspect} " \
+                 "cont=#{cont.class}@#{cont.object_id}"
+          end
           return nil unless block
 
           # Build DynamicContext from hash
@@ -142,18 +148,33 @@ module Parsanol
           )
 
           # Call the block. Parslet-canonical blocks take two arguments
-          # (source, context): pass the restricted context for both so
-          # either convention works (GH-76). Captures are read-only
-          # snapshots of the engine state; write-dependent dispatch must
-          # run on mode: :ruby.
+          # (source, context). The source is a REAL Parsanol::Source
+          # positioned at the dispatch point: blocks that read source
+          # state (bytepos, line_and_column — the lazy-continuation
+          # guards do) previously got the context wrapper for both
+          # args and raised NoMethodError, which the bridge turned
+          # into a silent dispatch failure (rs#165). Consumption
+          # side-effects stay local to the call: the resolved fragment
+          # is the parse.
           result = if block.arity == 2
-                     block.call(ctx, ctx)
+                     dispatch_source = Parsanol::Source.new(context[:input])
+                     dispatch_source.bytepos = context[:pos]
+                     block.call(dispatch_source, ctx)
                    else
                      block.call(ctx)
                    end
 
           return nil unless result
 
+          if ENV["PARSANOL_FRAG_TRACE"]
+            begin
+              json = result.to_atom_json
+              warn "FRAG id=#{callback_id} json=#{json[0, 120]}"
+            rescue StandardError => e
+              warn "FRAG id=#{callback_id} RAISE #{e.class}: #{e.message[0, 140]}"
+            end
+          end
+
           # Capture-write contract (GH-80): return the atom and the
           # post-call captures hash; the Rust bridge diffs it against
           # the seeded values and propagates the block's writes

data/lib/parsanol/native/parser.rb

@@ -121,6 +121,13 @@ module Parsanol
           }
         end
 
+        # Public (rs#166): the VM program cache shares compiled
+        # programs across fresh parser instances keyed on this —
+        # the same disambiguator the grammar cache uses.
+        def public_structure_hash(atom)
+          grammar_structure_hash(atom)
+        end
+
         private
 
         def grammar_cache_key(root_atom)

data/lib/parsanol/native/serializer.rb

@@ -103,15 +103,17 @@ module Parsanol
                      # atoms — empty match yielding a wire constant.
                      { "Constant" => { "value" => serialize_constant_value(atom.value) } }
                    when Parsanol::Atoms::Lookbehind
-                     # rs#137 follow-up: the precedes?/does_not_precede?
-                     # guards — inspect the bytes behind the position.
-                     {
-                       "Lookbehind" => {
-                         "count" => atom.count,
-                         "pattern" => atom.pattern,
-                         "positive" => atom.positive,
-                       },
-                     }
+                     # rs#137/#163: the behind-window test — a fixed
+                     # literal window or an end-anchored regex (the
+                     # CommonMark flanking form).
+                     look = if atom.regex?
+                              { "Regex" => { "source" => atom.regex_source } }
+                            else
+                              { "Literal" => { "count" => atom.count,
+                                               "pattern" => atom.pattern } }
+                            end
+                     { "Lookbehind" => { "look" => look,
+                                         "positive" => atom.positive } }
                    when Parsanol::Atoms::Ignored
                      serialize_ignored(atom)
                    else

data/lib/parsanol/parg/artifact.rb

@@ -65,8 +65,16 @@ module Parsanol
       def parse(entry_name, input, mode: :native)
         case mode
         when :native
-          if !envelope["dynamic"] && Native.available?
-            return Native.parse(JSON.generate(entry(entry_name).fetch("grammar")), input)
+          if Native.available? && !envelope["dynamic"]
+            # Fast lane (parsanol-ruby#162): the per-instance atom
+            # tree rides the DSL serialization/registration caches
+            # (GRAMMAR_CACHE / HANDLE_CACHE keyed on the stable root
+            # atom), so an artifact parses at compiled speed after
+            # the first call. The old path re-serialized the whole
+            # grammar JSON and re-registered it per parse (~8x).
+            # Dynamic artifacts carry ruby-tier atoms their wire
+            # cannot express — they keep the interpreter.
+            return root_atom(entry_name).parse(input, mode: :native)
           end
 
           root_atom(entry_name).parse(input)

data/lib/parsanol/version.rb

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

data/lib/parsanol/vm.rb

@@ -202,6 +202,10 @@ module Parsanol
         # starts memoized on its very first parse (fresh parser instances
         # included — the seed is recomputed at every compile), so the
         # cold-start never pays the doomed unmemoized exploration.
+        # rs#166: proneness rides the structure-hash share as a bool —
+        # a later identical-structure grammar inherits the seed instead
+        # of running its cold start unmemoized because compilation was
+        # skipped entirely.
         if compiler.backtracking_prone
           (@heavy ||= {}.compare_by_identity)[root] = true
           trim_cache(@heavy)

metadata

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