parsanol 1.3.69-aarch64-linux → 1.3.71-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6a5010f401ab86662e22dc17f411005f2039baccbbd8696609d8f6410554ff65
-  data.tar.gz: 1dbf808bc8ee62a2ca7100407fb02a5ad902620515896dec70ea4b11c1dd730d
+  metadata.gz: 7521a5d8e982e8a4790eb217b8c3a3f21190247b411b6862bacb4e4a3a919af3
+  data.tar.gz: 581f51a2fb7b68a7ff5a79c149338fccd63ff4e09398fa5e5a73f1479e895104
 SHA512:
-  metadata.gz: '0897db9c9ec1bc04a0e75eeeda9e7b876b582eb929150adfd5d5a712c7e8024fdb7e99d3b726bc21246a7ebb14a331b41482e1f3b47921bb81757261b95fdf2d'
-  data.tar.gz: 91c450fa01ebfd40f99605b053ebe64af71e09578cb478c6ae36d98d17566111145dac010daad992ff7a31079bc879b81e7917819c6dc4edfa5dc5906899d01e
+  metadata.gz: 398da535c6500293148c92a6616cfa9bbc7834893e8911fa38f515dad0f81dce3ab0bec8ff5281c5a1ec2f1ade77b4b8d9c23244e07606f82b10fd24b802a123
+  data.tar.gz: '0293cc80cd29a221f10bb739af8b7f41a2f33c85e23598ba1599edc67edb05a6606eb36ae119c3e929034f93a33bb0e2f31546855c5b987299a18378f31209ba'

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: 38404904 bytes
-sha256: a5d0457229599d97f525a3fc207ab3d24492d5ea16ff78861c81a0bafe105a7d
+size: 39067688 bytes
+sha256: 1336a78f2ee05d8e4599a6ee7dc70263b6774bedb1234ae109c02013c76be06c

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: 38639936 bytes
-sha256: 9bc9ce948d6ff2eb6293b77910456c2d7b9db670a25dbf23b94d88efeda8bdc7
+size: 39306936 bytes
+sha256: 1981488f1c97656d97bd2c6b2b63bcfc0bc4ca98c27ab28743dfaf32150c4ffc

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: 38639776 bytes
-sha256: 314d4a2eaecf433d927e40d83ab62b3aa645e9819a77af9b5c5a2f7d9a001a00
+size: 39310816 bytes
+sha256: c4e57e00acce9397e2a7607e74b5bf679e572db69db4a32659990f59ded86028

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: 38649776 bytes
-sha256: acaa6dab5ff22e494c80a9c905369d9f29950ca600b0620991228bc6bc0406e6
+size: 39320888 bytes
+sha256: 23eb16a3cc0a3204738f7b315571c530bdeaad70c7fee4c5e20846f4ea13064d

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: 34928224 bytes
+sha256: 30c136ad62e8cd47f56529bd1f61218985ade298ac6f0965b4a8ec43bcef8e38

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

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Parsanol
-  VERSION = "1.3.69"
+  VERSION = "1.3.71"
 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?

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: parsanol
 version: !ruby/object:Gem::Version
-  version: 1.3.69
+  version: 1.3.71
 platform: aarch64-linux
 authors:
 - Ribose Inc.