parsanol 1.3.70 → 1.3.71

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 46a9a34dd51e63ba24ee155131eb13326947d08cf08a9814a6d600046aead88a
-  data.tar.gz: 679d459fa6c46a6b27816c042af13b0c6e9f15ccae847786140c473731b25ebd
+  metadata.gz: 31f449debbc9026b7145e9997f9012f9b4506c9506532b37c29d7700a35c75c2
+  data.tar.gz: 0fff18b2ebfa691eca0d08937fb246e39c38cc15bc7e1c13cd82835ee2ea5be2
 SHA512:
-  metadata.gz: 5bddc1e0b863c8f50be6573f29e09b17091c95dbfd0db57c660aea348d090b681bb7d99e3870276f3b05f32fcc1944098f71777bdaf4db2b34f348c1e847fbaa
-  data.tar.gz: bbb0ce39775917e628fcc19a04d15e2f252437d6fdcfe9b9b69f33711e096b2cb9a2b9a40908177068f66e54c3dc9ceb4d4ba25396b4cfc0ac465de34667b65d
+  metadata.gz: d93e19f1581d6a55902f9d496ef8fe998e293709983b0572b2c3192f2779f26e88168c785eee43d045cabfc87e4c334168851a953ab5cb7eb3ff74a53c8149d5
+  data.tar.gz: '0818e9e2bc93e762f13dc21410f1449838df58555369b223ca91669e4c0247dc137122d3e4b10ba0a8ad56c0642ffa482cfb1d3cce157708f085ea6e3ee966c7'

data/Cargo.lock

@@ -307,34 +307,16 @@ checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
 
 [[package]]
 name = "parsanol"
-version = "0.10.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dd43c104276def3f79a54ce6e8d26642ea330c13f97d66380bd94fc057f0a849"
-dependencies = [
- "ahash",
- "getrandom 0.3.4",
- "getrandom 0.4.3",
- "hashbrown",
- "parsanol-derive 0.10.2",
- "regex",
- "regex-syntax",
- "serde",
- "serde_json",
- "sha2",
-]
-
-[[package]]
-name = "parsanol"
-version = "0.12.0"
+version = "0.12.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b3754baf8f7f9761748bac497cd60efd1bab93ff54c4212e899e27cf3f09100a"
+checksum = "dab930fe5902a8f92e8bcd45b6521a52b79b9090b89b8c6b5b867aaa7527054a"
 dependencies = [
  "ahash",
  "getrandom 0.3.4",
  "getrandom 0.4.3",
  "hashbrown",
  "magnus",
- "parsanol-derive 0.12.0",
+ "parsanol-derive",
  "regex",
  "regex-syntax",
  "serde",
@@ -344,20 +326,9 @@ dependencies = [
 
 [[package]]
 name = "parsanol-derive"
-version = "0.10.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eca430ba21d7cc2d674080d40dd37a5567e1a0acdc37faef9a9b3738b8651dd6"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 3.0.6",
-]
-
-[[package]]
-name = "parsanol-derive"
-version = "0.12.0"
+version = "0.12.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7cdc8438988a014ec5a7cb6d7891c3c467154de134b353e8790bd42d4ae2ddd5"
+checksum = "18ef2346916b3d6aca5d6ad50c0b56402cce2050d1ebeeaf5b6a0c24de110eb9"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -368,7 +339,7 @@ dependencies = [
 name = "parsanol_cdylib"
 version = "1.3.52"
 dependencies = [
- "parsanol 0.10.2",
+ "parsanol",
 ]
 
 [[package]]
@@ -377,7 +348,7 @@ version = "1.0.2"
 dependencies = [
  "log",
  "magnus",
- "parsanol 0.12.0",
+ "parsanol",
  "rb-sys",
 ]
 

data/ext/parsanol_cdylib/Cargo.toml

@@ -12,4 +12,5 @@ crate-type = ["cdylib"]
 doc = false
 
 [dependencies]
-parsanol = { version = "0.10" }
+# 0.12 carries rs#174 (native dynamic-grammar backtracking fix)
+parsanol = { version = "0.12" }

data/ext/parsanol_native/Cargo.toml

@@ -29,7 +29,9 @@ magnus = { version = "0.9" }
 
 # parsanol parser library (crates.io; 0.12 carries the rs#174 native
 # backtracking fix: dynamic-dependent memoization + outcome cache)
-parsanol = { version = "0.12.0", features = ["ruby"] }
+# parsanol parser library (crates.io; 0.12 carries the rs#174 native
+# backtracking fix: dynamic-dependent memoization + outcome replay)
+parsanol = { version = "0.12.1", features = ["ruby"] }
 
 # Logging
 log = "0.4"

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/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.70"
+  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.70
+  version: 1.3.71
 platform: ruby
 authors:
 - Ribose Inc.