parsanol 1.3.102 → 1.3.104

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 01e6dfd6d0e397462e91b772baa049ab4e3b8a3dd4b4a16fa49e6ae599a93e48
-  data.tar.gz: 5c9028ae8ad50dcfa25a2e5c1e93bd1c56b93afdefec97d3fdf4d0bf20a604f9
+  metadata.gz: ebed37c7bde0d80cb4e89167f63c53cfb2158362fbb058a3f486cddd0e8d0ec8
+  data.tar.gz: e9b7e329d1bbd7308c3d974e82a604c52127e5ee3a3690770f887d9946c7e542
 SHA512:
-  metadata.gz: f7426c9cda16fa16f6d1edbcc2fc8218b8b3e2c7c60ee5322b565148d8bd5de9d076cff3a3b202679ea41a3c0cf7a21649827d1a765c43def870b81ea0e0c69d
-  data.tar.gz: 4551fd5e365e33eaf3249756248225a8c549340f36beea7e283841eb35e24fa2943c43e4a4628962153e7d1b9c0bbe272207ea95b44f7472a8d312a16b4f7ca1
+  metadata.gz: 72cd356e1e03e260fe71c9fdbc32997b7f687bd3d47177231644ec3492a62f087a5e50377c14101e3f5224f251f88fb580c18295fbeca0003165439ba393f7e5
+  data.tar.gz: dc110763f9635a3698da2ec4663a1383c26bc110937264de005f1699e5441e3eaf475bf69c93c5def5f1b98d02dad65f9aa7e682902c70e06227bb3ea4985e24

data/Cargo.lock

@@ -307,9 +307,9 @@ checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
 
 [[package]]
 name = "parsanol"
-version = "0.18.15"
+version = "0.18.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "782e03b2061221e0e3823365974743020dadc1229c1937af0a3f4e1874c5b9ef"
+checksum = "597e0971251e10f0d9fac99a9f217dc2ce8e5607df9f93d2a12a5e4d823d0ee9"
 dependencies = [
  "ahash",
  "getrandom 0.3.4",
@@ -326,9 +326,9 @@ dependencies = [
 
 [[package]]
 name = "parsanol-derive"
-version = "0.18.15"
+version = "0.18.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "679f09b2b9c9c61a20ba25bede3c48a00c2c39619125e14b10a2651a8d3d25f8"
+checksum = "342e298363272c74478384205a3d6def7905d8277945d65ad203606596de7fe6"
 dependencies = [
  "proc-macro2",
  "quote",

data/lib/parsanol/parg/artifact.rb

@@ -222,10 +222,97 @@ module Parsanol
         # initial parse's (the native FFI's coarse failure position
         # loses the deepest offset).
         captures, reparse_error = recovery_journal(entry_name, input, mode)
+        partial = recovery_partial(entry_name)
+        resyncs = []
+        if partial && reparse_error
+          items = partial.values.first
+          extended, resyncs = resync_extension(entry_name, input,
+                                               reparse_error["offset"])
+          items.concat(extended) if extended
+        end
         { "ok" => false,
           "error" => reparse_error || recovery_error(e),
           "captures" => captures,
-          "partial" => recovery_partial(entry_name) }
+          "partial" => partial,
+          "resyncs" => resyncs }
+      end
+
+      # R2 (TODO.sota/1), inferred resync on the interpreter — the same
+      # policy as the rs engine (parsanol-rs#280): from the failure
+      # offset, scan forward for the next byte position where a
+      # spine-body iteration matches with progress; the skipped span is
+      # annotated and the recovered items join the partial tree.
+      # Bounded (8 rounds, each must advance) so recovery stays linear.
+      # Returns [items, resyncs]; [nil, []] when the grammar has no
+      # resolvable spine.
+      def resync_extension(entry_name, input, cursor)
+        body_rule = spine_body_rule(entry_name)
+        return [[], []] unless body_rule
+
+        body_atom = compiler.atom_for(body_rule)
+        max = input.length
+        resyncs = []
+        items = []
+        rounds = 0
+        while rounds < 8
+          found = nil
+          scan = cursor
+          while scan < max
+            attempt = try_iteration(body_atom, input, scan)
+            if attempt && attempt[1] > scan
+              found = [scan, attempt[1], attempt[0]]
+              break
+            end
+            scan += 1
+          end
+          break unless found
+
+          skip_start, resume, value = found
+          resyncs << {
+            "offset" => cursor,
+            "skipped" => input[cursor...skip_start],
+            "resumed_at" => skip_start,
+          }
+          items << root_atom(entry_name).flatten(value)
+          cursor = resume
+          rounds += 1
+          until cursor >= max
+            attempt = try_iteration(body_atom, input, cursor)
+            break unless attempt && attempt[1] > cursor
+
+            items << root_atom(entry_name).flatten(attempt[0])
+            cursor = attempt[1]
+          end
+          break if cursor >= max
+        end
+        [items, resyncs]
+      end
+
+      # Apply the body atom at one position: [value, end_pos] on a
+      # progressing match, nil otherwise.
+      def try_iteration(atom, input, pos)
+        source = Parsanol::Source.new(input)
+        source.bytepos = pos
+        context = Parsanol::Atoms::Context.new(nil, parser_class: atom.class)
+        success, value = atom.apply(source, context, false)
+        success && source.bytepos > pos ? [value, source.bytepos] : nil
+      end
+
+      # The root rule's repetition-body rule name, when the grammar is
+      # a repetition spine (root = rep of a single rule reference).
+      # Conservative: anything but rep/opt/cap wrapping a bare ref
+      # returns nil and resync is skipped.
+      SPINE_UNWRAP_KINDS = %i[rep opt cap].freeze
+
+      def spine_body_rule(entry_name)
+        root_rule = entry(entry_name)["root"]
+        node = compiler.document.rules[root_rule.to_sym] ||
+          compiler.document.rules[root_rule]
+        while node.is_a?(Parsanol::PARG::Node) &&
+            SPINE_UNWRAP_KINDS.include?(node.kind)
+          node = node.a
+        end
+        node.is_a?(Parsanol::PARG::Node) && node.kind == :ref ? node.a : nil
       end
 
       # R1.5 (TODO.sota/1): the deepest repetition prefix the failed

data/lib/parsanol/parg/compiler.rb

@@ -40,6 +40,10 @@ module Parsanol
         end
       end
 
+      # Read access for recovery tooling (the artifact's inferred
+      # resync walks the rule graph to find the spine body).
+      attr_reader :document
+
       def initialize(document, tables_dir, bindings: nil)
         @document = document
         @tables_dir = tables_dir

data/lib/parsanol/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: parsanol
 version: !ruby/object:Gem::Version
-  version: 1.3.102
+  version: 1.3.104
 platform: ruby
 authors:
 - Ribose Inc.