parsanol 1.3.71 → 1.3.72

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 31f449debbc9026b7145e9997f9012f9b4506c9506532b37c29d7700a35c75c2
-  data.tar.gz: 0fff18b2ebfa691eca0d08937fb246e39c38cc15bc7e1c13cd82835ee2ea5be2
+  metadata.gz: bd9773776674bd865171d5b4b378628a063b0dee92e2a4442fcf3fe0182262da
+  data.tar.gz: 6e8554e163d07070a54b9255d6bed7ca348fd72fd6a8968a17308814323d0d4c
 SHA512:
-  metadata.gz: d93e19f1581d6a55902f9d496ef8fe998e293709983b0572b2c3192f2779f26e88168c785eee43d045cabfc87e4c334168851a953ab5cb7eb3ff74a53c8149d5
-  data.tar.gz: '0818e9e2bc93e762f13dc21410f1449838df58555369b223ca91669e4c0247dc137122d3e4b10ba0a8ad56c0642ffa482cfb1d3cce157708f085ea6e3ee966c7'
+  metadata.gz: fa0c3526c5ab79f7d9b6ed08e7523738cf6b46e2b8a6c30e2a021845d6bdeeabd5bb3e7ddd4d31f36725c1682ad94e650975289889c1bc991364d48bd9e2c8d7
+  data.tar.gz: ea7fd569d5a432d56583d76ec896c5a0c03ab8b769d9af7863041f02e64343ce1280ee226f450efde730bcb98bb4a0391fb7fcd03d3f490c7e35b133f6f427e1

data/Cargo.lock

@@ -307,9 +307,9 @@ checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
 
 [[package]]
 name = "parsanol"
-version = "0.12.1"
+version = "0.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dab930fe5902a8f92e8bcd45b6521a52b79b9090b89b8c6b5b867aaa7527054a"
+checksum = "126b715ffe53b3bc75ed8ff753333e350d51aaea64a0a51a6eb8588f0786d925"
 dependencies = [
  "ahash",
  "getrandom 0.3.4",
@@ -326,9 +326,9 @@ dependencies = [
 
 [[package]]
 name = "parsanol-derive"
-version = "0.12.1"
+version = "0.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "18ef2346916b3d6aca5d6ad50c0b56402cce2050d1ebeeaf5b6a0c24de110eb9"
+checksum = "6f1413076b79ef60c0af56973f8bbfddcc6034bd3cb47fbc5205fcd188bc8d79"
 dependencies = [
  "proc-macro2",
  "quote",

data/ext/parsanol_cdylib/Cargo.toml

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

data/ext/parsanol_native/Cargo.toml

@@ -29,9 +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 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"] }
+# parsanol parser library (crates.io; 0.13 carries the rs#172 Trivia
+# atom: native diagnostics skip trivia positions, matching ruby #145)
+parsanol = { version = "0.13.0", features = ["ruby"] }
 
 # Logging
 log = "0.4"

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/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.71"
+  VERSION = "1.3.72"
 end

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.71
+  version: 1.3.72
 platform: ruby
 authors:
 - Ribose Inc.
@@ -155,6 +155,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