moxml 0.5.129 → 0.5.131

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9f040a5d5fc3e041e15a54cc42aeb10ca5d3cc882ecc22ca97faa7d45cbbb2d5
-  data.tar.gz: de59fd55dd4eff18451ddec5a20f246325be236313a55d0aeb4cab5af56ce4f9
+  metadata.gz: 2de6081e549de3acc9fe0fe2697d0f44e137673eaa311dc9beec4de6346dfb54
+  data.tar.gz: 026a76efc77132825449057e48559626e3f3ec4166d54fb5ea817d51accb830e
 SHA512:
-  metadata.gz: 668587c18c1bf04415c99e715460b1dece9f5619206d6a7fb1ffa8260a32be81f6faa20853eeca322b3b016523a589550711647362f03ff79f64ccc507ef8e03
-  data.tar.gz: 7ff1f188edb97ee6f36c0294745232f1e1a4078bd6e94d567d56e649c01f5939617b345ebed2fe5b21bf325b6be1863f68b5af1acfb7171bd63b0a4bef58bd2a
+  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/materialize.rb

@@ -23,6 +23,18 @@ module Moxml
         CHILDREN_CAPACITY = 64
         private_constant :CHILDREN_CAPACITY
 
+        # #367: HTML-parsed trees carry no namespace declarations,
+        # so the engine's attribute-URI face answers nil for the
+        # RESERVED prefixes too (xml:lang loses its identity). The
+        # wrapper path resolves them from the builtin table
+        # (AttributeResolver) — the bulk stride mirrors that, so
+        # records and wrapper API agree on every tree flavor.
+        RESERVED_ATTR_PREFIX_URIS = {
+          "xml" => "http://www.w3.org/XML/1998/namespace",
+          "xmlns" => "http://www.w3.org/2000/xmlns/",
+        }.freeze
+        private_constant :RESERVED_ATTR_PREFIX_URIS
+
         # Bulk materialization (issues #132/#143): a Ruby-side
         # post-order recursion over RAW C pointers — no binding
         # wrapper per node, no per-node FFI callback, no depth memo
@@ -132,6 +144,7 @@ module Moxml
               # path's resolver semantics (moxml's canonical shape).
               attr_name = attr_name[(colon + 1)..]
               attr_uri = f.leptris_attribute_namespace_uri(attr)
+              attr_uri ||= RESERVED_ATTR_PREFIX_URIS[attr_prefix]
             else
               attr_prefix = nil
               attr_uri = nil

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.129"
+  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/materialize_namespace_uri_spec.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# #367: the bulk records stride carries the bound namespace URI
+# for RESERVED-prefixed attributes on HTML-fragment-parsed trees —
+# HTML trees carry no declarations, so the engine's attribute-URI
+# face answers nil for xml:lang there; the bulk path mirrors the
+# wrapper resolver's builtin table so records and wrapper agree.
+RSpec.describe "materialize_fields reserved-prefix URIs (#367)" do
+  let(:ctx) { Moxml.new(:leptris) }
+  let(:frag) { ctx.parse_html_fragment('<span lang="en" xml:lang="en">text</span>') }
+  let(:span) { frag.children.first }
+
+  def records_attrs
+    out = nil
+    span.materialize_fields do |kind, _q, _p, _u, _ns, attrs, _t, _d| # rubocop:disable Metrics/ParameterLists,Lint/UnusedBlockArgument
+      out = attrs.dup if kind == :element
+    end
+    out
+  end
+
+  it "matches the wrapper API for prefixed attributes on fragment trees" do
+    records = records_attrs
+    expect(records).to eq(
+      ["lang", "en", nil, nil,
+       "lang", "en", "http://www.w3.org/XML/1998/namespace", "xml"],
+    )
+  end
+
+  it "agrees with the wrapper attribute API stride-for-stride" do
+    wrapper = span.attributes.map { |a| [a.name, a.value, a.namespace&.uri, a.namespace&.prefix] }
+    expect(records_attrs.each_slice(4).to_a).to eq(wrapper)
+  end
+end

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.129
+  version: 0.5.131
 platform: ruby
 authors:
 - Ribose Inc.
@@ -508,6 +508,7 @@ files:
 - spec/moxml/error_spec.rb
 - spec/moxml/html_fragment_spec.rb
 - spec/moxml/lazy_parse_spec.rb
+- spec/moxml/materialize_namespace_uri_spec.rb
 - spec/moxml/materializer_spec.rb
 - spec/moxml/moxml_spec.rb
 - spec/moxml/namespace_spec.rb
@@ -530,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