parsanol 1.3.88 → 1.3.89

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c24632a252a0d882d2491b361a569d8e96132f5c25942660db5c531313ebe913
-  data.tar.gz: 6349b99005ed86363fc2a13943a2c4e5dd4ce3958a364d12cb82ceea4c660d64
+  metadata.gz: c14d89aab19e9406bc569b378659d7a1ca0b058490e4e4345c3eeff82eb49d06
+  data.tar.gz: 326c235976048e27e9bb6ad07a5ab9efa295a39b58e19b0ff366456f68cdeeac
 SHA512:
-  metadata.gz: 81eca9be5955bc6e28413a88622392ad25c969307a9ee3d2d29255c4c59ad543f560c06c94cbcb34044b143365ad87622115a2786b4d8e7a5dd609cb91b5d4b6
-  data.tar.gz: 943d81f3c10eb2e2e662ca1312d41c25f5b0cff23e455f5aec1d605d0be868dd0e682104980f4b46333d5e262399814d9cf2a9fa8626a578297a045218fff52e
+  metadata.gz: 05fc2044f427fc9f63ca67e59b4f364384d8905bfe3429d0133925497f5fe026f479c1ffea63a04edf3d9e3da442c4f1982946a756d3748d2475954cc28067b0
+  data.tar.gz: 0c12c39b5dd8ae1d2ca23b049aa6ec53787497dd0ec3799fbe1dceffeddf104ec238b6b858b423312671a87b31e98f131d0fda60328c9be7d24140f6b351afd4

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

@@ -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

@@ -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.89"
 end

metadata

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