parsanol 1.3.85 → 1.3.87

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 38de1565e58ea110f8732c5eec590223281787eb7922f0b885ddfa76594353e4
-  data.tar.gz: 745175be31f92a3c40bac11e846b317954dfa4abe24628802aeefb1ee1adc460
+  metadata.gz: a0b4e99564a7a93dc454c5e004acb05f2fb6884dc993a75c3eb30565c0360687
+  data.tar.gz: 64ce48196a227e8c4f73dbc1d16a5415a278ef8a7730aaa7c8e85b45b28e75b3
 SHA512:
-  metadata.gz: 133c7393222f9e29c776def04d6f7b5764d344bad9d8e7dd5ce054dcacaafca8720c266fb2f7ecd48cbcc036d462747028c42659b0b2ce271aed9ede9e56aded
-  data.tar.gz: 646eb2011402310a591dc4aec7c87a5ccf58e270d9177d5c3657dd776a0e0762765f3a7be731137cadbe57ac292922de7d58008ef2b0fc908268cc8a60433510
+  metadata.gz: 2fde0240109a63a418d2851ca9578293934c784a0e14c74ecf74032dab99c361c729fdb468c4a4c8fdbc39e0f836a00a04202ccc7cfc96485230adfe636c7772
+  data.tar.gz: 516e9a87cc5577b0f00d1f994783cb0da6132105052f466f3ed4afb45b41445d29234d96443c15e39b1557d14c93395457c10d9bc5b4a2d7d30ef8393dcc4ae1

data/lib/parsanol/atoms/base.rb

@@ -157,7 +157,11 @@ module Parsanol
       # @param outer [Integer] caller's precedence
       # @return [String]
       def to_s(outer = TOP)
-        text = label || to_s_inner(precedence)
+        # The inner text is cached per instance: renders walk the atom
+        # tree through shared references, and an uncached render is
+        # exponential on cross-referencing grammars (parsanol-ruby#190).
+        # The paren wrapper stays dynamic; the label is read live.
+        text = label || (@to_s_inner_cache ||= to_s_inner(precedence))
         outer < precedence ? "(#{text})" : text
       end
 

data/lib/parsanol/parg/compiler.rb

@@ -235,7 +235,10 @@ module Parsanol
           kids = atom.parslets.map { |child| inject_skip_trivia(child) }
           out = []
           kids.each do |child|
-            out << skip_maybe_atom unless skip_wrapper?(child)
+            # parsanol-ruby#192: no injected skip directly before a
+            # lookahead — its contract is the raw next character.
+            out << skip_maybe_atom unless skip_wrapper?(child) ||
+              child.is_a?(Atoms::Lookahead)
             out << child
           end
           out.length == 1 ? out.first : Atoms::Sequence.new(*out)
@@ -271,7 +274,11 @@ module Parsanol
           # `atomic` rules deliberately stop doing.
           Atoms::Named.new(inject_skip_trivia(atom.parslet), atom.name)
         when Atoms::Lookahead
-          Atoms::Lookahead.new(inject_skip_trivia(atom.bound_parslet), atom.positive)
+          # parsanol-ruby#192: a lookahead's contract is the RAW text
+          # ahead — injected separators inside would make keyword
+          # boundary checks examine the wrong character. Interiors
+          # stay injection-exempt, not even rule references re-scope.
+          atom
         when Atoms::Str, Atoms::Re
           # bare terminal as a whole rule body: leading trivia position
           Atoms::Sequence.new(skip_maybe_atom, atom)

data/lib/parsanol/skip.rb

@@ -109,9 +109,13 @@ module Parsanol
         @wrapper_ids = {}.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 }
+        # and the refinement injects differently there. The :exempt
+        # context (lookahead interiors, ruby#192) suppresses injection
+        # everywhere, rule references included.
+        @memo = { true => {}.compare_by_identity, false => {}.compare_by_identity,
+                  exempt: {}.compare_by_identity }
+        @in_progress = { true => {}.compare_by_identity, false => {}.compare_by_identity,
+                         exempt: {}.compare_by_identity }
       end
 
       def inject(atom, entry: false)
@@ -149,27 +153,33 @@ module Parsanol
       # 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]
+      def walk(atom, mode)
+        cached = @memo[mode][atom]
         return cached if cached
-        return atom if @in_progress[rep_interior].key?(atom)
+        return atom if @in_progress[mode].key?(atom)
         return atom if atom.equal?(@skip_atom)
 
-        @in_progress[rep_interior][atom] = true
+        @in_progress[mode][atom] = true
         injected =
           case atom
           when Atoms::Sequence
             out = []
             atom.parslets.each do |child|
-              walked = walk(child, rep_interior)
-              unless rep_interior || wrapper?(walked) || walked.is_a?(Atoms::Trivia)
+              walked = walk(child, mode)
+              # parsanol-ruby#192: no wrapper directly before a
+              # lookahead — a lookahead's contract is the raw next
+              # character, and an injected separator between a
+              # keyword and its boundary check makes the check
+              # examine the wrong character.
+              unless mode || wrapper?(walked) || walked.is_a?(Atoms::Trivia) ||
+                  walked.is_a?(Atoms::Lookahead)
                 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, rep_interior) })
+            Atoms::Alternative.new(*atom.alternatives.map { |a| walk(a, mode) })
           when Atoms::Repetition
             if wrapper?(atom)
               atom
@@ -178,30 +188,49 @@ module Parsanol
                                     atom.result_tag)
             end
           when Atoms::Named
-            Atoms::Named.new(walk(atom.parslet, rep_interior), atom.name)
+            Atoms::Named.new(walk(atom.parslet, mode), atom.name)
           when Atoms::Lookahead
-            Atoms::Lookahead.new(walk(atom.bound_parslet, rep_interior), atom.positive)
+            # parsanol-ruby#192: a lookahead's contract is the RAW
+            # text ahead — no injection inside, rule references
+            # included (an injected separator between a keyword and
+            # its boundary check makes the check examine the wrong
+            # character).
+            Atoms::Lookahead.new(walk(atom.bound_parslet, :exempt), atom.positive)
           when Atoms::Ignored
-            Atoms::Ignored.new(walk(atom.wrapped_atom, rep_interior))
+            Atoms::Ignored.new(walk(atom.wrapped_atom, mode))
           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 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.
+            # is walked once, so inject the resolved body as a fresh
+            # injection scope (even inside a repetition interior — the
+            # d54a29e exception is for rule-reference children). The
+            # reference itself stays an Entity pointing at the injected
+            # body: inlining the body into every referencing site makes
+            # every rendered string (to_s, and failure messages built
+            # from inspect) expand the grammar exponentially on
+            # cross-referencing grammars — one failing Sequence rendered
+            # a multi-gigabyte message (parsanol-ruby#190).
             begin
-              walk(atom.parslet, false)
+              body = walk(atom.parslet, mode == :exempt ? :exempt : false)
+              if body.is_a?(Atoms::Lookahead)
+                # A whole-body lookahead keeps its #192 boundary visible
+                # to enclosing sequences (no wrapper before it).
+                body
+              else
+                ref = Atoms::Entity.new(atom.rule_name) { body }
+                ref.label = atom.label if atom.label
+                ref
+              end
             rescue StandardError
               atom
             end
           when Atoms::Str, Atoms::Re
-            rep_interior ? atom : Atoms::Sequence.new(maybe, atom)
+            mode ? atom : Atoms::Sequence.new(maybe, atom)
           else
             atom
           end
-        @in_progress[rep_interior].delete(atom)
-        @memo[rep_interior][atom] = injected
+        @in_progress[mode].delete(atom)
+        @memo[mode][atom] = injected
         injected
       end
     end

data/lib/parsanol/version.rb

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

metadata

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