parsanol 1.3.99-arm-linux → 1.3.101-arm-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '0449928649d5a003cea029230dccdb8d4a1cf5e15a3115d713396f256e5a4cbf'
-  data.tar.gz: 6f78bd36cb506e26a808d16d0e82cab33d1d4af239ff2850247b9ff29925e51a
+  metadata.gz: 4fd1314a9ec192bbb07d077678f6b47ee816c6aceb22f5f8c6e37eedf5437703
+  data.tar.gz: 7a1bfe5c2d16e243ae40f5c3f711888937c8fb98c18d8e6d88ce180ee551e100
 SHA512:
-  metadata.gz: dc51f046f4d0e11b562f8dc35d37eed3476cb6d6bc77f0692d5363b87a8707444f04f4416a1dfef85db1a6e3dbb551f3477145831e2daa1cf21159646c086ef6
-  data.tar.gz: 02bcffde2c4565099de61ffc31de674f24c244bbb1ac2bb5820ae5c4636d780f775ce092f57c64c2d8a47706a275899e7ea4358ffe26a93ee6b204a7b9609859
+  metadata.gz: 2fbfffa60cb521128df34e153537b2a692c7cb93e513b56f8a2fc3d00d7655504c21f7e3c6b55465d2d4d3ade007fce8a01b798191d43dddfe2a668c13895081
+  data.tar.gz: 10b1b6cef6d8490591e061d303dc264acf836313b414aeb26f016afdb089c3d27b6286c08921acfc0317fade20e9d70f1af26346d765453ce30b53107c0f9c6d

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: 34547268 bytes
-sha256: 5ffe08395738b583a3472e832256ff294510921a25ff6e53dc90c951905191ec
+size: 34471380 bytes
+sha256: b173569fc4832c4463657ee385337964d42d85f0aa13847b0c1044d2fcc55f70

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: 34732408 bytes
-sha256: c187d2bd208b1d8aef9c66f4d3188496789e48b93dc6fb59c65cbbfcd300a6ca
+size: 34656540 bytes
+sha256: 960c9d040d78fc90dbf5aa42b9b4d4685db1962a9b4ec22f905820d87a48ac26

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: 34726616 bytes
-sha256: 14dcfeb7a0bad418583ac54f7430c5212c273c5df0a3e0ae3eaba8ed14156907
+size: 34650712 bytes
+sha256: 0fd3652b9a3da3d83cca520dcee15bf02d5497ad97e3c9a23529d5813e7ef51b

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: 34736332 bytes
-sha256: 8eb3b9649e9070ee5ec045863c45cdc50a4ae76faf0c0c45fa6f26f15e503db4
+size: 34660448 bytes
+sha256: 905510a7562305c41aa2e1bb9a1a081fe8ecc42c379f02d3481d9f713d71d193

data/lib/parsanol/atoms/base.rb

@@ -236,9 +236,15 @@ module Parsanol
       end
 
       # Reports detailed error by reparsing with reporter.
+      #
+      # The default reporter is Deepest (parsanol-ruby#265): the native
+      # engine's failure diagnostics report the furthest failure, and a
+      # consumer's file:line:col degrades to "line 1 char 1" when the
+      # interpreter raises the outermost sequence instead. Explicit
+      # reporters (Tree for full cause trees) are honored unchanged.
       def report_detailed_error(input, consume_all, reporter, _initial_error)
         input.bytepos = 0
-        error_reporter = reporter || Parsanol::ErrorReporter::Tree.new
+        error_reporter = reporter || Parsanol::ErrorReporter::Deepest.new
         success, cause = run_with_context(input, error_reporter, consume_all)
 
         # Second parse should also fail

data/lib/parsanol/atoms/repetition.rb

@@ -211,6 +211,7 @@ module Parsanol
 
         # Check minimum bound
         if occurrence < @min
+          Recovery.stash_partial(source.bytepos, result[1, occurrence], @result_tag)
           source.bytepos = start_pos
           return context.err_at(self, source, min_error, start_pos,
                                 failure_children(last_failure))
@@ -218,6 +219,9 @@ module Parsanol
 
         # Check complete consumption
         if consume_all && source.chars_left.positive?
+          # R1.5: the partial run IS the best partial root — stash it
+          # before reporting the leftover-input failure.
+          Recovery.stash_partial(source.bytepos, result[1, occurrence], @result_tag)
           return context.err(self, source, @extra_error,
                              failure_children(last_failure))
         end

data/lib/parsanol/error_reporter/deepest.rb

@@ -98,12 +98,16 @@ module Parsanol
       # @return [Array<Integer, Parsanol::Cause>] [depth, deepest_leaf]
       #
       def find_deepest_leaf(node, rank = 0)
+        return [rank, node] if node.nil?
+
         best_node = node
         best_rank = rank
 
         kids = node.children
         if kids && !kids.empty?
           kids.each do |kid|
+            next if kid.nil?
+
             kid_rank, kid_node = find_deepest_leaf(kid, rank + 1)
 
             if kid_rank > best_rank

data/lib/parsanol/native.rb

@@ -282,8 +282,10 @@ module Parsanol
         if parsanol_grammar
           # No native diagnostics (e.g. incomplete-input errors): one
           # interpreter pass with the reporter attached — a success
-          # recovers the tree, a failure raises the cause tree.
-          reporter = Parsanol::ErrorReporter::Tree.new
+          # recovers the tree, a failure raises the cause tree. Deepest
+          # keeps the fallback's diagnostics at parity with the direct
+          # interpreter path (parsanol-ruby#265).
+          reporter = Parsanol::ErrorReporter::Deepest.new
           source = Parsanol::Source.new(input)
           success, value = grammar.run_with_context(source, reporter, true)
           return grammar.finalize_result(value) if success

data/lib/parsanol/parg/artifact.rb

@@ -217,14 +217,51 @@ module Parsanol
         shape = parse(entry_name, input, mode: mode)
         { "ok" => true, "shape" => shape }
       rescue Parsanol::ParseFailed => e
+        # The journaling re-parse fails at the same point with the
+        # interpreter's deepest cause — report ITS error, not the
+        # initial parse's (the native FFI's coarse failure position
+        # loses the deepest offset).
+        captures, reparse_error = recovery_journal(entry_name, input, mode)
         { "ok" => false,
-          "error" => recovery_error(e),
-          "captures" => recovery_journal(entry_name, input, mode) }
+          "error" => reparse_error || recovery_error(e),
+          "captures" => captures,
+          "partial" => recovery_partial(entry_name) }
+      end
+
+      # R1.5 (TODO.sota/1): the deepest repetition prefix the failed
+      # journaling pass matched, shaped like the root (the item array
+      # under the root rule's name). Nil when nothing matched.
+      def recovery_partial(entry_name)
+        stash = Parsanol::Recovery.take_partial
+        return nil if stash.nil?
+
+        _end_pos, items, _tag = stash
+        # The stash holds raw per-iteration results; the root atom's
+        # flatten (the same laws the success shape goes through) turns
+        # sequence-tagged iterations into their shaped values.
+        flattened = items.map { |item| root_atom(entry_name).flatten(item) }
+        root_name = entry(entry_name)["root"].to_sym
+        { root_name => flattened }
       end
 
       def recovery_error(err)
-        pos = err.parse_failure_cause&.position
-        { "offset" => pos, "message" => err.message }
+        cause = err.parse_failure_cause
+        # The raised cause can sit shallower than the real failure (a
+        # consume-all leftover reported at the partial run's end);
+        # recovery annotations carry the DEEPEST position in the cause
+        # tree — the same semantics as the rs engine's failure wire.
+        { "offset" => cause && deepest_position(cause),
+          "message" => err.message }
+      end
+
+      def deepest_position(cause)
+        max = cause.position
+        Array(cause.children).each do |child|
+          next if child.nil?
+
+          max = [max, deepest_position(child)].max
+        end
+        max
       end
 
       # Journaling re-parse — always on the Ruby engine (journaling
@@ -233,18 +270,21 @@ module Parsanol
       # by the differential specs, so the observed captures agree.
       def recovery_journal(entry_name, input, _mode)
         Parsanol::Recovery.start_journal
+        reparse_error = nil
         begin
           parse(entry_name, input, mode: :ruby)
-        rescue Parsanol::ParseFailed
+        rescue Parsanol::ParseFailed => e
           # expected: the journaling pass fails at the same point
+          reparse_error = recovery_error(e)
         end
-        Parsanol::Recovery.stop_journal.each_with_object({}) do |(name, value), out|
+        captures = Parsanol::Recovery.stop_journal.each_with_object({}) do |(name, value), out|
           # Both the initial attempt and the diagnostic re-parse journal
           # into the shared thread-local; identical observations dedupe.
           wire = value.is_a?(Slice) ? slice_wire(value) : value
           (out[name.to_s] ||= []) << wire
           out[name.to_s].uniq!
         end
+        [captures, reparse_error]
       end
 
       def slice_wire(slice)

data/lib/parsanol/recovery.rb

@@ -11,6 +11,10 @@ module Parsanol
     def start_journal
       Thread.current[:parsanol_recovery_journal] = []
       Thread.current[:parsanol_recovery_journaling] = true
+      # R1.5 partial-tree collection rides the journaling (recovery)
+      # pass: success paths never touch the stash.
+      Thread.current[:parsanol_recovery_partial] = nil
+      Thread.current[:parsanol_recovery_collect_partial] = true
     end
 
     # Stops journaling and returns the journal: [name, value] pairs in
@@ -29,5 +33,25 @@ module Parsanol
     def journaling?
       Thread.current[:parsanol_recovery_journaling] == true
     end
+
+    # R1.5: the deepest repetition prefix matched before the failure.
+    # Repetition failure paths call stash_partial; the furthest-reaching
+    # prefix wins. [end_pos, items, tag]
+    def stash_partial(end_pos, items, tag)
+      return unless Thread.current[:parsanol_recovery_collect_partial]
+      return if items.empty? # nothing matched: no partial, like rs
+
+      current = Thread.current[:parsanol_recovery_partial]
+      return if current && current[0] >= end_pos
+
+      Thread.current[:parsanol_recovery_partial] = [end_pos, items.dup, tag]
+    end
+
+    def take_partial
+      value = Thread.current[:parsanol_recovery_partial]
+      Thread.current[:parsanol_recovery_partial] = nil
+      Thread.current[:parsanol_recovery_collect_partial] = nil
+      value
+    end
   end
 end

data/lib/parsanol/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: parsanol
 version: !ruby/object:Gem::Version
-  version: 1.3.99
+  version: 1.3.101
 platform: arm-linux
 authors:
 - Ribose Inc.