parsanol 1.3.81-aarch64-linux → 1.3.83-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b0c85bb6ed37d4b272d3c2232453260631a9340aba985adaf43ff8d6be9f8b3a
-  data.tar.gz: 591430101290d9e3cfcba3b3f725263864f2daa5760c1d083276d8c64fc34dce
+  metadata.gz: 9d77e5143a8bb36ec74223556d54b300f26b80adc0c28c1c192712b69374ca17
+  data.tar.gz: 49a1036eb86a943aebc9ec08e37c0f5fbf6b302480f928e36d91b502d327f03f
 SHA512:
-  metadata.gz: 02cccef1f811a8d99a9da8dc3f19d0c2fa3d5211faa25d779d2f71b26b9fb51135649708171f2fbf9398ffb815d657b2bd2b130039f97b6a155412c059698c76
-  data.tar.gz: 643d76aabbeab125985c8841ec79eb5c9481f68b11a9e27e6922b7781238f9eb0ff42a7b4f55d6bb216bc8b9766167db0ce4a63b03ddce64f06bfc5706261d38
+  metadata.gz: 718f9b08d6cba2a180e07f7e59783fae4c322dc27c991be78a3a814d7bfce669620dc3d459eb8d6399428ee60f543f33dba9eeda4412306b04466cdc0d02aae3
+  data.tar.gz: 6683bd143dc36f15c0c964d1b3b95a0d0bce3801fa1535f7a3672560899466bd4ed2deaecd9f0f1da7bee71eeab4afc8e493b1fe3628cd9e7f3c8cc74d362f3b

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: 40098992 bytes
-sha256: 7a192ca31b988dcb7ff09aae8c7f198366ec949ba6d643c6345f7697b733f4f2
+size: 40172512 bytes
+sha256: 359ae26a1f3e2f13c0aba4eceb7f03653e1189a5cc9b8173215ce9861a0005f1

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: 40334088 bytes
-sha256: a59a1e8331a9da417e8dbaefdefa59632c43094cf0c34c63a71fec3cf4bad616
+size: 40407592 bytes
+sha256: e3c5a2bade542954a2a4ca002ac51324b73d70bb35af0083c10708c878616411

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: 40329752 bytes
-sha256: bb046626dcb81c3ee91852c1bc42c8aa98f931abf6594e9d023331515d300562
+size: 40407448 bytes
+sha256: 0036df3e435906993e26973bd69a3330171b69ef8e9e001ed29760bb54ffffee

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: 40339776 bytes
-sha256: 43352d26128f698a3e233303d8bb8844784c12a369f9ca577a476818a1c8b5cd
+size: 40417504 bytes
+sha256: 6bcf4690e25658d3050046c39e9d496bd45e0d92ac66b9acb7eabb077fad2c5d

data/lib/parsanol/atoms/sequence.rb

@@ -18,14 +18,25 @@ module Parsanol
       def initialize(*components)
         super()
         @parslets = components
-
-        # Pre-built error message
-        @fail_msg = "Failed to match sequence (#{inspect})"
+        # The failure message renders LAZILY (error_msgs): constructing
+        # sequences is hot-path work for the builder/injector, and
+        # stringifying the whole subtree eagerly is exponential on
+        # shared cross-referencing grammars (parsanol-ruby#180 side
+        # observation: a 25-rule Fibonacci-shaped grammar took 6s).
+        @fail_msg = nil
       end
 
       # Error messages hash (for compatibility)
       def error_msgs
-        { failed: @fail_msg }
+        { failed: fail_msg }
+      end
+
+      # Rendered lazily (see initialize); construction is hot-path
+      # builder/injector work and stringifying the whole subtree
+      # eagerly is exponential on shared cross-referencing grammars
+      # (parsanol-ruby#180 side observation).
+      def fail_msg
+        @fail_msg ||= "Failed to match sequence (#{inspect})"
       end
 
       # Appends a parser to this sequence with flattening.
@@ -104,7 +115,7 @@ module Parsanol
       # Single element sequence
       def match_single(parser, source, context, consume_all)
         success, value = parser.apply(source, context, consume_all)
-        return context.err(self, source, @fail_msg, [value]) unless success
+        return context.err(self, source, fail_msg, [value]) unless success
 
         ok([:sequence, value])
       end
@@ -112,10 +123,10 @@ module Parsanol
       # Two-element sequence
       def match_pair(p1, p2, source, context, consume_all)
         success, v1 = p1.apply(source, context, false)
-        return context.err(self, source, @fail_msg, [v1]) unless success
+        return context.err(self, source, fail_msg, [v1]) unless success
 
         success, v2 = p2.apply(source, context, consume_all)
-        return context.err(self, source, @fail_msg, [v2]) unless success
+        return context.err(self, source, fail_msg, [v2]) unless success
 
         ok([:sequence, v1, v2])
       end
@@ -123,13 +134,13 @@ module Parsanol
       # Three-element sequence
       def match_triple(p1, p2, p3, source, context, consume_all)
         success, v1 = p1.apply(source, context, false)
-        return context.err(self, source, @fail_msg, [v1]) unless success
+        return context.err(self, source, fail_msg, [v1]) unless success
 
         success, v2 = p2.apply(source, context, false)
-        return context.err(self, source, @fail_msg, [v2]) unless success
+        return context.err(self, source, fail_msg, [v2]) unless success
 
         success, v3 = p3.apply(source, context, consume_all)
-        return context.err(self, source, @fail_msg, [v3]) unless success
+        return context.err(self, source, fail_msg, [v3]) unless success
 
         ok([:sequence, v1, v2, v3])
       end
@@ -148,7 +159,7 @@ module Parsanol
           success, value = components[idx].apply(source, context, must_consume)
 
           unless success
-            return context.err(self, source, @fail_msg, [value])
+            return context.err(self, source, fail_msg, [value])
           end
 
           result[idx + 1] = value

data/lib/parsanol/atoms/trivia.rb

@@ -28,12 +28,16 @@ module Parsanol
       # +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.
-      attr_reader :capturers
+      # marker are whitespace-shaped and stay unrecorded — unless
+      # +whitespace_kind+ is declared (parsanol-ruby#180): every
+      # unit then records under that label, giving source-preserving
+      # grammars the full ordered trivia stream.
+      attr_reader :capturers, :whitespace_kind
 
-      def initialize(atom, capturers)
+      def initialize(atom, capturers, whitespace_kind: nil)
         super(atom)
         @capturers = capturers
+        @whitespace_kind = whitespace_kind
       end
 
       def apply(source, context, consume_all)
@@ -55,16 +59,16 @@ module Parsanol
       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)
+        marker, label = @capturers&.find { |m, _label| stripped.start_with?(m) }
+        if marker
+          context.push_captured_trivia(label, stripped.strip)
+        elsif @whitespace_kind
+          context.push_captured_trivia(@whitespace_kind, text)
+        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: 35898616 bytes
-sha256: f604a8ab076f360350c20ba56652a6033209d14f91b7810142c3cbcd04bb7021
+size: 35976496 bytes
+sha256: eae3f380df547353fdda1c2d515d9dd59355b36250c9af6152459d18df0d0d63

data/lib/parsanol/native/serializer.rb

@@ -332,12 +332,16 @@ module Parsanol
 
     def serialize_trivia_capture(atom)
       inner_id = serialize_atom(atom.wrapped_atom)
-      {
-        "TriviaCapture" => {
-          "atom" => inner_id,
-          "rules" => atom.capturers.map { |marker, label| [marker, label.to_s] },
-        },
+      payload = {
+        "atom" => inner_id,
+        "rules" => atom.capturers.map { |marker, label| [marker, label.to_s] },
       }
+      # parsanol-ruby#180: the optional whitespace kind — units that
+      # match no marker record under it (source-preserving grammars).
+      # Optional on the wire: engines predating it deserialize and
+      # simply don't record whitespace units (documented caveat).
+      payload["whitespace"] = atom.whitespace_kind.to_s if atom.whitespace_kind
+      { "TriviaCapture" => payload }
     end
 
     def serialize_trivia(atom)

data/lib/parsanol/parser.rb

@@ -54,7 +54,8 @@ module Parsanol
           skip_name = self.class.skip_rule_name
           if skip_name
             Parsanol::Skip.inject(self, atom, skip_name,
-                                  captures: self.class.skip_captures)[0]
+                                  captures: self.class.skip_captures,
+                                  whitespace: self.class.skip_whitespace)[0]
           else
             atom
           end
@@ -89,9 +90,10 @@ module Parsanol
       #   rule(:line_comment) { str("//") >> match(/[^\n]/).repeat }
       #   skip :trivia, capture: { line_comment: :line_comment }
       #
-      def skip(rule_name, capture: nil)
+      def skip(rule_name, capture: nil, whitespace: nil)
         @skip_rule_name = rule_name
         @skip_captures = capture
+        @skip_whitespace = whitespace
         nil
       end
 
@@ -106,6 +108,12 @@ module Parsanol
       def skip_captures
         @skip_captures
       end
+
+      # The declared whitespace kind (units matching no capturer
+      # record under it), or nil — see {.skip}.
+      def skip_whitespace
+        @skip_whitespace
+      end
     end
 
     # Delegates matching to the root rule.

data/lib/parsanol/skip.rb

@@ -20,7 +20,8 @@ module Parsanol
     # 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)
+    def self.inject(parser_instance, root_atom, skip_rule_name, captures: nil,
+                    whitespace: nil)
       skip_atom = parser_instance.__send__(skip_rule_name)
       skip_atom = skip_atom.parslet while skip_atom.is_a?(Atoms::Entity)
 
@@ -31,7 +32,8 @@ module Parsanol
       end
 
       markers = capturer_markers(parser_instance, captures)
-      injector = Injector.new(skip_atom, markers)
+      whitespace_kind = whitespace&.to_sym
+      injector = Injector.new(skip_atom, markers, whitespace_kind)
       [injector.inject(root_atom, entry: true), skip_atom]
     end
 
@@ -92,15 +94,28 @@ module Parsanol
     # clean — the wrapper is Trivia: Ignored + diagnostics
     # transparency), bare terminals gain a leading wrapper, and the
     # entry root takes leading and trailing wrappers.
+    # The walk is a pure function of the atom subtree, so results are
+    # memoized: dense cross-referencing grammars (expressir's ~250
+    # rules) revisit shared subtrees once per referencing path, which
+    # made the path-scoped visited-set exponential — a 25-rule
+    # Fibonacci-shaped grammar took 6.2s to build (parsanol-ruby#180
+    # side observation). In-progress atoms mark a cycle re-entry and
+    # return raw, exactly as the path-scoped set did.
     class Injector
-      def initialize(skip_atom, markers = nil)
+      def initialize(skip_atom, markers = nil, whitespace_kind = nil)
         @skip_atom = skip_atom
         @markers = markers
+        @whitespace_kind = whitespace_kind
         @wrapper_ids = {}.compare_by_identity
+        # Results keyed per injection context: the same shared atom
+        # can be reached both inside and outside repetition interiors,
+        # and the refinement injects differently there.
+        @memo = { true => {}.compare_by_identity, false => {}.compare_by_identity }
+        @in_progress = { true => {}.compare_by_identity, false => {}.compare_by_identity }
       end
 
       def inject(atom, entry: false)
-        injected = walk(atom, {})
+        injected = walk(atom, false)
         return injected unless entry
 
         Atoms::Sequence.new(maybe, injected, maybe)
@@ -112,8 +127,9 @@ module Parsanol
         @maybe ||= begin
           inner = Atoms::Repetition.new(@skip_atom, 0, 1)
           wrapper =
-            if @markers
-              Atoms::TriviaCapture.new(inner, @markers)
+            if @markers || @whitespace_kind
+              Atoms::TriviaCapture.new(inner, @markers,
+                                       whitespace_kind: @whitespace_kind)
             else
               Atoms::Trivia.new(inner)
             end
@@ -126,50 +142,67 @@ module Parsanol
         @wrapper_ids.key?(atom)
       end
 
-      def walk(atom, visited)
-        return atom if visited.key?(atom)
+      # +rep_interior+: the d54a29e refinement (PARG's owner-set
+      # semantics, now aligned for the DSL): no injection inside
+      # repetition interiors except through rule references — their
+      # bodies are fresh injection scopes. Wrapping char-level
+      # terminals inside a repetition consumes trivia within the
+      # ENCLOSING capture's scope and mis-attaches recorded units when
+      # the iteration fails.
+      def walk(atom, rep_interior)
+        cached = @memo[rep_interior][atom]
+        return cached if cached
+        return atom if @in_progress[rep_interior].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
+        @in_progress[rep_interior][atom] = true
+        injected =
+          case atom
+          when Atoms::Sequence
+            out = []
+            atom.parslets.each do |child|
+              walked = walk(child, rep_interior)
+              unless rep_interior || wrapper?(walked) || walked.is_a?(Atoms::Trivia)
+                out << maybe
+              end
+              out << walked
+            end
+            out.length == 1 ? out.first : Atoms::Sequence.new(*out)
+          when Atoms::Alternative
+            Atoms::Alternative.new(*atom.alternatives.map { |a| walk(a, rep_interior) })
+          when Atoms::Repetition
+            if wrapper?(atom)
+              atom
+            else
+              Atoms::Repetition.new(walk(atom.parslet, true), atom.min, atom.max,
+                                    atom.result_tag)
+            end
+          when Atoms::Named
+            Atoms::Named.new(walk(atom.parslet, rep_interior), atom.name)
+          when Atoms::Lookahead
+            Atoms::Lookahead.new(walk(atom.bound_parslet, rep_interior), atom.positive)
+          when Atoms::Ignored
+            Atoms::Ignored.new(walk(atom.wrapped_atom, rep_interior))
+          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 in-progress set guarding recursion. A rule body is a
+            # fresh injection scope even inside a repetition interior —
+            # the d54a29e exception is for rule-reference children.
+            begin
+              walk(atom.parslet, false)
+            rescue StandardError
+              atom
+            end
+          when Atoms::Str, Atoms::Re
+            rep_interior ? atom : Atoms::Sequence.new(maybe, 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
+        @in_progress[rep_interior].delete(atom)
+        @memo[rep_interior][atom] = injected
+        injected
       end
     end
   end

data/lib/parsanol/version.rb

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

metadata

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