parsanol 1.3.86 → 1.3.88

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 47aefbe702313d394398c0a3761f397d13f912521310b924bf84361bd336e920
-  data.tar.gz: f575935f73c5244972ed7e3cd93c0c9b9ee4de775127587d85e3e36319202808
+  metadata.gz: c24632a252a0d882d2491b361a569d8e96132f5c25942660db5c531313ebe913
+  data.tar.gz: 6349b99005ed86363fc2a13943a2c4e5dd4ce3958a364d12cb82ceea4c660d64
 SHA512:
-  metadata.gz: 1c1d2274eb415f449ee1f93d5ccd09a1ba087504ff3e842bcbf7212f40dfeac61d6cc988a3c285559b82f48f59ddc7be20a2640743fff9de1b643e5517b8ae93
-  data.tar.gz: 3730499554f40a734a38385a20e5a81bb836306ef87e19469409e7ca76fde72f311b33571e941a0cc3539be54c14f717fa86c470e742d7120c8124b799eafe1a
+  metadata.gz: 81eca9be5955bc6e28413a88622392ad25c969307a9ee3d2d29255c4c59ad543f560c06c94cbcb34044b143365ad87622115a2786b4d8e7a5dd609cb91b5d4b6
+  data.tar.gz: 943d81f3c10eb2e2e662ca1312d41c25f5b0cff23e455f5aec1d605d0be868dd0e682104980f4b46333d5e262399814d9cf2a9fa8626a578297a045218fff52e

data/Cargo.lock

@@ -307,9 +307,9 @@ checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
 
 [[package]]
 name = "parsanol"
-version = "0.18.0"
+version = "0.18.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc899494d6b94ea8df14279b7dcbac89d59ba4d1be52f7b8ffe840674c6c8e3c"
+checksum = "b059d18a92c61ba7c7c6241bb446196729dadf618e6e34c0b79935f0292d7a27"
 dependencies = [
  "ahash",
  "getrandom 0.3.4",
@@ -326,9 +326,9 @@ dependencies = [
 
 [[package]]
 name = "parsanol-derive"
-version = "0.18.0"
+version = "0.18.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b437046956f356eee0eb9b407ff1f1f6286af1f70f1af1d305c54a64c65b64e2"
+checksum = "4b9a6de83c376137ccce01cb8890427a8879b34b6ac4832cc0413c5624923001"
 dependencies = [
  "proc-macro2",
  "quote",

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/atoms/context.rb

@@ -263,10 +263,10 @@ module Parsanol
         [false, @reporter.err(*)]
       end
 
-      # Records one captured trivia unit (kind, text) for attachment to
-      # the next successful Named capture.
-      def push_captured_trivia(kind, text)
-        @pending_trivia << { kind: kind, text: text }
+      # Records one captured trivia unit (kind, text, input offset)
+      # for attachment to the next successful Named capture.
+      def push_captured_trivia(kind, text, pos)
+        @pending_trivia << { kind: kind, text: text, pos: pos }
         nil
       end
 

data/lib/parsanol/atoms/named.rb

@@ -41,7 +41,7 @@ module Parsanol
 
         comments = context.take_pending_trivia
         result = wrap_result(value)
-        result = attach_comments(result, comments) unless comments.empty?
+        result = attach_comments(result, comments, source) unless comments.empty?
         ok(result)
       end
 
@@ -50,9 +50,13 @@ module Parsanol
       # parsanol-ruby#152: trivia captured ahead of this capture rides
       # with it under `comments:`. The attachment only fires when the
       # grammar declared capture AND trivia actually preceded — key
-      # absence everywhere else keeps v1 trees byte-identical.
-      def attach_comments(result, comments)
-        list = comments.map { |unit| { unit[:kind] => unit[:text] } }
+      # absence everywhere else keeps v1 trees byte-identical. Units
+      # carry their input offset so the value is a positioned Slice,
+      # like every other capture value (native parity, ruby#180).
+      def attach_comments(result, comments, source)
+        list = comments.map do |unit|
+          { unit[:kind] => Slice.new(unit[:pos], unit[:text], source.input) }
+        end
         if result.is_a?(Hash)
           result.merge(comments: list)
         else

data/lib/parsanol/atoms/trivia.rb

@@ -61,13 +61,17 @@ module Parsanol
       def record(source, context, start_pos, end_pos)
         text = source.input[start_pos...end_pos]
         # A trivia unit may lead with whitespace before the comment
-        # shape; markers test the comment head.
+        # shape; markers test the comment head. The recorded offset
+        # must agree with the recorded content as a slice of the
+        # input: trimmed marker text starts after the unit's leading
+        # whitespace, not at the wrapper (native parity, ruby#180).
         stripped = text.lstrip
         marker, label = @capturers&.find { |m, _label| stripped.start_with?(m) }
         if marker
-          context.push_captured_trivia(label, stripped.strip)
+          context.push_captured_trivia(label, stripped.strip,
+                                       start_pos + (text.length - stripped.length))
         elsif @whitespace_kind
-          context.push_captured_trivia(@whitespace_kind, text)
+          context.push_captured_trivia(@whitespace_kind, text, start_pos)
         end
       end
     end

data/lib/parsanol/native/transformer.rb

@@ -310,9 +310,16 @@ module Parsanol
                               transformed
                             elsif is_repetition
                               if transformed.is_a?(Array)
-                                if transformed.all? do |item|
-                                  item.is_a?(Hash) && item.key?(sym_key)
-                                end
+                                if transformed.all?(Hash)
+                                  # Hash items carry their own capture
+                                  # names (parslet semantics) — the
+                                  # single-key path
+                                  # (transform_repetition_value) already
+                                  # keeps them; this multi-key path (a
+                                  # Named with a trivia attachment, or
+                                  # merged siblings) must agree — only
+                                  # unnamed items take the parent name
+                                  # per item.
                                   transformed
                                 else
                                   transformed.map { |item| { sym_key => item } }

data/lib/parsanol/parg/parser.rb

@@ -296,29 +296,49 @@ module Parsanol
           if peek&.type == :punct && peek.value == "*"
             advance
             max = peek&.type == :num ? advance.value.to_i : nil
-            node = Node.new(:rep, parse_postfixed, min, max)
+            node = Node.new(:rep, parse_rep_body, min, max)
           else
-            node = Node.new(:rep, parse_postfixed, min, min)
+            node = Node.new(:rep, parse_rep_body, min, min)
           end
-          return node
+          return capture_postfix(node)
         elsif token.type == :punct && token.value == "*"
           advance
           max = peek&.type == :num ? advance.value.to_i : nil
-          return Node.new(:rep, parse_postfixed, 0, max)
+          return capture_postfix(Node.new(:rep, parse_rep_body, 0, max))
         end
         parse_postfixed
       end
 
-      def parse_postfixed
+      # A repetition's body must not claim the `as` that follows the
+      # repetition's own closing paren (parsanol-ruby#197): the body
+      # parser is postfix-blind, and the postfix wraps the REPETITION —
+      # `*( X ) as name` captures the whole repeated run, matching the
+      # Ruby DSL's `.repeat.as(:name)`. An `as` inside the body's own
+      # parens still binds the body — write `*( ( X ) as name )` for
+      # that (naming each iteration's X).
+      def parse_rep_body
         sign = nil
         if peek&.type == :punct && %w[! &].include?(peek.value)
           sign = advance.value == "&"
         end
         node = parse_primary
+        sign.nil? ? node : Node.new(:pred, sign, node)
+      end
+
+      def capture_postfix(node)
         if peek&.type == :ident && peek.value == "as"
           advance
           node = Node.new(:cap, ident.value, node)
         end
+        node
+      end
+
+      def parse_postfixed
+        sign = nil
+        if peek&.type == :punct && %w[! &].include?(peek.value)
+          sign = advance.value == "&"
+        end
+        node = capture_postfix(parse_primary)
         sign.nil? ? node : Node.new(:pred, sign, node)
       end
 

data/lib/parsanol/skip.rb

@@ -201,12 +201,26 @@ module Parsanol
           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, mode == :exempt ? :exempt : 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

data/lib/parsanol/version.rb

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

metadata

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