parsanol 1.3.83-aarch64-linux → 1.3.85-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9d77e5143a8bb36ec74223556d54b300f26b80adc0c28c1c192712b69374ca17
-  data.tar.gz: 49a1036eb86a943aebc9ec08e37c0f5fbf6b302480f928e36d91b502d327f03f
+  metadata.gz: d2fb094f721fc4cae062cf0516e8a210ac26bb9346ca4bd5ff39397218899372
+  data.tar.gz: 16d4ec0c27c22efe0dd59ad081425bc2bd1dd7a6c3bb58411460e3feb5362bc4
 SHA512:
-  metadata.gz: 718f9b08d6cba2a180e07f7e59783fae4c322dc27c991be78a3a814d7bfce669620dc3d459eb8d6399428ee60f543f33dba9eeda4412306b04466cdc0d02aae3
-  data.tar.gz: 6683bd143dc36f15c0c964d1b3b95a0d0bce3801fa1535f7a3672560899466bd4ed2deaecd9f0f1da7bee71eeab4afc8e493b1fe3628cd9e7f3c8cc74d362f3b
+  metadata.gz: c72ae01c19db7e97fb61a5c787d4629d0ef439df72dfbbd021afbec09b0f70c8eb3e6010df1b84060cd18fe9247753157373f0576fc57476f4a982542f91c3b0
+  data.tar.gz: '09cb081d4143380cc4fc11530fa31328ead71172f30714ec5f7e240c8055c2d9d7057d817d54ee09b4e7ce9019c38fb3730bda821f59b720f6b6e1bb44b640b8'

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: aarch64-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