moxml 0.5.130 → 0.5.131

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c2f099a606cb34b83d050cd7127593bc1403b3c2ae0d75f1d2d5afaad0107177
-  data.tar.gz: 1d1d777052f784a68363fc7efee322aeb53cfea53781927df1c0e424a165327e
+  metadata.gz: 2de6081e549de3acc9fe0fe2697d0f44e137673eaa311dc9beec4de6346dfb54
+  data.tar.gz: 026a76efc77132825449057e48559626e3f3ec4166d54fb5ea817d51accb830e
 SHA512:
-  metadata.gz: 28d300923fb7a5225aae5241ccbf3af90269ce73258ce1351260fb437df8a70f390a889fcccc98556202fcbcda15a0dbc2b1a9a8ab753e54f81d79a4132ab431
-  data.tar.gz: f8085292e7b0bad93fc80075f1b1e6422021afb972dd11fd9088798b254cff3268068a7ae8786a29511440e7b716c6f48550671bebd772e34c6b509c96357f84
+  metadata.gz: 369b3b0ca0527711f87e4b18f9b268c503612c9aed6aa8ea4fcfcb6dd9ad835be5cbb80b9ff00b0606b3df908bb150a0ef22bba6041157bfdb41a0bd8264a153
+  data.tar.gz: a86491ce96b541420ddf36fc2cbe1324c2f283d212d0271cb2eb61129bca15258dd7d92dbe7a022c6e3e4055140fb395111c96e8518ebd5b5d882a036186ae33

data/Gemfile

@@ -9,7 +9,7 @@ gemspec
 gem "benchmark"
 gem "benchmark-ips"
 gem "get_process_mem"
-gem "leptris", "~> 1.9.343"
+gem "leptris", "~> 1.9.345"
 gem "libxml-ruby", ">= 5.0"
 gem "nokogiri", "~> 1.18"
 gem "openssl", "~> 3.0"

data/lib/moxml/adapter/leptris.rb

@@ -182,6 +182,18 @@ module Moxml
         defined?(::Leptris::HTML) &&
         ::Leptris::HTML.respond_to?(:parse_fragment)
 
+      # The engine's recovery mode (moxml#369, engine leptris#1660
+      # via binding 1.9.344.0): non-strict parses pass recover:
+      # true and keep the best-effort tree (libxml2
+      # XML_PARSE_RECOVER semantics — mismatched closers close
+      # intermediates, unclosed elements close at EOF) instead of
+      # the rescue-to-empty fallback. The kwarg probe pairs the
+      # floor (a binding without the kwarg cannot arm).
+      RECOVER_MODE =
+        Gem::Version.new(::Leptris::VERSION) >= Gem::Version.new("1.9.344.0") &&
+        ::Leptris::XML::ParseOptions.instance_method(:initialize)
+          .parameters.any? { |_, key| key == :recover }
+
       # Markup-accumulating builder face (leptris-ruby#374 lever 2,
       # binding 1.9.313): the DSL accumulates markup in a plain
       # String and ONE native crossing (parse + attach) flushes the
@@ -1031,23 +1043,45 @@ module Moxml
           # multi-pass consumers (comparison, diff, signature).
           # dtdattr: true opts into DTD ATTLIST default materialization
           # (off by default since libleptris 1.9.8, matching libxml2).
+          # #369: non-strict parses RECOVER on engines that carry
+          # the mode (1.9.344+) — the best-effort tree survives
+          # recoverable structural errors (libxml2
+          # XML_PARSE_RECOVER semantics). Strict callers never
+          # recover: malformed input raises. Direct adapter calls
+          # are caller-owned-options by contract (Context applies
+          # config.strict_parsing; bypassing it means the caller
+          # chose the mode).
+          recover = !options[:strict] && RECOVER_MODE
           native_doc = begin
             ::Leptris::XML::Document.parse(
               processed,
               readonly: options[:readonly] == true,
-              options: parse_flags(options, context: _context),
+              options: parse_flags(options, recover: recover,
+                                            context: _context),
             )
           rescue ::Leptris::XML::ParseError => e
-            # libleptris has no recovery mode that survives unclosed
-            # tags; non-strict callers get an empty document, matching
-            # the Libxml adapter's non-strict behavior. The fatal
-            # error rides the document as parse diagnostics (issue
-            # #147) — otherwise nothing says why it came back empty.
             raise Moxml::ParseError.new(e.message) if options[:strict]
 
+            # Engines below the 1.9.344 recover floor (or the
+            # residual unrecoverable edges, e.g. trailing content
+            # after the root close) have no best-effort tree: the
+            # empty-document fallback stands, with the fatal error
+            # as parse diagnostics (issue #147) — otherwise nothing
+            # says why it came back empty.
             recover_errors = [e.message]
             create_document
           end
+          if recover && native_doc.root.nil? && !recover_errors
+            # The recover path answers a rootless document for
+            # input with nothing to recover into (whitespace-only,
+            # declaration-only) — libxml2's recover behaves the
+            # same. Surface WHY on parse_errors so consumers report
+            # it instead of silently holding an empty tree.
+            recover_errors =
+              ["leptris parse recovered no document root " \
+               "(empty or whitespace-only input)"]
+          end
+
           register_mint_klasses!(native_doc)
           ctx = _context || Context.new(:leptris)
           doc = Wrappers::Document.new(native_doc, ctx)
@@ -1191,7 +1225,7 @@ module Moxml
           ::Leptris::XML::ParseOptions.const_defined?(:SKIP_DUP_DETECTION) &&
           ::Leptris::XML::ParseOptions.const_defined?(:SKIP_SOURCE_POSITIONS)
 
-        def parse_flags(options, context: nil)
+        def parse_flags(options, recover: false, context: nil)
           flags = 0
           flags |= ::Leptris::XML::ParseOptions::DTDATTR if options[:dtdattr] == true
           flags |= ::Leptris::XML::ParseOptions::KEEP_ENTITY_REFS if NATIVE_ENTITY_REFS &&
@@ -1203,6 +1237,13 @@ module Moxml
             flags |= po::SKIP_DUP_DETECTION if options[:skip_dup_detection] == true
             flags |= po::SKIP_SOURCE_POSITIONS if options[:skip_source_positions] == true
           end
+          if recover
+            # #369: flags and the recover kwarg ride the same
+            # options struct (leptris-ruby's constructor composes
+            # both).
+            return ::Leptris::XML::ParseOptions.new(flags, recover: true)
+          end
+
           flags.zero? ? nil : ::Leptris::XML::ParseOptions.new(flags)
         end
 

data/lib/moxml/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Moxml
-  VERSION = "0.5.130"
+  VERSION = "0.5.131"
 end

data/spec/moxml/adapter/leptris_spec.rb

@@ -595,11 +595,24 @@ RSpec.describe Moxml::Adapter::Leptris do
   describe "recover-path parse diagnostics" do
     let(:ctx) { Moxml.new(:leptris) }
 
-    it "records the fatal error on non-strict parses" do
-      doc = ctx.parse("<root><unclosed>", strict: false)
-      expect(doc.root).to be_nil
-      expect(doc.parse_errors).not_to be_empty
-      expect(doc.parse_errors).to all(be_a(String))
+    it "records the fatal error on non-strict parses below the recover floor" do
+      unless Moxml::Adapter::Leptris::RECOVER_MODE
+        doc = ctx.parse("<root><unclosed>", strict: false)
+        expect(doc.root).to be_nil
+        expect(doc.parse_errors).not_to be_empty
+        expect(doc.parse_errors).to all(be_a(String))
+      end
+    end
+
+    it "recovers an unclosed root at the floor (#369)" do
+      if Moxml::Adapter::Leptris::RECOVER_MODE
+        doc = ctx.parse("<root><unclosed>", strict: false)
+        expect(doc.root).not_to be_nil
+        # recovery diagnostics ride parse_errors once leptris-ruby
+        # #1200's DOM face lands; today the recovered tree is the
+        # contract.
+        expect(doc.parse_errors).to eq([])
+      end
     end
 
     it "answers [] on clean parses" do

data/spec/moxml/recover_mode_spec.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# #369: non-strict parses RECOVER on engines carrying the mode
+# (leptris 1.9.344+, leptris#1660) — the best-effort tree survives
+# recoverable structural errors (libxml2 XML_PARSE_RECOVER
+# semantics) instead of the rescue-to-empty fallback. Strict
+# callers never recover: malformed input raises.
+RSpec.describe "recover mode (#369)" do
+  let(:ctx) { Moxml.new(:leptris) }
+
+  describe "engines with the recover mode" do
+    before do
+      unless Moxml::Adapter::Leptris::RECOVER_MODE
+        skip "binding #{Leptris::VERSION} predates the recover mode"
+      end
+    end
+
+    it "recovers a mismatched closer into a tree" do
+      doc = ctx.parse("<root><a>x</b></root>", strict: false)
+      expect(doc.root).not_to be_nil
+      expect(doc.to_xml).to include("<a>x</a>")
+    end
+
+    it "closes unclosed elements at EOF" do
+      doc = ctx.parse("<root><a>x</root>", strict: false)
+      expect(doc.root).not_to be_nil
+      expect(doc.to_xml).to include("<a>x</a>")
+    end
+
+    it "keeps strict parsing raising" do
+      expect { ctx.parse("<root><a>x</b></root>", strict: true) }
+        .to raise_error(Moxml::ParseError)
+    end
+
+    it "raises by default (Context strict_parsing defaults true)" do
+      expect { ctx.parse("<root><a>x</b></root>") }
+        .to raise_error(Moxml::ParseError)
+    end
+
+    it "the recovered tree carries no parse errors (diagnostics ride #1200)" do
+      doc = ctx.parse("<root><a>x</b></root>", strict: false)
+      expect(doc.parse_errors).to eq([])
+    end
+  end
+
+  describe "engines below the recover floor" do
+    before do
+      if Moxml::Adapter::Leptris::RECOVER_MODE
+        skip "binding #{Leptris::VERSION} carries the recover mode"
+      end
+    end
+
+    it "keeps the empty-document fallback with diagnostics" do
+      doc = ctx.parse("<root><a>x</b></root>", strict: false)
+      expect(doc.root).to be_nil
+      expect(doc.parse_errors).not_to be_empty
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: moxml
 version: !ruby/object:Gem::Version
-  version: 0.5.130
+  version: 0.5.131
 platform: ruby
 authors:
 - Ribose Inc.
@@ -531,6 +531,7 @@ files:
 - spec/moxml/plan_spec.rb
 - spec/moxml/processing_instruction_spec.rb
 - spec/moxml/readonly_parse_spec.rb
+- spec/moxml/recover_mode_spec.rb
 - spec/moxml/sax/namespace_splitter_spec.rb
 - spec/moxml/sax_entity_parity_spec.rb
 - spec/moxml/sax_spec.rb