parsanol 1.3.100-aarch64-linux → 1.3.101-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ffe9cf736fae27a11f941c38eaa1ec8f5ad6a67af74a81952d6a2a39478cd69d
-  data.tar.gz: 5a35dd607a8ca943fb12da09ce8f90a6e9c15efaddb589e3861ab6b71ed646f6
+  metadata.gz: 85697303ffb8cb62ebb1208abc799e13e7ce23075778507e00d9141e7f25c9bb
+  data.tar.gz: 6238cca1d4d96d79a98bb4ac9b3dc2a1414c4e91866d930b2e38ab2a731bcf96
 SHA512:
-  metadata.gz: 4426f5e8c9a6073f95582e6ffbaec7d3efdd4b2cea1525db7cadc6baf1b64b4394ff1da62758b72b171c86a4d9134c09b0b104f408f35ec871b7eeaead0853d6
-  data.tar.gz: 8196495a9b452106dd4f1ef500b16e5dedadb06984b605629ae473051af4a4fb18a79fbe53b04f8c325f6c6f9142b904d6ee34b51d5e10e2c0bb1546d2841d11
+  metadata.gz: 727fe32b864fabf84910df147d2739f77feff1954eae6c8c56718360e902ad5d4fbba04d01e7f70e257168d75e7f9c835dd9c96f4778b62afcb098c6f68b7d51
+  data.tar.gz: b33624dd05ee196ed99cc4b579d65d9e3b5894487928069d5b85908c8afe9b7dae9e82b418f77d0b329f9ace95442b14bf2e94d3b76076c6543a6b8b4eb8f072

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: 40823664 bytes
-sha256: 74eadd193ef8d65d50ee57835773ce7c815f6ce9ce795ffebb039c2db1fb1292
+size: 40713576 bytes
+sha256: 9046a412696fbea40f4abd5a490259c0238b129077d12c50f547a07a6898a3a2

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: 41058696 bytes
-sha256: b6a5f7b526422c4766de9b1d45eaa82c99cf59c7fa330aa2af832b607a2f71f8
+size: 40948672 bytes
+sha256: 2baac404ddacf6abfd49f0603b886aede63153b76f800213bc5e47905322ecfc

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: 41054344 bytes
-sha256: 1c95bcd0337a6961284fed89522e1a446cc90e21369a2994a5f62414c98ccf85
+size: 40944224 bytes
+sha256: 1156950191ccfa3f28bd3b4b73c5e5134d8602f3298a96ca6807713c4c4acfbe

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: 41064400 bytes
-sha256: 3921a83255cd10483c05b9d8c65d170d4dce6379aee2415adc56b85c3dabdf77
+size: 40954248 bytes
+sha256: 20539d7248054b4ccc12d1ced93f60f8a5565b8a215f41cf0bbb94de30c891e7

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/native/libparsanol.so

@@ -1,4 +1,4 @@
 [diffend] Oversized file quarantined before diffing.
 name: data/lib/parsanol/native/libparsanol.so
-size: 36611864 bytes
-sha256: db77c7d151957854ca658a95d3edbf03bbf0df6032a9f16779b57816b2c83068
+size: 36503920 bytes
+sha256: 3edc47eb5bb795d4ffc067e423fe23a20eb513b1454686e3e146a1d7bc43fd87

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.100"
+  VERSION = "1.3.101"
 end

metadata

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