parsanol 1.3.87 → 1.3.89

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a0b4e99564a7a93dc454c5e004acb05f2fb6884dc993a75c3eb30565c0360687
-  data.tar.gz: 64ce48196a227e8c4f73dbc1d16a5415a278ef8a7730aaa7c8e85b45b28e75b3
+  metadata.gz: c14d89aab19e9406bc569b378659d7a1ca0b058490e4e4345c3eeff82eb49d06
+  data.tar.gz: 326c235976048e27e9bb6ad07a5ab9efa295a39b58e19b0ff366456f68cdeeac
 SHA512:
-  metadata.gz: 2fde0240109a63a418d2851ca9578293934c784a0e14c74ecf74032dab99c361c729fdb468c4a4c8fdbc39e0f836a00a04202ccc7cfc96485230adfe636c7772
-  data.tar.gz: 516e9a87cc5577b0f00d1f994783cb0da6132105052f466f3ed4afb45b41445d29234d96443c15e39b1557d14c93395457c10d9bc5b4a2d7d30ef8393dcc4ae1
+  metadata.gz: 05fc2044f427fc9f63ca67e59b4f364384d8905bfe3429d0133925497f5fe026f479c1ffea63a04edf3d9e3da442c4f1982946a756d3748d2475954cc28067b0
+  data.tar.gz: 0c12c39b5dd8ae1d2ca23b049aa6ec53787497dd0ec3799fbe1dceffeddf104ec238b6b858b423312671a87b31e98f131d0fda60328c9be7d24140f6b351afd4

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

@@ -35,7 +35,7 @@ module Parsanol
         !@regex_source.nil?
       end
 
-      def try(source, _context, _consume_all)
+      def try(source, context, _consume_all)
         start = source.bytepos
         if regex?
           @compiled ||= Regexp.new("(?:#{@regex_source})\\z")
@@ -47,7 +47,10 @@ module Parsanol
             end
           matched = !behind.nil? && behind == @pattern.b
         end
-        [matched == @positive, nil]
+        return ok(nil) if matched == @positive
+
+        message = regex? ? "text behind does not match /#{@regex_source}/" : "text behind is not #{@pattern.inspect}"
+        context.err_at(self, source, message, start)
       end
 
       def to_s_inner(_prec)

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

@@ -422,7 +422,12 @@ module Parsanol
         when :rep
           Atoms::Repetition.new(build_atom(node.a), node.b, node.c)
         when :opt then Atoms::Repetition.new(build_atom(node.a), 0, 1, :maybe)
-        when :pred then Atoms::Lookahead.new(build_atom(node.b), node.a)
+        when :pred
+          if node.c == :behind
+            build_lookbehind(node)
+          else
+            Atoms::Lookahead.new(build_atom(node.b), node.a)
+          end
         when :cap
           # "" as name is the PARG spelling of Ruby parslet's
           # str("").as(:name): an always-succeeding zero-width marker
@@ -470,6 +475,41 @@ module Parsanol
         end
       end
 
+      # `!<X` / `&<X` (parsanol-ruby#197, coradoc#281): the behind
+      # guard consumes nothing and constrains only the text behind the
+      # position. A case-sensitive literal is the fixed byte window
+      # (Literal form); a character class — or builtin class reference,
+      # or case-insensitive literal — is the end-anchored flanking
+      # regex (Regex form). Anything else cannot be expressed behind.
+      def build_lookbehind(node)
+        positive = node.a
+        body = node.b
+        case body.kind
+        when :lit
+          if body.b
+            Atoms::Lookbehind.regex("(?i:#{Regexp.escape(body.a)})",
+                                    positive: positive)
+          else
+            Atoms::Lookbehind.new(body.a.bytesize, body.a, positive: positive)
+          end
+        when :class
+          Atoms::Lookbehind.regex(class_pattern(body.a), positive: positive)
+        when :ref
+          if BUILTIN_CLASSES.key?(body.a)
+            Atoms::Lookbehind.regex(class_pattern(BUILTIN_CLASSES[body.a]),
+                                    positive: positive)
+          else
+            raise CompileError,
+                  "lookbehind body must be a literal or character class " \
+                  "(got rule #{body.a.inspect})"
+          end
+        else
+          raise CompileError,
+                "lookbehind body must be a literal or character class " \
+                "(got #{body.kind.inspect})"
+        end
+      end
+
       def class_pattern(ranges)
         body = ranges.map do |lo, hi|
           if lo == hi
@@ -635,7 +675,13 @@ module Parsanol
           set
         when :opt then first_set(node.a) + [EPS]
         when :pred
-          node.a ? first_set(node.b) : Set.new([ANY])
+          # A behind-guard constrains nothing ahead: its first set is
+          # ANY for both signs.
+          if node.c == :behind
+            Set.new([ANY])
+          else
+            node.a ? first_set(node.b) : Set.new([ANY])
+          end
         when :cap then first_set(node.b)
         when :ref
           if @ref_stack.include?(node.a)

data/lib/parsanol/parg/imports.rb

@@ -76,7 +76,8 @@ module Parsanol
         when :alt then Node.new(:alt, node.a.map { |child| copy(child, prefix) })
         when :rep then Node.new(:rep, copy(node.a, prefix), node.b, node.c)
         when :opt then Node.new(:opt, copy(node.a, prefix))
-        when :pred then Node.new(:pred, node.a, copy(node.b, prefix))
+        when :pred
+          Node.new(:pred, node.a, copy(node.b, prefix), node.c)
         when :cap then Node.new(:cap, node.a, copy(node.b, prefix))
         when :ref then Node.new(:ref, "#{prefix}#{node.a}")
         else node

data/lib/parsanol/parg/lexer.rb

@@ -23,7 +23,7 @@ module Parsanol
       | (?<arrow>->)
       | (?<num>\d+)
       | (?<ident>[A-Za-z_][A-Za-z0-9_]*)
-      | (?<punct>[=\/()\[\]{}*!&:,.])
+      | (?<punct>[=\/()\[\]{}*!&:,.<])
       /x
 
       def initialize(text)

data/lib/parsanol/parg/parser.rb

@@ -296,30 +296,64 @@ 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
-        sign = nil
-        if peek&.type == :punct && %w[! &].include?(peek.value)
-          sign = advance.value == "&"
-        end
+      # 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, behind = parse_guard_sign
         node = parse_primary
+        if sign.nil?
+          node
+        else
+          Node.new(:pred, sign, node, behind ? :behind : nil)
+        end
+      end
+
+      # `!X` / `&X` are lookaheads; `!<X` / `&<X` (coradoc#281,
+      # parsanol-ruby#197) inspect the text BEHIND the position and
+      # consume nothing.
+      def parse_guard_sign
+        return [nil, false] unless peek&.type == :punct && %w[! &].include?(peek.value)
+
+        positive = advance.value == "&"
+        behind = peek&.type == :punct && peek.value == "<"
+        advance if behind
+        [positive, behind]
+      end
+
+      def capture_postfix(node)
         if peek&.type == :ident && peek.value == "as"
           advance
           node = Node.new(:cap, ident.value, node)
         end
-        sign.nil? ? node : Node.new(:pred, sign, node)
+        node
+      end
+
+      def parse_postfixed
+        sign, behind = parse_guard_sign
+        node = capture_postfix(parse_primary)
+        if sign.nil?
+          node
+        else
+          Node.new(:pred, sign, node, behind ? :behind : nil)
+        end
       end
 
       def parse_primary

data/lib/parsanol/parg/visitor.rb

@@ -53,7 +53,9 @@ module Parsanol
           Node.new(node.kind, rewrite(node.a), node.b, node.c)
         when :opt
           Node.new(node.kind, rewrite(node.a))
-        when :pred, :cap
+        when :pred
+          Node.new(node.kind, node.a, rewrite(node.b), node.c)
+        when :cap
           Node.new(node.kind, node.a, rewrite(node.b))
         else
           yield(node) || node

data/lib/parsanol/parser.rb

@@ -55,7 +55,8 @@ module Parsanol
           if skip_name
             Parsanol::Skip.inject(self, atom, skip_name,
                                   captures: self.class.skip_captures,
-                                  whitespace: self.class.skip_whitespace)[0]
+                                  whitespace: self.class.skip_whitespace,
+                                  exempt: self.class.skip_exempt)[0]
           else
             atom
           end
@@ -90,10 +91,11 @@ module Parsanol
       #   rule(:line_comment) { str("//") >> match(/[^\n]/).repeat }
       #   skip :trivia, capture: { line_comment: :line_comment }
       #
-      def skip(rule_name, capture: nil, whitespace: nil)
+      def skip(rule_name, capture: nil, whitespace: nil, exempt: nil)
         @skip_rule_name = rule_name
         @skip_captures = capture
         @skip_whitespace = whitespace
+        @skip_exempt = exempt
         nil
       end
 
@@ -114,6 +116,12 @@ module Parsanol
       def skip_whitespace
         @skip_whitespace
       end
+
+      # The declared exemption list (rule names whose bodies build
+      # without injection), or nil — see {.skip}.
+      def skip_exempt
+        @skip_exempt
+      end
     end
 
     # Delegates matching to the root rule.

data/lib/parsanol/skip.rb

@@ -20,8 +20,16 @@ module Parsanol
     # capturer's leading literal attach to the next Named capture
     # under `comments:` — the PARG `skip = trivia capture: comments`
     # shape. Whitespace-shaped units never record.
+    #
+    # +exempt+ (parsanol-ruby#195) lists rule names whose bodies build
+    # WITHOUT injection — the DSL mirror of the PARG compiler's
+    # skip_exempt_names closure. Grammars that manage part of their
+    # trivia explicitly (expressir's remark rules) must not have
+    # wrappers inside those bodies: the wrapper would consume text the
+    # rule itself captures (a remark's own spaces) and record it as
+    # pending trivia, corrupting the value and double-representing it.
     def self.inject(parser_instance, root_atom, skip_rule_name, captures: nil,
-                    whitespace: nil)
+                    whitespace: nil, exempt: nil)
       skip_atom = parser_instance.__send__(skip_rule_name)
       skip_atom = skip_atom.parslet while skip_atom.is_a?(Atoms::Entity)
 
@@ -33,7 +41,8 @@ module Parsanol
 
       markers = capturer_markers(parser_instance, captures)
       whitespace_kind = whitespace&.to_sym
-      injector = Injector.new(skip_atom, markers, whitespace_kind)
+      exempt_names = exempt.nil? ? nil : Set.new(exempt.map(&:to_s))
+      injector = Injector.new(skip_atom, markers, whitespace_kind, exempt_names)
       [injector.inject(root_atom, entry: true), skip_atom]
     end
 
@@ -102,10 +111,11 @@ module Parsanol
     # side observation). In-progress atoms mark a cycle re-entry and
     # return raw, exactly as the path-scoped set did.
     class Injector
-      def initialize(skip_atom, markers = nil, whitespace_kind = nil)
+      def initialize(skip_atom, markers = nil, whitespace_kind = nil, exempt_names = nil)
         @skip_atom = skip_atom
         @markers = markers
         @whitespace_kind = whitespace_kind
+        @exempt_names = exempt_names
         @wrapper_ids = {}.compare_by_identity
         # Results keyed per injection context: the same shared atom
         # can be reached both inside and outside repetition interiors,
@@ -199,30 +209,14 @@ module Parsanol
           when Atoms::Ignored
             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 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
-              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
+            # parsanol-ruby#195: exempt rules build without injection —
+            # the reference returns untouched, its body never walked.
+            # A wrapper inside a rule that explicitly manages trivia
+            # consumes text the rule itself captures.
+            if @exempt_names&.include?(atom.rule_name.to_s)
               atom
+            else
+              inject_entity(atom, mode)
             end
           when Atoms::Str, Atoms::Re
             mode ? atom : Atoms::Sequence.new(maybe, atom)
@@ -233,6 +227,32 @@ module Parsanol
         @memo[mode][atom] = injected
         injected
       end
+
+      # 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 the resolved body is injected 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).
+      def inject_entity(atom, mode)
+        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
     end
   end
 end

data/lib/parsanol/version.rb

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

metadata

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