parsanol 1.3.103 → 1.3.104

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cb2f3b3922cef3e909c43f5c1bebf7e5a156a68557a7f0bfc218991d50cd1c29
-  data.tar.gz: 2bea7e93f51a9220f62ac555b42b8ca71a27cc23e7e38d5d869cc676a0c08bf1
+  metadata.gz: ebed37c7bde0d80cb4e89167f63c53cfb2158362fbb058a3f486cddd0e8d0ec8
+  data.tar.gz: e9b7e329d1bbd7308c3d974e82a604c52127e5ee3a3690770f887d9946c7e542
 SHA512:
-  metadata.gz: f43f0fe4283755f2f6db280b68d434f18b45e1ef4ee115b1715a084f2e72d6e8f2c0c8a251c09ba52527426ad32d0b7dacd35135b1f9b560c357201123a19cd2
-  data.tar.gz: 9e7a105627a3c128d5d56552b45b0641328a8a0e05eda4563c0ff11616b0c24c447b3f4a5a3f842f043f3902d905c38323508411ab366863394a0f62c5f90dd0
+  metadata.gz: 72cd356e1e03e260fe71c9fdbc32997b7f687bd3d47177231644ec3492a62f087a5e50377c14101e3f5224f251f88fb580c18295fbeca0003165439ba393f7e5
+  data.tar.gz: dc110763f9635a3698da2ec4663a1383c26bc110937264de005f1699e5441e3eaf475bf69c93c5def5f1b98d02dad65f9aa7e682902c70e06227bb3ea4985e24

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.103"
+  VERSION = "1.3.104"
 end

metadata

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