parsanol 1.3.103 → 1.3.105

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cb2f3b3922cef3e909c43f5c1bebf7e5a156a68557a7f0bfc218991d50cd1c29
-  data.tar.gz: 2bea7e93f51a9220f62ac555b42b8ca71a27cc23e7e38d5d869cc676a0c08bf1
+  metadata.gz: 3954375840e755bd28df5e62048c4ec4dc94ab56a5917c839e04901e95290c2f
+  data.tar.gz: ec2e66f50dab4a8e6cc30651d9b4fe6ec468e4441a1c62b697f3a28d61e86167
 SHA512:
-  metadata.gz: f43f0fe4283755f2f6db280b68d434f18b45e1ef4ee115b1715a084f2e72d6e8f2c0c8a251c09ba52527426ad32d0b7dacd35135b1f9b560c357201123a19cd2
-  data.tar.gz: 9e7a105627a3c128d5d56552b45b0641328a8a0e05eda4563c0ff11616b0c24c447b3f4a5a3f842f043f3902d905c38323508411ab366863394a0f62c5f90dd0
+  metadata.gz: 465b6dfa7765cf143cc78bd7eab75bf8c8c7bf9d20a859930a868be5563de33e44f50e2844a519f9179d4d1dbe9836a4392042c573cf58dbd106e110bf67a26c
+  data.tar.gz: 06c14f1c1111606323b4ec1e3c895a88fbb9109440158ed68eab0094840c9ce38e366bc2e049653790257873f720755196087d16abdc29aad3afbd8d07b3af54

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
@@ -244,14 +331,33 @@ module Parsanol
         { root_name => flattened }
       end
 
+      # Recovery error wire — the rs engine's F7 shape (offset, line,
+      # column, expected at the deepest position, ranked distinct
+      # positions deepest-first), computed from the interpreter's cause
+      # tree. `message` rides along for consumers that surface the
+      # rendered text (lutaml-lml digs line/column from it).
+      # Parity with parsanol::portable::parser::MAX_RANKED_FAILURES.
+      MAX_RANKED_FAILURES = 8
+
       def recovery_error(err)
         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 }
+        return { "offset" => nil, "message" => err.message } unless cause
+
+        ranks = collect_ranks(cause)
+        offset = ranks.keys.max
+        line, column = cause.source&.line_and_column(offset)
+        {
+          "offset" => offset,
+          "line" => line,
+          "column" => column,
+          # The deepest entry mirrors ranked's head — same as the rs
+          # wire, where failure_wire and ranked[0] agree.
+          "expected" => ranks[offset] || [],
+          "ranked" => ranks.sort_by { |pos, _| -pos }
+            .first(MAX_RANKED_FAILURES)
+            .map { |pos, labels| [pos, labels] },
+          "message" => err.message,
+        }
       end
 
       def deepest_position(cause)
@@ -264,6 +370,22 @@ module Parsanol
         max
       end
 
+      # Distinct failure positions with the labels expected at each —
+      # every cause node contributes its position and message; deeper
+      # duplicates of the same position merge. Capped like the rs wire
+      # (MAX_RANKED_FAILURES) at the reader, deepest first.
+      def collect_ranks(cause, into = {})
+        labels = into[cause.position] ||= []
+        text = cause.message.to_s
+        labels << text unless labels.include?(text)
+        Array(cause.children).each do |child|
+          next if child.nil?
+
+          collect_ranks(child, into)
+        end
+        into
+      end
+
       # Journaling re-parse — always on the Ruby engine (journaling
       # rides the interpreter's diagnostic reparse; the native engine
       # has no journal). Tree parity with the native engine is enforced

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.105"
 end

metadata

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