parsanol 1.3.83-arm-linux → 1.3.85-arm-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7f0e6c8c662ef00d3cf9b455a90f086e2dd6ee46639b9272eaa2be08b380abee
-  data.tar.gz: 4cb4b482bdb061e18de9d6e78445916a749ea926879c4cacf7fad7663acc90d5
+  metadata.gz: b8fb8fead38031f96872f7aae3373ff012794c1733d534d759c6ac57e38cdb95
+  data.tar.gz: 11c3fbeae81c61325155c805cb31c8a0aefa6a29a3fa6979349912c715e0c596
 SHA512:
-  metadata.gz: cf4bb4cf4dca692026c4f90999de2d9cf79fab5a4135400099108954dcc9847d65c1ea05ac04c17ef74afb55732cb046fe8b98565251200fbe1aa5c60e3c69f9
-  data.tar.gz: 61d8a00dc1e15e1128c0ef624fac1073f6dfc23c774069eb661a6b0db6f828e4d447a38e112bcff9104526e19b7405c8b85711d2b228ebcd1b414574e19d77bf
+  metadata.gz: 02254b1575071cd812a89e9cc18559df5d1c0fe75038928d159a52d9e448374505765e69e98e7eca201730639ca212424d2c9ac183e198b1ef6e71a3aab080fd
+  data.tar.gz: 28dd52ef90e9930b67deea237f40b63f0c68ea7526c6d9dbe6653536f8f265977ee238e3cd91b6b5e83e571152b579788193c3749048adb84254c98e381255f6

data/lib/parsanol/atoms/repetition.rb

@@ -48,16 +48,25 @@ module Parsanol
         # Internal value for comparisons (nil becomes infinity)
         @max_internal = max_count || Float::INFINITY
 
-        # Pre-built error messages
-        @min_error = "Expected at least #{min_count} of #{parser.inspect}"
+        # Error messages render LAZILY (error_msgs): construction is
+        # hot-path builder/injector work, and stringifying the whole
+        # subtree eagerly is exponential on shared cross-referencing
+        # grammars (the same class of cost Sequence's fail_msg had,
+        # parsanol-ruby#180/#184).
         @extra_error = "Extra input after last repetition"
       end
 
       # Error messages hash (for compatibility)
       def error_msgs
-        { minrep: @min_error, unconsumed: @extra_error }
+        { minrep: min_error, unconsumed: @extra_error }
       end
 
+      # Rendered lazily and memoized on first failure (see initialize).
+      def min_error
+        @min_error ||= "Expected at least #{@min} of #{@parslet.inspect}"
+      end
+      private :min_error
+
       # Executes the repetition.
       #
       # @param source [Parsanol::Source] input
@@ -110,8 +119,6 @@ module Parsanol
         first
       end
 
-      private
-
       # Optional match (0 or 1)
       def try_maybe(source, context, _consume_all)
         success, value = @parslet.apply(source, context, false)
@@ -136,39 +143,39 @@ module Parsanol
         success, value = @parslet.apply(source, context, consume_all)
         return ok([@result_tag, value]) if success
 
-        context.err_at(self, source, @min_error, source.bytepos, [value])
+        context.err_at(self, source, min_error, source.bytepos, [value])
       end
 
       def double_match(source, context, consume_all)
         success, v1 = @parslet.apply(source, context, false)
         unless success
-          return context.err_at(self, source, @min_error, source.bytepos,
+          return context.err_at(self, source, min_error, source.bytepos,
                                 [v1])
         end
 
         success, v2 = @parslet.apply(source, context, consume_all)
         return ok([@result_tag, v1, v2]) if success
 
-        context.err_at(self, source, @min_error, source.bytepos, [v2])
+        context.err_at(self, source, min_error, source.bytepos, [v2])
       end
 
       def triple_match(source, context, consume_all)
         success, v1 = @parslet.apply(source, context, false)
         unless success
-          return context.err_at(self, source, @min_error, source.bytepos,
+          return context.err_at(self, source, min_error, source.bytepos,
                                 [v1])
         end
 
         success, v2 = @parslet.apply(source, context, false)
         unless success
-          return context.err_at(self, source, @min_error, source.bytepos,
+          return context.err_at(self, source, min_error, source.bytepos,
                                 [v2])
         end
 
         success, v3 = @parslet.apply(source, context, consume_all)
         return ok([@result_tag, v1, v2, v3]) if success
 
-        context.err_at(self, source, @min_error, source.bytepos, [v3])
+        context.err_at(self, source, min_error, source.bytepos, [v3])
       end
 
       # General repetition: builds the tagged result Array in place so
@@ -205,7 +212,7 @@ module Parsanol
         # Check minimum bound
         if occurrence < @min
           source.bytepos = start_pos
-          return context.err_at(self, source, @min_error, start_pos,
+          return context.err_at(self, source, min_error, start_pos,
                                 failure_children(last_failure))
         end
 
@@ -283,7 +290,7 @@ module Parsanol
         if occurrence < @min
           context.release_array(positions)
           source.bytepos = start_pos
-          return context.err_at(self, source, @min_error, start_pos,
+          return context.err_at(self, source, min_error, start_pos,
                                 failure_children(last_failure))
         end
 
@@ -303,7 +310,7 @@ module Parsanol
         # Check minimum
         if occurrence < @min
           source.bytepos = start_pos
-          return context.err_at(self, source, @min_error, start_pos,
+          return context.err_at(self, source, min_error, start_pos,
                                 failure_children(last_failure))
         end
 

data/lib/parsanol/native/serializer.rb

@@ -334,7 +334,10 @@ module Parsanol
       inner_id = serialize_atom(atom.wrapped_atom)
       payload = {
         "atom" => inner_id,
-        "rules" => atom.capturers.map { |marker, label| [marker, label.to_s] },
+        # a whitespace-only trivia declaration (whitespace: :space with
+        # no capture:) has no capturer map — the wire field is optional
+        # (relaton with the expressir grammar, parsanol-ruby#180)
+        "rules" => atom.capturers&.map { |marker, label| [marker, label.to_s] } || [],
       }
       # parsanol-ruby#180: the optional whitespace kind — units that
       # match no marker record under it (source-preserving grammars).

data/lib/parsanol/native.rb

@@ -202,6 +202,38 @@ module Parsanol
         stats
       end
 
+      # True when the grammar carries no atoms the native tier cannot
+      # express (Dynamic callbacks, artifact custom bindings). Cached by
+      # grammar identity — the scan walks the atom tree once.
+      def native_expressible?(grammar)
+        root = grammar.is_a?(Parsanol::Parser) ? grammar.root : grammar
+        cache = (@expressible_cache ||= {}.compare_by_identity)
+        cache.fetch(root) do
+          expressible = !contains_inexpressible?(root, {}.compare_by_identity)
+          cache[root] = expressible
+        end
+      end
+
+      def contains_inexpressible?(atom, seen)
+        return false if seen.key?(atom)
+
+        seen[atom] = true
+        case atom
+        when Parsanol::Atoms::Dynamic, Parsanol::Atoms::CustomRef then true
+        when Parsanol::Atoms::Sequence, Parsanol::Atoms::Alternative
+          children = atom.respond_to?(:parslets) ? atom.parslets : atom.alternatives
+          children.any? { |child| contains_inexpressible?(child, seen) }
+        when Parsanol::Atoms::Entity, Parsanol::Atoms::Repetition,
+             Parsanol::Atoms::Named, Parsanol::Atoms::Capture, Parsanol::Atoms::Ignored,
+             Parsanol::Atoms::Trivia, Parsanol::Atoms::TriviaCapture, Parsanol::Atoms::Lookahead
+          inner = atom.respond_to?(:parslet) ? atom.parslet : nil
+          inner ||= atom.wrapped_atom if atom.respond_to?(:wrapped_atom)
+          inner && contains_inexpressible?(inner, seen)
+        else
+          false
+        end
+      end
+
       # Translates a native backend failure into the Parsanol error protocol.
       #
       # When the grammar atom is at hand, reparses through the pure Ruby
@@ -227,9 +259,19 @@ module Parsanol
         # across long parses (#123).
         message = error.message
         if parsanol_grammar && (pos_str = message[NATIVE_POS_MARKER, 1])
+          # The interpreter reparse exists to RECOVER grammars the
+          # native tier cannot express (Dynamic/CustomRef atoms —
+          # parsanol-ruby#80/#129). For grammars without them the
+          # native failure is authoritative and the deepest-position
+          # diagnostics ride in this message — reparsing through the
+          # interpreter buys nothing and, on capture-heavy injected
+          # grammars, explodes (#190: the interpreter memo never
+          # stores capture-spanning outcomes).
           source = Parsanol::Source.new(input)
-          success, value = grammar.run_with_context(source, nil, true)
-          return grammar.finalize_result(value) if success
+          unless native_expressible?(grammar)
+            success, value = grammar.run_with_context(source, nil, true)
+            return grammar.finalize_result(value) if success
+          end
 
           pos = pos_str.to_i
           msg = message.sub(NATIVE_POS_MARKER, "")

data/lib/parsanol/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: parsanol
 version: !ruby/object:Gem::Version
-  version: 1.3.83
+  version: 1.3.85
 platform: arm-linux
 authors:
 - Ribose Inc.
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2026-10-08 00:00:00.000000000 Z
+date: 2026-10-09 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