parsanol 1.3.80-arm-linux → 1.3.81-arm-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '082b8651b4be9f5cfa8579ddd021a01b76e72a00f8a5ee108f2674c1c8990bfd'
-  data.tar.gz: b5f94c8e10d8156c10873e9d5eebad3f4395307ed3f13b4df9bab939333e6a82
+  metadata.gz: 01fb11b456bec79f8f4bd6b6db018ef771260440414f75ef02f4e1520ec2caf2
+  data.tar.gz: 75e011ecd46597e4c008cbb3fd2c7e3d2bda46ba4cd716c1613a351a28d99fb8
 SHA512:
-  metadata.gz: 1c9b597c365b5c7bd2d79aca132450dd8a93b03129a26a95403195b1b68722938b26baec0e4929f772f8a917daacada8cdbf11a5daf62ef3d5b2e52142bade4f
-  data.tar.gz: fe3d1efcd398ac36c28dd230d07593b96293ce827725d12972a8f7e7abe9b21ebcab653356d3c0794c2fabd9bc156dbabb1b931c2dfd06d0646d2b6770fa8d14
+  metadata.gz: 602203c6a4b11eef7c4af0613212091742b1c2f4d9a0250ee27dc7e6d67a891a77c318a70feb7f38b168d64dfd6843ace2123687cc8a17713b0dd9fcb8c8bc43
+  data.tar.gz: 49afc1a994a7aeb1b3231446890bc729da4c6a76f520fa448c872437f45861fb4e912a1dfbf8476e13c37e4723dc21b3675e1e4dc8156851d645905006e0c1dd

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: 33857428 bytes
-sha256: 555fffa50043f91efe6d1003cf97ba60224c83b0118205bff2033615de4bf54d
+size: 33956544 bytes
+sha256: 5f8d55c4f6ab0f5bba8ea501b6ab13b16df2bfa1b63b823152d70bb86b95daaf

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: 34042676 bytes
-sha256: 63a27cccdad9628f8dba74a5efdf1d6993ad7b5ad69a434746608ca1df28dd9c
+size: 34141808 bytes
+sha256: c9ec101532d77f531c2b73fd93c48add52fcd2fc0a06e4047b9e1deb9dc5c4d6

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: 34036828 bytes
-sha256: a7917405bf0af8cbff7095c8391970d47165543ec62fcc25518a3bd017e03397
+size: 34135964 bytes
+sha256: 42f14ef394d8a41ed832e9a9f61fbc0868056062d94df7ea62403290c5581c31

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: 34046564 bytes
-sha256: 3eb609a621681ded3508cdbb5fe6fb0ebea27419febfb58243b56625d041db51
+size: 34145720 bytes
+sha256: 953c7f621b8c343ab150a9dada110ad29b94d571cc621d0be94c8235419bd2b1

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: arm-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