parsanol 1.3.88-aarch64-linux → 1.3.90-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3f2889605b2e93364b7966c358acff8e3d0314059d9eb9bfce8d755d330de21e
-  data.tar.gz: aa00f7c4c0791f436c3df18175c7a9f722e4da45de07d7cfe070d283fc190abd
+  metadata.gz: 0a5eae02b01793cba6627f5e7e91d63789b3b4870da638d45868b6857dc557bd
+  data.tar.gz: c32369c415f06ed312afe42cbb2621c59918b4ca10c8c1945d9b39bd69e9244f
 SHA512:
-  metadata.gz: e21fdffdb9736976ddfe2404b1f728ad2d3f273bd7e537df30f27c5926921d6f02a1ec7d24abf9104f1bf313d2b1ebc453ae0834d2cf61d7bf2452ea93f6bf91
-  data.tar.gz: bf0a69f0018caeeee808d061939bc0ca4afb8b8aa3822c79e219eed6db3b01dc78f504cc1fb2e3dd40ce12c3829bf0514fea99ad5e031c0ee148ae941babea93
+  metadata.gz: 9c3fa5252fa8b34f870c741a0df64f27edf52e587217a07c56dbaefd344259870e483def84a1260eebb867af9da4c9b18ac8d799b2d18f678a44865d9c691bfa
+  data.tar.gz: 59d50b74eb42a3451108150ba3ba99bb537f561fad472fab7b6645859688adbbda8345e0090a03c975b1da20bc365b7005b4f04ad4a30629c08a419286bc7776

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

@@ -421,8 +421,29 @@ module Parsanol
           Atoms::Alternative.new(*node.a.map { |child| build_atom(child) })
         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 :opt
+          # [ … ] is the OPTIONAL form; a bracket whose elements are all
+          # character classes reads as an optional SEQUENCE of single
+          # characters (matchable empty — captures come back nil), which
+          # is almost certainly a mis-typed multi-range class
+          # (parsanol-ruby#201). One class alone stays a legitimate
+          # optional ([ %x0D ] — CRLF handling).
+          if (content = node.a).kind == :seq && content.a.length > 1 &&
+              content.a.all? { |el| el.kind == :class }
+            raise CompileError,
+                  "brackets contain a sequence of character classes: " \
+                  "[ … ] is the optional form, so each class matches one " \
+                  "character and the sequence can match empty (an as-capture " \
+                  "over it yields nil). A multi-range character class is an " \
+                  "alternation: (%x21-2f / %x3a-40 / …)"
+          end
+          Atoms::Repetition.new(build_atom(node.a), 0, 1, :maybe)
+        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 +491,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 +691,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

@@ -317,12 +317,25 @@ module Parsanol
       # 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
+        sign, behind = parse_guard_sign
         node = parse_primary
-        sign.nil? ? node : Node.new(:pred, sign, node)
+        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)
@@ -334,12 +347,13 @@ module Parsanol
       end
 
       def parse_postfixed
-        sign = nil
-        if peek&.type == :punct && %w[! &].include?(peek.value)
-          sign = advance.value == "&"
-        end
+        sign, behind = parse_guard_sign
         node = capture_postfix(parse_primary)
-        sign.nil? ? node : Node.new(:pred, sign, node)
+        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.88"
+  VERSION = "1.3.90"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: parsanol
 version: !ruby/object:Gem::Version
-  version: 1.3.88
+  version: 1.3.90
 platform: aarch64-linux
 authors:
 - Ribose Inc.
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2026-10-09 00:00:00.000000000 Z
+date: 2026-10-10 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