parsanol 1.3.80-aarch64-linux → 1.3.81-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3db21b25c629a5b9d907cf661e4bca3274008851581374dddf81f368ee1d7a03
-  data.tar.gz: 1717436f9e2cfe65ed10360126cd8324f7e4b4daa78d6225b6d1b48dd7bb9e2d
+  metadata.gz: b0c85bb6ed37d4b272d3c2232453260631a9340aba985adaf43ff8d6be9f8b3a
+  data.tar.gz: 591430101290d9e3cfcba3b3f725263864f2daa5760c1d083276d8c64fc34dce
 SHA512:
-  metadata.gz: 94e3abd6b86e42bb47bec3ae815ea6e410aa932688a24d2180ab0b4df9dd93275296438bd39d90e9c559175281b16965cf157ac5b6653bd67ba577e5de03897d
-  data.tar.gz: 6eab4de294189656931273f67b7d78002796b02f0d38690e7b99294c3a24561441f335d84ba7b05823551e55c37444e313646a43c4d5c98b2859ff6b0ffff0e7
+  metadata.gz: 02cccef1f811a8d99a9da8dc3f19d0c2fa3d5211faa25d779d2f71b26b9fb51135649708171f2fbf9398ffb815d657b2bd2b130039f97b6a155412c059698c76
+  data.tar.gz: 643d76aabbeab125985c8841ec79eb5c9481f68b11a9e27e6922b7781238f9eb0ff42a7b4f55d6bb216bc8b9766167db0ce4a63b03ddce64f06bfc5706261d38

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: 39970840 bytes
-sha256: 2418549f6fab93c79e9ccac4bb541d78fe848f4bc77541d5fd950ec36d403dc8
+size: 40098992 bytes
+sha256: 7a192ca31b988dcb7ff09aae8c7f198366ec949ba6d643c6345f7697b733f4f2

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: 40205952 bytes
-sha256: 05caedfe18731bfcbb62ab895baab23913aeb41b54547b381fd119b68a213ac2
+size: 40334088 bytes
+sha256: a59a1e8331a9da417e8dbaefdefa59632c43094cf0c34c63a71fec3cf4bad616

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: 40213984 bytes
-sha256: de34a1df947d7a29c0b6ef3a81fde12dd7606b3b1a6a21c09ba7cdb16ae5db16
+size: 40329752 bytes
+sha256: bb046626dcb81c3ee91852c1bc42c8aa98f931abf6594e9d023331515d300562

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: 40223960 bytes
-sha256: 34f828a479cf2e1c719c23756c285456cef7560a81fa9ecec22190064156e2e6
+size: 40339776 bytes
+sha256: 43352d26128f698a3e233303d8bb8844784c12a369f9ca577a476818a1c8b5cd

data/lib/parsanol/native/libparsanol.so

@@ -1,4 +1,4 @@
 [diffend] Oversized file quarantined before diffing.
 name: data/lib/parsanol/native/libparsanol.so
-size: 35764456 bytes
-sha256: ff8bc8908504b2a1e70764ecab02dfdf252314b213bdcb7daa728e3902b4068e
+size: 35898616 bytes
+sha256: f604a8ab076f360350c20ba56652a6033209d14f91b7810142c3cbcd04bb7021

data/lib/parsanol/native/parser.rb

@@ -205,6 +205,19 @@ module Parsanol
             [:constant, atom.value.inspect]
           when ::Parsanol::Atoms::Lookbehind
             [:lookbehind, atom.count, atom.pattern, atom.positive]
+          # Subclass first: TriviaCapture < Trivia < Ignored (the same
+          # dispatch discipline as the serializer's).
+          when ::Parsanol::Atoms::TriviaCapture
+            # The capturer table differentiates capture-carrying
+            # grammars from plain-trivia ones — without it the grammar
+            # cache serves one variant's wire to every other and the
+            # wrong marker table reaches the engine (parsanol-ruby#180).
+            [:trivia_capture, atom.capturers.to_a.sort,
+             atom_structure(atom.wrapped_atom, visited)]
+          when ::Parsanol::Atoms::Trivia
+            [:trivia, atom_structure(atom.wrapped_atom, visited)]
+          when ::Parsanol::Atoms::Ignored
+            [:ignored, atom_structure(atom.wrapped_atom, visited)]
           else
             [:unknown, atom.class.name]
           end

data/lib/parsanol/parg/artifact.rb

@@ -65,24 +65,26 @@ module Parsanol
       def parse(entry_name, input, mode: :native)
         case mode
         when :native
-          if Native.available? && !envelope["dynamic"]
-            # Fast lane (parsanol-ruby#162): the per-instance atom
-            # tree rides the DSL serialization/registration caches
+          if Native.available?
+            # Fast lane (parsanol-ruby#162): Native.parse with the
+            # per-instance root atom registers the grammar once
             # (GRAMMAR_CACHE / HANDLE_CACHE keyed on the stable root
-            # atom), so an artifact parses at compiled speed after
-            # the first call. The old path re-serialized the whole
-            # grammar JSON and re-registered it per parse (~8x).
-            # Dynamic artifacts carry ruby-tier atoms their wire
-            # cannot express — they keep the interpreter.
-            begin
-              return root_atom(entry_name).parse(input, mode: :native)
-            rescue Parsanol::ParseFailed
-              # The atom-tree native path reports the root position; the
-              # wire-registration path carries the deepest-failure
-              # diagnostics (parsanol-ruby#171). Failures pay the
-              # serialization once; successes keep the fast lane.
-              return Native.parse(JSON.generate(entry(entry_name).fetch("grammar")), input)
-            end
+            # atom) and every parse after the first runs the native
+            # engine by handle — the same path a DSL parser's
+            # mode: :native takes. Atoms::Base#parse must NOT carry
+            # this lane: it ignores :mode, so it would silently run
+            # the pure-Ruby VM and its interpreter fallback (the
+            # 5-7x real-document gap in #162, and the root-position
+            # diagnostics in #171 before the wire fallback).
+            #
+            # Dynamic-flagged artifacts parse natively too (rs#204):
+            # the state atoms (StateSet/StateMatch/StateSwitch)
+            # evaluate in the engine, riding the capture store's
+            # rollback discipline. Reaching a CustomRef aborts the
+            # native pass outright — Native.parse's error path then
+            # re-runs the interpreter, so customs stay Ruby-tier with
+            # identical trees.
+            return Native.parse(root_atom(entry_name), input)
           end
 
           root_atom(entry_name).parse(input)

data/lib/parsanol/parser.rb

@@ -52,7 +52,12 @@ module Parsanol
         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
+          if skip_name
+            Parsanol::Skip.inject(self, atom, skip_name,
+                                  captures: self.class.skip_captures)[0]
+          else
+            atom
+          end
         end
       end
 
@@ -63,6 +68,13 @@ module Parsanol
       # everything it references) builds without injection; it must be
       # non-nullable. Order-independent with +root+.
       #
+      # +capture:+ (parsanol-ruby#180) declares trivia capturers — a
+      # map of rule name to kind label. Units of the skip rule
+      # matching a capturer's leading literal attach to the next
+      # Named capture under +comments:+ (the PARG
+      # `skip = trivia capture: comments` shape) instead of being
+      # discarded; whitespace-shaped units never record.
+      #
       # @example
       #   class MyParser < Parsanol::Parser
       #     rule(:spaces) { match(/[ \t]/).repeat(1) }
@@ -72,8 +84,14 @@ module Parsanol
       #     root :doc
       #   end
       #
-      def skip(rule_name)
+      # @example capturing comments
+      #   rule(:trivia) { spaces | line_comment }
+      #   rule(:line_comment) { str("//") >> match(/[^\n]/).repeat }
+      #   skip :trivia, capture: { line_comment: :line_comment }
+      #
+      def skip(rule_name, capture: nil)
         @skip_rule_name = rule_name
+        @skip_captures = capture
         nil
       end
 
@@ -82,6 +100,12 @@ module Parsanol
       def skip_rule_name
         @skip_rule_name
       end
+
+      # The declared capturer map ({rule => kind label}), or nil —
+      # see {.skip}.
+      def skip_captures
+        @skip_captures
+      end
     end
 
     # Delegates matching to the root rule.

data/lib/parsanol/skip.rb

@@ -13,7 +13,14 @@ module Parsanol
     # 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)
+    #
+    # +captures+ (parsanol-ruby#180) maps capturer rule names to kind
+    # labels (`skip :trivia, capture: { line_comment: :line }`); the
+    # injected wrapper becomes a TriviaCapture whose units matching a
+    # capturer's leading literal attach to the next Named capture
+    # under `comments:` — the PARG `skip = trivia capture: comments`
+    # shape. Whitespace-shaped units never record.
+    def self.inject(parser_instance, root_atom, skip_rule_name, captures: nil)
       skip_atom = parser_instance.__send__(skip_rule_name)
       skip_atom = skip_atom.parslet while skip_atom.is_a?(Atoms::Entity)
 
@@ -23,10 +30,62 @@ module Parsanol
               "empty loops forever at injection points"
       end
 
-      injector = Injector.new(skip_atom)
+      markers = capturer_markers(parser_instance, captures)
+      injector = Injector.new(skip_atom, markers)
       [injector.inject(root_atom, entry: true), skip_atom]
     end
 
+    # Derives each capturer's leading literal (the leftmost Str the
+    # rule can start with) and keys the marker table by it — the same
+    # derivation the PARG compiler applies to its skip declaration. A
+    # declared capturer without a derivable, non-blank literal is a
+    # declaration error: its units could never be told apart from
+    # whitespace-shaped trivia and it would silently record nothing.
+    def self.capturer_markers(parser_instance, captures)
+      return nil if captures.nil? || captures.empty?
+
+      captures.each_with_object({}) do |(rule_name, kind), markers|
+        atom = parser_instance.__send__(rule_name)
+        atom = atom.parslet while atom.is_a?(Atoms::Entity)
+        literal = leading_literal(atom)
+        if literal.nil? || literal.strip.empty?
+          raise GrammarError,
+                "skip capturer #{rule_name.inspect} has no leading " \
+                "literal: its units cannot be told apart from " \
+                "whitespace-shaped trivia"
+        end
+        markers[literal] = kind || rule_name
+      end
+    end
+
+    # The leftmost literal the atom can start with, or nil when the
+    # shape is not literal-led (alternatives with disagreeing
+    # branches, regexes, lookaheads).
+    def self.leading_literal(atom)
+      case atom
+      when Atoms::Str then atom.str
+      when Atoms::Sequence
+        atom.parslets.each do |child|
+          literal = leading_literal(child)
+          return literal if literal
+        end
+        nil
+      when Atoms::Alternative
+        first = nil
+        atom.alternatives.each do |branch|
+          literal = leading_literal(branch)
+          return nil if literal.nil? || (first && literal != first)
+
+          first ||= literal
+        end
+        first
+      when Atoms::Repetition
+        atom.min&.positive? ? leading_literal(atom.parslet) : nil
+      when Atoms::Named, Atoms::Capture, Atoms::Ignored, Atoms::Trivia
+        leading_literal(atom.parslet)
+      end
+    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
@@ -34,8 +93,9 @@ module Parsanol
     # transparency), bare terminals gain a leading wrapper, and the
     # entry root takes leading and trailing wrappers.
     class Injector
-      def initialize(skip_atom)
+      def initialize(skip_atom, markers = nil)
         @skip_atom = skip_atom
+        @markers = markers
         @wrapper_ids = {}.compare_by_identity
       end
 
@@ -50,7 +110,13 @@ module Parsanol
 
       def maybe
         @maybe ||= begin
-          wrapper = Atoms::Trivia.new(Atoms::Repetition.new(@skip_atom, 0, 1))
+          inner = Atoms::Repetition.new(@skip_atom, 0, 1)
+          wrapper =
+            if @markers
+              Atoms::TriviaCapture.new(inner, @markers)
+            else
+              Atoms::Trivia.new(inner)
+            end
           @wrapper_ids[wrapper] = true
           wrapper
         end

data/lib/parsanol/version.rb

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

metadata

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