parsanol 1.3.81-arm-linux → 1.3.83-arm-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 01fb11b456bec79f8f4bd6b6db018ef771260440414f75ef02f4e1520ec2caf2
-  data.tar.gz: 75e011ecd46597e4c008cbb3fd2c7e3d2bda46ba4cd716c1613a351a28d99fb8
+  metadata.gz: 7f0e6c8c662ef00d3cf9b455a90f086e2dd6ee46639b9272eaa2be08b380abee
+  data.tar.gz: 4cb4b482bdb061e18de9d6e78445916a749ea926879c4cacf7fad7663acc90d5
 SHA512:
-  metadata.gz: 602203c6a4b11eef7c4af0613212091742b1c2f4d9a0250ee27dc7e6d67a891a77c318a70feb7f38b168d64dfd6843ace2123687cc8a17713b0dd9fcb8c8bc43
-  data.tar.gz: 49afc1a994a7aeb1b3231446890bc729da4c6a76f520fa448c872437f45861fb4e912a1dfbf8476e13c37e4723dc21b3675e1e4dc8156851d645905006e0c1dd
+  metadata.gz: cf4bb4cf4dca692026c4f90999de2d9cf79fab5a4135400099108954dcc9847d65c1ea05ac04c17ef74afb55732cb046fe8b98565251200fbe1aa5c60e3c69f9
+  data.tar.gz: 61d8a00dc1e15e1128c0ef624fac1073f6dfc23c774069eb661a6b0db6f828e4d447a38e112bcff9104526e19b7405c8b85711d2b228ebcd1b414574e19d77bf

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: 33956544 bytes
-sha256: 5f8d55c4f6ab0f5bba8ea501b6ab13b16df2bfa1b63b823152d70bb86b95daaf
+size: 34008548 bytes
+sha256: 3d9692b966fef81325ab09a430d755a70669b1bde6ec1e13ab8b15e6eb92dde9

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: 34141808 bytes
-sha256: c9ec101532d77f531c2b73fd93c48add52fcd2fc0a06e4047b9e1deb9dc5c4d6
+size: 34193832 bytes
+sha256: 316cbf3f2520113134750bc699742979580a901177be3ffcf74a736afc5f20d0

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

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: 34145720 bytes
-sha256: 953c7f621b8c343ab150a9dada110ad29b94d571cc621d0be94c8235419bd2b1
+size: 34197704 bytes
+sha256: 65f68a0f5e165622e51b676edefc6d404ed9cf1dce150e3e0d6fac152c7a9581

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/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: arm-linux
 authors:
 - Ribose Inc.