parsanol 1.3.70-aarch64-linux → 1.3.72-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ad959864e0602ce21fcaf7bfb65f129a839a3edf2cdcde4c9b3c0a7873aad3cf
-  data.tar.gz: 83e386bde70fe57d16fda75c2c435d04d7f1d7923e8810b5537f4ccebee8a441
+  metadata.gz: d8b7b5097114e65d7d72074732dc20073d34c7afbc5331be4120835cce2248d4
+  data.tar.gz: a383b0f2015b12d60a68761d9be2ac9767d1b7f7e85cd0f8d614410b2d441cc4
 SHA512:
-  metadata.gz: cf8e3598041fe4c871423d4ec0ce3b310029959b6b0f58c86fe26855ad1ff9eadccfd4844315afd7f3703562281b7bc5fe560f1f14cb7d24ff33e7caf3c7a21a
-  data.tar.gz: feaf49623ed5dd39f73f5744d1207fc26ff4a5b63cc1e80a2baf510edf132ead17d76ef0eeae1e59436cebb1eb66bef895e834928516e38af1068899afe1dead
+  metadata.gz: f8f13a39f5112deb6e1ac35b819feb710ca5373f4c16dbc118b8522bd38f200b205e534b400bfe1bbf4283f50d8577872fb6b4ba6fdaf9e9703de3e9f6604db1
+  data.tar.gz: 8981e9c539c0afbe57058a1a9293b518c2d5002ba65a734d856c13a7db879f90cff771f185e453221e4ae9829c7db1174775e345b530ef80772385536e7dfadc

data/lib/parsanol/3.2/parsanol_native.so

@@ -1,4 +1,4 @@
 [diffend] Oversized file quarantined before diffing.
 name: data/lib/parsanol/3.2/parsanol_native.so
-size: 38985448 bytes
-sha256: 5deca3c49c16862198a49c09501814569b36753ef5ff5bde0dcc237ce10131a6
+size: 39097672 bytes
+sha256: 503e24e59de87efda3090bc01fcf7a2cb100225bee3001607112c3d70214c0ed

data/lib/parsanol/3.3/parsanol_native.so

@@ -1,4 +1,4 @@
 [diffend] Oversized file quarantined before diffing.
 name: data/lib/parsanol/3.3/parsanol_native.so
-size: 39228816 bytes
-sha256: b488278de783d41fcaf427d65270a6a6e69ebf3330b39ed3a38c1f466f3f418c
+size: 39332704 bytes
+sha256: a789c4bf8878d1541defa7d5581495c8b16c0f63b28dfb015d212b06c5b65455

data/lib/parsanol/3.4/parsanol_native.so

@@ -1,4 +1,4 @@
 [diffend] Oversized file quarantined before diffing.
 name: data/lib/parsanol/3.4/parsanol_native.so
-size: 39220296 bytes
-sha256: 4c9067ae6b717e8763a28e5e498e5ec7db9ddf503d6e1c5afb0a8e34c6c5f5cf
+size: 39332560 bytes
+sha256: 92ca65756238005b89c3f4eef6efc85231967d1f67bd2b6776a81725224e387e

data/lib/parsanol/4.0/parsanol_native.so

@@ -1,4 +1,4 @@
 [diffend] Oversized file quarantined before diffing.
 name: data/lib/parsanol/4.0/parsanol_native.so
-size: 39230344 bytes
-sha256: 1d0f4a65b15b9f32b8f6a5e8cf7910ed7d55e79c1d34f106b51e82e84d298586
+size: 39342616 bytes
+sha256: 12e580b24f8fb88243ee35fe7af2917d144d3e0649ae3170b301211fc66bcb5f

data/lib/parsanol/atoms/context.rb

@@ -67,6 +67,11 @@ module Parsanol
         # Injected-trivia depth: while positive, reported causes are
         # marked trivia and never surface in diagnostics.
         @trivia_depth = 0
+        # Captured trivia channel (parsanol-ruby#152): when the grammar
+        # declares `skip ... capture:`, matched trivia units land here
+        # and the NEXT successful Named capture attaches (and drains)
+        # them under `comments:`.
+        @pending_trivia = []
         @evict_threshold = 200
         @evict_counter = 0
         @evict_interval = 100
@@ -258,6 +263,34 @@ 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 }
+        nil
+      end
+
+      # Snapshot for backtracking: a failed branch must not leak its
+      # half-recorded trivia into the successful alternative.
+      def take_pending_trivia_snapshot
+        @pending_trivia.dup
+      end
+
+      def restore_pending_trivia(snapshot)
+        @pending_trivia = snapshot
+        nil
+      end
+
+      # Drains pending captured trivia (attached by the next
+      # successful Named capture). Backtracking discards whatever has
+      # not been attached yet — the caller snapshots position and
+      # restores this list alongside.
+      def take_pending_trivia
+        list = @pending_trivia
+        @pending_trivia = []
+        list
+      end
+
       # Brackets a parse inside injected trivia: causes reported while
       # the depth is positive carry the trivia flag and never surface
       # in rendered trees or deepest-failure positions.

data/lib/parsanol/atoms/named.rb

@@ -32,10 +32,32 @@ module Parsanol
       # @param consume_all [Boolean] require full consumption
       # @return [Array(Boolean, Object)] result
       def apply(source, context, consume_all)
+        trivia_before = context.take_pending_trivia_snapshot
         success, value = @parslet.apply(source, context, consume_all)
-        return [false, value] unless success
+        unless success
+          context.restore_pending_trivia(trivia_before)
+          return [false, value]
+        end
 
-        ok(wrap_result(value))
+        comments = context.take_pending_trivia
+        result = wrap_result(value)
+        result = attach_comments(result, comments) unless comments.empty?
+        ok(result)
+      end
+
+      private
+
+      # 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] } }
+        if result.is_a?(Hash)
+          result.merge(comments: list)
+        else
+          { @name => result, comments: list }
+        end
       end
 
       # Named wrappers skip caching (inner parser handles it).
@@ -60,8 +82,6 @@ module Parsanol
         @parslet.first_set
       end
 
-      private
-
       # Wraps matched value in labeled hash.
       #
       # @param matched [Object] matched value

data/lib/parsanol/atoms/trivia.rb

@@ -17,5 +17,53 @@ module Parsanol
         "trivia(#{@wrapped_atom.to_s(prec)})"
       end
     end
+
+    # parsanol-ruby#152: the skip-declared capture wrapper. Whitespace
+    # trivia stays Ignored; comment-shaped units (the grammar names the
+    # capture rules in the declaration) are recorded into the context
+    # channel for attachment to the next successful Named capture.
+    # Span discipline is unchanged: the matched bytes still contribute
+    # nothing to values or capture spans.
+    class TriviaCapture < Trivia
+      # +capturers+ maps leading-literal marker -> kind label (the
+      # compiler derives markers from each capturer rule's first Str
+      # atom, e.g. "//" => :line_comment); units not matching any
+      # marker are whitespace-shaped and stay unrecorded.
+      def initialize(atom, capturers)
+        super(atom)
+        @capturers = capturers
+      end
+
+      def apply(source, context, consume_all)
+        context.with_trivia do
+          start = source.bytepos
+          ok, _value = @wrapped_atom.apply(source, context, consume_all)
+          if ok && source.bytepos > start
+            record(source, context, start, source.bytepos)
+            return ok(nil)
+          end
+          [ok, _value]
+        end
+      end
+
+      def to_s_inner(_prec)
+        "trivia!(@wrapped_atom.to_s(prec))"
+      end
+
+      private
+
+      def record(source, context, start_pos, end_pos)
+        return unless @capturers
+
+        text = source.input[start_pos...end_pos]
+        # A trivia unit may lead with whitespace before the comment
+        # shape; markers test the comment head.
+        stripped = text.lstrip
+        marker, label = @capturers.find { |m, _label| stripped.start_with?(m) }
+        return unless marker
+
+        context.push_captured_trivia(label, stripped.strip)
+      end
+    end
   end
 end

data/lib/parsanol/native/libparsanol.so

@@ -1,4 +1,4 @@
 [diffend] Oversized file quarantined before diffing.
 name: data/lib/parsanol/native/libparsanol.so
-size: 34261680 bytes
-sha256: 384067c37f3351470b67dea550d77a6cdfd743988040da614df5ce02b8bcb1c2
+size: 34958328 bytes
+sha256: 9cb91403adcb340e2538e3e8012a9d8330681ea22bee53a7647b059d6a1b2a24

data/lib/parsanol/native/serializer.rb

@@ -78,6 +78,13 @@ module Parsanol
                      serialize_custom_ref(atom)
                    when Parsanol::Atoms::Dynamic
                      serialize_dynamic(atom)
+                   when Parsanol::Atoms::Trivia
+                     # Wire-distinct from Ignore (rs#172): the Rust
+                     # engine suppresses trivia-position diagnostics by
+                     # atom kind. Engines predating the Trivia tag
+                     # reject skip-carrying artifacts loudly (unknown
+                     # variant), which is the declared gate.
+                     serialize_trivia(atom)
                    when Parsanol::Atoms::Ignored
                      serialize_ignored(atom)
                    else
@@ -276,6 +283,15 @@ module Parsanol
             "parse this grammar with mode: :ruby"
     end
 
+    def serialize_trivia(atom)
+      inner_id = serialize_atom(atom.wrapped_atom)
+      {
+        "Trivia" => {
+          "atom" => inner_id,
+        },
+      }
+    end
+
     def serialize_ignored(atom)
       inner_id = serialize_atom(atom.wrapped_atom)
       {

data/lib/parsanol/parg/artifact.rb

@@ -71,7 +71,10 @@ module Parsanol
 
           root_atom(entry_name).parse(input)
         when :ruby
-          root_atom(entry_name).parse(input)
+          # Deepest-failure reporting parity with the native engine: the
+          # default Tree reporter keeps the most recent (root) failure,
+          # which reports position 1:1 for grammars with entry wrappers.
+          root_atom(entry_name).parse(input, reporter: ErrorReporter::Deepest.new)
         else
           raise ArgumentError, "unknown mode #{mode.inspect} (use :native or :ruby)"
         end

data/lib/parsanol/parg/compiler.rb

@@ -141,6 +141,51 @@ module Parsanol
         end
       end
 
+      # parsanol-ruby#152: capturer rules are the rules transitively
+      # referenced by the skip declaration whose leading literal is a
+      # non-whitespace marker — the comment shapes ("//", "/*", ...).
+      # Whitespace rules stay unrecorded trivia.
+      def skip_capturer_markers
+        @skip_capturer_markers ||= begin
+          markers = {}
+          seen = {}
+          collect = lambda do |node|
+            case node.kind
+            when :ref
+              next if seen[node.a]
+
+              seen[node.a] = true
+              literal = leading_literal(node.a)
+              markers[literal] = node.a.to_sym if literal && !literal.strip.empty?
+              collect.call(@document.rules[node.a]) if @document.rules.key?(node.a)
+            when :alt, :seq then node.a.each { |b| collect.call(b) }
+            when :rep, :opt, :cap then collect.call(node.a)
+            when :pred then collect.call(node.b)
+            end
+          end
+          collect.call(@document.skip_declaration)
+          markers
+        end
+      end
+
+      def leading_literal(rule_name)
+        node = @document.rules[rule_name]
+        return nil unless node
+
+        literal = nil
+        walk = lambda do |n|
+          break if literal
+
+          case n.kind
+          when :lit then literal = n.a
+          when :seq, :alt then n.a.each { |c| walk.call(c) unless literal }
+          when :rep, :opt, :cap, :pred then walk.call(n.a || n.b) unless literal
+          end
+        end
+        walk.call(node)
+        literal
+      end
+
       def skip_wrapper?(atom)
         @skip_wrapper_ids&.key?(atom)
       end
@@ -163,7 +208,13 @@ module Parsanol
           # span-joined captures — and failures inside it never surface
           # in diagnostics (rendered trees and deepest-failure
           # positions skip trivia causes).
-          wrapper = Atoms::Trivia.new(Atoms::Repetition.new(atom, 0, 1))
+          inner = Atoms::Repetition.new(atom, 0, 1)
+          wrapper =
+            if @document.skip_capture_key
+              Atoms::TriviaCapture.new(inner, skip_capturer_markers)
+            else
+              Atoms::Trivia.new(inner)
+            end
           (@skip_wrapper_ids ||= {}.compare_by_identity)[wrapper] = true
           wrapper
         end

data/lib/parsanol/parg/document.rb

@@ -10,7 +10,7 @@ module Parsanol
       Test = Struct.new(:entry, :kind, :input, :expect)
 
       attr_accessor :grammar_name, :version, :source, :uses, :skip_declaration, :skip_source,
-                    :atomic_rules
+                    :atomic_rules, :skip_capture_key
       attr_reader :rules, :bindings, :preprocess, :entries, :docs, :tests, :render, :derive,
                   :customs, :states
       # Entries authored in this file (pre-import); nil-entry tests resolve

data/lib/parsanol/parg/parser.rb

@@ -21,7 +21,7 @@ module Parsanol
       STATE_KEYWORDS = %w[custom state].freeze
       KEYWORDS = %w[grammar as alt from_table column bindings render derive
                     preprocess entry table_lookup custom state set switch
-                    skip until atomic].freeze
+                    skip until atomic capture].freeze
 
       def initialize(text)
         @tokens = Lexer.new(text).tokens
@@ -170,6 +170,15 @@ module Parsanol
             end
 
             node = parse_choice
+            # parsanol-ruby#152 phase 2: `skip = trivia capture:
+            # comments` attaches comment-shaped trivia (the rules the
+            # declaration references, identified by leading literal)
+            # to the next successful capture under `comments:`.
+            if peek&.type == :ident && peek.value == "capture"
+              advance
+              punct(":")
+              document.skip_capture_key = ident.value.to_sym
+            end
             document.skip_declaration = validate_skip_node(node)
             document.skip_source = skip_source_string(node)
             skip_newlines
@@ -260,7 +269,12 @@ module Parsanol
 
       def stop_element?
         peek.nil? || peek.type == :newline ||
-          (peek.type == :punct && ["/", ")", "]", "}"].include?(peek.value))
+          (peek.type == :punct && ["/", ")", "]", "}"].include?(peek.value)) ||
+          # `capture:` suffix terminates the skip declaration's RHS
+          # (parsanol-ruby#152); everywhere else parse_element's guard
+          # rejects it.
+          (peek&.type == :ident && peek.value == "capture" &&
+           @tokens[@pos + 1]&.type == :punct && @tokens[@pos + 1]&.value == ":")
       end
 
       def parse_element
@@ -269,6 +283,13 @@ module Parsanol
           raise ParseError, "unexpected end of input inside sequence"
         end
 
+        # `capture:` is a skip-declaration suffix, never an expression
+        # element (reserved keyword; parsanol-ruby#152).
+        if token.type == :ident && token.value == "capture" &&
+            @tokens[@pos + 1]&.type == :punct && @tokens[@pos + 1]&.value == ":"
+          raise ParseError, "capture: only modifies the skip declaration"
+        end
+
         if token.type == :num
           advance
           min = token.value.to_i

data/lib/parsanol/parser.rb

@@ -49,7 +49,38 @@ module Parsanol
       def root(rule_name)
         # Remove any existing root method before redefining
         undef_method :root if method_defined?(:root)
-        define_method(:root) { __send__(rule_name) }
+        define_method(:root) do
+          atom = __send__(rule_name)
+          skip_name = self.class.skip_rule_name
+          skip_name ? Parsanol::Skip.inject(self, atom, skip_name)[0] : atom
+        end
+      end
+
+      # Declares the grammar's skip rule (parsanol-ruby#134 DSL
+      # surface): an optional match of the named rule is injected
+      # before every terminal of the root's rule tree, and the entry
+      # takes leading and trailing skips. The referenced rule (and
+      # everything it references) builds without injection; it must be
+      # non-nullable. Order-independent with +root+.
+      #
+      # @example
+      #   class MyParser < Parsanol::Parser
+      #     rule(:spaces) { match(/[ \t]/).repeat(1) }
+      #     rule(:word) { match(/[a-z]/).repeat(1).as(:w) }
+      #     rule(:doc) { word >> str(",") >> word }
+      #     skip :spaces
+      #     root :doc
+      #   end
+      #
+      def skip(rule_name)
+        @skip_rule_name = rule_name
+        nil
+      end
+
+      # The declared skip rule name, or nil (class-level; subclasses
+      # inherit unless they declare their own).
+      def skip_rule_name
+        @skip_rule_name
       end
     end
 

data/lib/parsanol/skip.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module Parsanol
+  # Skip-rule trivia injection for Ruby-DSL grammars (the PARG surface
+  # compiles the same semantics into artifacts; see
+  # Parsanol::PARG::Compiler#inject_skip_trivia). A parser declares
+  # `skip :trivia`; the resolved rule's atom becomes the injected
+  # optional trivia wrapper before every terminal of every rule body,
+  # with the declaration's transitive closure exempt (the skip atom
+  # must not contain itself).
+  module Skip
+    # +skip_rule_name+ resolves against the parser instance's rule
+    # methods. Returns [injected_root, skip_atom] with the wrapper
+    # built and the lint applied, or raises GrammarError for a
+    # nullable skip.
+    def self.inject(parser_instance, root_atom, skip_rule_name)
+      skip_atom = parser_instance.__send__(skip_rule_name)
+      skip_atom = skip_atom.parslet while skip_atom.is_a?(Atoms::Entity)
+
+      if VM::Compiler.new.nullable?(skip_atom)
+        raise GrammarError,
+              "skip rule must be non-nullable: a skip that can match " \
+              "empty loops forever at injection points"
+      end
+
+      injector = Injector.new(skip_atom)
+      [injector.inject(root_atom, entry: true), skip_atom]
+    end
+
+    # The injection walk. Mirrors the PARG compiler's semantics:
+    # sequences interleave the wrapper before every child, alternatives
+    # and repetitions descend, named captures descend (spans stay
+    # clean — the wrapper is Trivia: Ignored + diagnostics
+    # transparency), bare terminals gain a leading wrapper, and the
+    # entry root takes leading and trailing wrappers.
+    class Injector
+      def initialize(skip_atom)
+        @skip_atom = skip_atom
+        @wrapper_ids = {}.compare_by_identity
+      end
+
+      def inject(atom, entry: false)
+        injected = walk(atom, {})
+        return injected unless entry
+
+        Atoms::Sequence.new(maybe, injected, maybe)
+      end
+
+      private
+
+      def maybe
+        @maybe ||= begin
+          wrapper = Atoms::Trivia.new(Atoms::Repetition.new(@skip_atom, 0, 1))
+          @wrapper_ids[wrapper] = true
+          wrapper
+        end
+      end
+
+      def wrapper?(atom)
+        @wrapper_ids.key?(atom)
+      end
+
+      def walk(atom, visited)
+        return atom if visited.key?(atom)
+        return atom if atom.equal?(@skip_atom)
+
+        visited = visited.merge(atom => true)
+        case atom
+        when Atoms::Sequence
+          out = []
+          atom.parslets.each do |child|
+            injected = walk(child, visited)
+            out << maybe unless wrapper?(injected) || injected.is_a?(Atoms::Trivia)
+            out << injected
+          end
+          out.length == 1 ? out.first : Atoms::Sequence.new(*out)
+        when Atoms::Alternative
+          Atoms::Alternative.new(*atom.alternatives.map { |a| walk(a, visited) })
+        when Atoms::Repetition
+          if wrapper?(atom)
+            atom
+          else
+            Atoms::Repetition.new(walk(atom.parslet, visited), atom.min, atom.max,
+                                  atom.result_tag)
+          end
+        when Atoms::Named
+          Atoms::Named.new(walk(atom.parslet, visited), atom.name)
+        when Atoms::Lookahead
+          Atoms::Lookahead.new(walk(atom.bound_parslet, visited), atom.positive)
+        when Atoms::Ignored
+          Atoms::Ignored.new(walk(atom.wrapped_atom, visited))
+        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
+          # identity visited-set guarding recursion.
+          begin
+            walk(atom.parslet, visited)
+          rescue StandardError
+            atom
+          end
+        when Atoms::Str, Atoms::Re
+          Atoms::Sequence.new(maybe, atom)
+        else
+          atom
+        end
+      end
+    end
+  end
+end

data/lib/parsanol/version.rb

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

data/lib/parsanol/vm.rb

@@ -649,6 +649,12 @@ module Parsanol
           compile_entity(atom, consume_all)
         when Parsanol::Atoms::Lookahead
           compile_lookahead(atom, consume_all)
+        when Parsanol::Atoms::TriviaCapture
+          # Captured trivia records into the context channel at match
+          # time (parsanol-ruby#152); the bytecode program has no
+          # channel, so the interpreter (which does) must own the
+          # grammar. Declining here routes program_for to :fallback.
+          nil
         when Parsanol::Atoms::Ignored
           inner = atom.wrapped_atom
           return nil if inner.nil?

data/lib/parsanol.rb

@@ -290,6 +290,7 @@ module Parsanol
   autoload :Pattern, "parsanol/pattern"
   autoload :Transform, "parsanol/transform"
   autoload :VM, "parsanol/vm"
+  autoload :Skip, "parsanol/skip"
   autoload :Parser, "parsanol/parser"
   autoload :ErrorReporter, "parsanol/error_reporter"
   autoload :Scope, "parsanol/scope"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: parsanol
 version: !ruby/object:Gem::Version
-  version: 1.3.70
+  version: 1.3.72
 platform: aarch64-linux
 authors:
 - Ribose Inc.
@@ -138,6 +138,7 @@ files:
 - lib/parsanol/rig/rspec.rb
 - lib/parsanol/rope.rb
 - lib/parsanol/scope.rb
+- lib/parsanol/skip.rb
 - lib/parsanol/slice.rb
 - lib/parsanol/source.rb
 - lib/parsanol/source/line_cache.rb