parsanol 1.3.82-arm-linux → 1.3.84-arm-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 755c4aaa1b93bb1331ff3a845e21cc87b73451a63676776590fe76b17b398056
-  data.tar.gz: 46c3065db82aab1b10d5eae3ff1027772f3fcbad30d1851356fa1e7c8777db87
+  metadata.gz: 7fe58dafe54c7d48c133db50eaa7e71e289405348f4f9127a6cebb381efd648f
+  data.tar.gz: 4150bbf3e58d1f56733309bf297d249b17b1896a5f5406ae28bcd18ab93cbed0
 SHA512:
-  metadata.gz: 044e61d3fc124a973e5a03bffb3814fac6fd5c695f860a713457cd592927146c9aa328db2460ca460010ee23cb514325825a831e721f537c00fbeb9f70956f24
-  data.tar.gz: d4d50039baa8eed43d7be5232bce8a0d66e8b1f72aeac9b6c124a6ccd0673125def471e49796c78969b324cd0463696c20c30081ef1ef33a0f55a0bf7330a315
+  metadata.gz: 4c5193545cbf0c4c9d8d4993e218876192d134a6085d8ba667f241f1ee7528a8919a6603f3be1a605eecb8b2146933997c44536f5861359c652bbf0d6cfac35e
+  data.tar.gz: 837871fe2d1de062d73ed4eb47dac35e471346fb3926218b83c54fda9088fb27ba2b5a581cd4176c05854580df0ffd23dc0d6ac4223bd1024942c2d09ee6bd98

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

@@ -107,12 +107,15 @@ module Parsanol
         @markers = markers
         @whitespace_kind = whitespace_kind
         @wrapper_ids = {}.compare_by_identity
-        @memo = {}.compare_by_identity
-        @in_progress = {}.compare_by_identity
+        # Results keyed per injection context: the same shared atom
+        # can be reached both inside and outside repetition interiors,
+        # and the refinement injects differently there.
+        @memo = { true => {}.compare_by_identity, false => {}.compare_by_identity }
+        @in_progress = { true => {}.compare_by_identity, false => {}.compare_by_identity }
       end
 
       def inject(atom, entry: false)
-        injected = walk(atom)
+        injected = walk(atom, false)
         return injected unless entry
 
         Atoms::Sequence.new(maybe, injected, maybe)
@@ -139,55 +142,66 @@ module Parsanol
         @wrapper_ids.key?(atom)
       end
 
-      def walk(atom)
-        cached = @memo[atom]
+      # +rep_interior+: the d54a29e refinement (PARG's owner-set
+      # semantics, now aligned for the DSL): no injection inside
+      # repetition interiors except through rule references — their
+      # bodies are fresh injection scopes. Wrapping char-level
+      # terminals inside a repetition consumes trivia within the
+      # ENCLOSING capture's scope and mis-attaches recorded units when
+      # the iteration fails.
+      def walk(atom, rep_interior)
+        cached = @memo[rep_interior][atom]
         return cached if cached
-        return atom if @in_progress.key?(atom)
+        return atom if @in_progress[rep_interior].key?(atom)
         return atom if atom.equal?(@skip_atom)
 
-        @in_progress[atom] = true
+        @in_progress[rep_interior][atom] = true
         injected =
           case atom
           when Atoms::Sequence
             out = []
             atom.parslets.each do |child|
-              injected = walk(child)
-              out << maybe unless wrapper?(injected) || injected.is_a?(Atoms::Trivia)
-              out << injected
+              walked = walk(child, rep_interior)
+              unless rep_interior || wrapper?(walked) || walked.is_a?(Atoms::Trivia)
+                out << maybe
+              end
+              out << walked
             end
             out.length == 1 ? out.first : Atoms::Sequence.new(*out)
           when Atoms::Alternative
-            Atoms::Alternative.new(*atom.alternatives.map { |a| walk(a) })
+            Atoms::Alternative.new(*atom.alternatives.map { |a| walk(a, rep_interior) })
           when Atoms::Repetition
             if wrapper?(atom)
               atom
             else
-              Atoms::Repetition.new(walk(atom.parslet), atom.min, atom.max,
+              Atoms::Repetition.new(walk(atom.parslet, true), atom.min, atom.max,
                                     atom.result_tag)
             end
           when Atoms::Named
-            Atoms::Named.new(walk(atom.parslet), atom.name)
+            Atoms::Named.new(walk(atom.parslet, rep_interior), atom.name)
           when Atoms::Lookahead
-            Atoms::Lookahead.new(walk(atom.bound_parslet), atom.positive)
+            Atoms::Lookahead.new(walk(atom.bound_parslet, rep_interior), atom.positive)
           when Atoms::Ignored
-            Atoms::Ignored.new(walk(atom.wrapped_atom))
+            Atoms::Ignored.new(walk(atom.wrapped_atom, rep_interior))
           when Atoms::Entity
             # Rule bodies own their injection when the grammar declares
             # skip on every rule (PARG); in the DSL surface the root tree
-            # is walked once, so descend through resolved bodies with the
-            # identity visited-set guarding recursion.
+            # is walked once, so descend through resolved bodies with
+            # the in-progress set guarding recursion. A rule body is a
+            # fresh injection scope even inside a repetition interior —
+            # the d54a29e exception is for rule-reference children.
             begin
-              walk(atom.parslet)
+              walk(atom.parslet, false)
             rescue StandardError
               atom
             end
           when Atoms::Str, Atoms::Re
-            Atoms::Sequence.new(maybe, atom)
+            rep_interior ? atom : Atoms::Sequence.new(maybe, atom)
           else
             atom
           end
-        @in_progress.delete(atom)
-        @memo[atom] = injected
+        @in_progress[rep_interior].delete(atom)
+        @memo[rep_interior][atom] = injected
         injected
       end
     end

data/lib/parsanol/version.rb

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

metadata

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