parsanol 1.3.82 → 1.3.84

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c56435897ed6f65bc101a9df1cdb0c0510917824295fa003893cdf7e447a32a4
-  data.tar.gz: 8308c7b4bc8179fbf7867ab1769c53b1f6759ce6ad8cd7ca2dc9362e8c5a3c58
+  metadata.gz: 538f5154142806cd3797526af8304d450faf55e3ea08af3215990a9abab94538
+  data.tar.gz: 5e42a6e8f10a85f3dbdcff23895ef6e745aa2af46d9cb513100094efb045817b
 SHA512:
-  metadata.gz: 7ad6958bee6a30a11ce020e95a1b084bd26155f7293c2c127c2ff264850da1df22bbde4eb1f321f8e442448492d5612adc25fc3ccd19fe8a65b3e9ea7a2f9731
-  data.tar.gz: 4e353b492c5113f197822c528bf37622b54bc6eae4d2a4bb73f171cbce7edadd00c96ed55928eda73a9d2746d68e14fb4fd212ec2c768bca30a733123a32c1c8
+  metadata.gz: d75b5ea646136ce92dcf4a811f4bd1341dd1c5372eec6e2b91d9d8734a1d3acdd8b4301f6cb671a90a5211c02444b6f2a0f5cff5d2902cb1e40fb56cf8c960e2
+  data.tar.gz: fe20987b02a24520432855e5ab081f14f8b0075fa7d4b21306ae15793942738ea5c71a64dc51db5a8acefd372161f5d7ef624f9f6c9ac42bbf129406d84b9e84

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