parsanol 1.3.103-arm-linux → 1.3.105-arm-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7d3cf2d4d76879a579ca674f3304cae0388d9fea825722d6194bbec055492230
-  data.tar.gz: a1e13b713cfd2f39228757c8239924d83e18518e9eb40fcf6ddce0d5bf1fe359
+  metadata.gz: 1b2a5b84cfa562c1535e789fbb1b255eacbed37ba883009bebc3cdcdd6ee5bf1
+  data.tar.gz: cff2ac2a93078d48366061fc0e929ce7a959db8ee5200f6202b8ee56bd33ab1e
 SHA512:
-  metadata.gz: 30d3712aa28138ba5d3cbc69654d0096fac2a4816841b910593984b99aa1f545e9f21bf14394d385f19b49c475387be4e8d78635ba5e3da44026bb843c1fc306
-  data.tar.gz: 7a16afa441e72786dae5e74d76bf1853a664f7982ad332b6603d68a90715cf5584fee6ad36db6cd6fd8648a3fbb49d6b2418d9098a51abc577990df4f64fd40b
+  metadata.gz: 46131326bda0bcc9f9304c88dcf935b67675f9d18aea638bff38334b9f245fba87aad2b7a6433df41349af6dec63dae68e9c33c2b7d287748cc783b26bdc3a9b
+  data.tar.gz: c75b6c38c1f04df3e9de16313c4bf5bbecd57c2490a57c20704b6144b593e884613f1353ae8317975e381119542f831bf6161d82fd53f54edd802b2d96cc50e2

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,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: parsanol
 version: !ruby/object:Gem::Version
-  version: 1.3.103
+  version: 1.3.105
 platform: arm-linux
 authors:
 - Ribose Inc.
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2026-10-21 00:00:00.000000000 Z
+date: 2026-10-22 00:00:00.000000000 Z
 dependencies: []
 description: A small Ruby library for constructing parsers in the PEG (Parsing Expression
   Grammar) fashion. Parsanol provides Parslet-compatible API with additional features