moxml 0.5.137 → 0.5.139

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 43beff2cbabe6c8800099bc8f56a76b4c2510c6158cb632984cd31c8c3893a24
-  data.tar.gz: e7d0540ce919c428a26b55805f0c78fc25de976c08f2639a83161eab6ffc3b4d
+  metadata.gz: 271ff9c6c8d5502c0cd427efdc84e5ba8f123d0008e100a3e7303d478b4a47eb
+  data.tar.gz: c87777565ab89568a4195754e4f6c84fe5bd04e230416e0f4e2a5dc605945b54
 SHA512:
-  metadata.gz: 8e33f465faabc1da5cc0c7233f70e60592e0080cb4897b81d98eb1b073fedeea21160d2252170e322c8a66b33f4899e1752f96b30555ba0959f4b6f2e46ecd8b
-  data.tar.gz: 29dde54bd4af8259207a708175309fdf9ad7fd3c4702eacf1e77a92d5fbfbd03b0993d2730c70ddb0c5b30edc41bbc4871e73d10334814fd51b813f2e6905629
+  metadata.gz: d5d766ba5edbce1fcba2e14c7227e22c5f3ca0d96a01ab1f2ae2dee5c97f76fc8bb5723e0b1349fe5aee90b026f3532aae07291e17bd2a785761a9f6a7d99e3e
+  data.tar.gz: e24616f241e0e846db54db729ad564bf1363f53c7fd7ea422ec6ee3a605138b934d79fe49627b2942c8716b1e2b6655909f2ef84fec0b9ca17fddaa022f23500

data/lib/moxml/adapter/leptris/document_parts.rb

@@ -36,7 +36,13 @@ module Moxml
           # Nokogiri-shaped contract, epilog anchoring included (issue
           # #130). Built documents reflect their parts immediately
           # since leptris-ruby 1.9.32 (leptris-ruby#91).
-          children.concat(doc.children.to_a)
+          # leptris-ruby#459 lists the declaration among the binding
+          # children; the Nokogiri-shaped facade contract never lists
+          # it (the declaration is a preamble part, not a child node)
+          # — filtered at the listing seam.
+          children.concat(
+            doc.children.to_a.grep_v(::Leptris::XML::Declaration),
+          )
 
           texts = attachments.get(doc, :document_text)
           children.concat(texts) if texts
@@ -156,6 +162,13 @@ module Moxml
               next
             end
 
+            # leptris-ruby#459 exposes the declaration as a
+            # Document#children entry; the preamble above owns the
+            # emission (a second line here duplicates it — and the
+            # 1.9.360 0-arity Declaration#to_xml raises under the
+            # options-passing call).
+            next if child.is_a?(::Leptris::XML::Declaration)
+
             parts << raw_serialize(child, options) << "\n"
           end
 

data/lib/moxml/adapter/leptris.rb

@@ -92,8 +92,20 @@ module Moxml
       # NativeNode#[]), so the adapter's native fast paths speak to
       # the native layer through these bound entries — bind_call is
       # the same C dispatch without the shadow lookup.
+      # Always defined: nothing can be an instance of an anonymous
+      # class, so on the FFI-only lane is_a?(NN) is uniformly false
+      # and the ungated native-node conditionals keep their
+      # semantics without the compiled ext.
+      NN = NATIVE_READ_LAYER ? ::Leptris::XML::NativeNode : Class.new
+
+      # The binding's Document.parse gained the strict: kwarg later
+      # than the native layer's default-strict behavior — probe the
+      # face instead of version-gating (the RECOVER_MODE pattern).
+      STRICT_PARSE_KWARG =
+        ::Leptris::XML::Document.method(:parse)
+          .parameters.any? { |_, key| key == :strict }
+
       if NATIVE_READ_LAYER
-        NN = ::Leptris::XML::NativeNode
         NN_ATTRIBUTE = NN.instance_method(:attribute)
         NN_NAME = NN.instance_method(:name)
         NN_PARENT = NN.instance_method(:parent)
@@ -397,6 +409,27 @@ module Moxml
         end
       end
 
+      class << self
+        # These three live OUTSIDE the NATIVE_READ_LAYER gate:
+        # ungated methods (register_mint_klasses!, the
+        # create/register seams) and the specs' singleton const_get
+        # read them, and on the FFI-only lane the gate's Identity
+        # classes do not exist. NATIVE_MUTATIONS_COHERENT is false
+        # without the native layer, so all three evaluate false
+        # there.
+        NATIVE_IDENTITY =
+          NATIVE_MUTATIONS_COHERENT &&
+          Gem::Version.new(::Leptris::VERSION) >= Gem::Version.new("1.9.174.4")
+
+        NATIVE_C_MINT =
+          NATIVE_IDENTITY &&
+          Gem::Version.new(::Leptris::VERSION) >= Gem::Version.new("1.9.255.2")
+
+        NATIVE_KLASS_CHILDREN =
+          NATIVE_IDENTITY &&
+          Gem::Version.new(::Leptris::VERSION) >= Gem::Version.new("1.9.193.2")
+      end
+
       if NATIVE_READ_LAYER
         # root NativeNode -> binding document (recorded at #root
         # mint; the native layer exposes no document accessor).
@@ -501,10 +534,6 @@ module Moxml
             TEXT.include(Reads)
           end
 
-          NATIVE_IDENTITY =
-            NATIVE_MUTATIONS_COHERENT &&
-            Gem::Version.new(::Leptris::VERSION) >= Gem::Version.new("1.9.174.4")
-
           # leptris-ruby#246 klass-propagating reads: the read
           # family (children/element_children/next_sibling/parent)
           # mints the mapped subclass per kind, so children arrive
@@ -521,14 +550,6 @@ module Moxml
           # classes — walked and built nodes arrive already carrying the
           # contract, and the Ruby shell mint drops out entirely
           # (moxml#288: the entire remaining walk/build gap).
-          NATIVE_C_MINT =
-            NATIVE_IDENTITY &&
-            Gem::Version.new(::Leptris::VERSION) >= Gem::Version.new("1.9.255.2")
-
-          NATIVE_KLASS_CHILDREN =
-            NATIVE_IDENTITY &&
-            Gem::Version.new(::Leptris::VERSION) >= Gem::Version.new("1.9.193.2")
-
           if NATIVE_KLASS_CHILDREN
             kind_classes = [
               Identity::ELEMENT,
@@ -1065,6 +1086,10 @@ module Moxml
             ::Leptris::XML::Document.parse(
               processed,
               readonly: options[:readonly] == true,
+              # The FFI fallback lane parses leniently by default —
+              # the strict intent must ride explicitly or strict
+              # callers silently get a best-effort tree.
+              **(options[:strict] && STRICT_PARSE_KWARG ? { strict: true } : {}),
               options: parse_flags(options, recover: recover,
                                             context: _context),
             )
@@ -1343,13 +1368,22 @@ module Moxml
         # comment, cdata, pi. Parsed documents register right after
         # the binding mint. Unregistered bindings (older floors, the
         # C-mint off) are unchanged — the shell path stays.
-        MINT_KIND_CLASSES = [
-          Identity::ELEMENT,
-          Identity::TEXT,
-          Identity::COMMENT,
-          Identity::CDATA,
-          Identity::PROCESSING_INSTRUCTION,
-        ].freeze
+        # Identity lives under the NATIVE_READ_LAYER gate — on the
+        # FFI-only lane (windows, or a binding whose native bundle
+        # fails to load) the constant must not be referenced at load
+        # time. register_mint_klasses! never reads it there
+        # (NATIVE_C_MINT is false).
+        MINT_KIND_CLASSES = if NATIVE_READ_LAYER
+                              [
+                                Identity::ELEMENT,
+                                Identity::TEXT,
+                                Identity::COMMENT,
+                                Identity::CDATA,
+                                Identity::PROCESSING_INSTRUCTION,
+                              ].freeze
+                            else
+                              [].freeze
+                            end
 
         def register_mint_klasses!(binding_doc)
           return binding_doc unless NATIVE_C_MINT && binding_doc
@@ -2349,7 +2383,7 @@ module Moxml
           # upstream (its absorbed_into? checks are not transitive) —
           # those keep the pin + adoption copy. Entity references
           # keep the marker flow below.
-          if NATIVE_DOC_ABSORB && !child.is_a?(NN) &&
+          if NATIVE_READ_LAYER && NATIVE_DOC_ABSORB && !child.is_a?(NN) &&
               child.is_a?(::Leptris::XML::Node) &&
               !child.is_a?(CustomizedLeptris::EntityReference)
             child_doc = child.document
@@ -2447,8 +2481,11 @@ module Moxml
           end
           # 1.9.311: an absorbed element source moves through the raw
           # engine faces — the binding's sibling insert drops it.
-          if new_node.is_a?(::Leptris::XML::Element) &&
-              !new_node.is_a?(::Leptris::XML::NativeNode)
+          # NATIVE_READ_LAYER: the absorb needs the raw engine add to
+          # land the source; on the FFI lane the binding's own insert
+          # handles it and the absorbed-source splice loses the node.
+          if NATIVE_READ_LAYER && new_node.is_a?(::Leptris::XML::Element) &&
+              !new_node.is_a?(NN)
             new_doc = new_node.document
             node_doc = node.document
             if new_doc && node_doc && !new_doc.equal?(node_doc)
@@ -2477,8 +2514,11 @@ module Moxml
           pin_foreign_owner_document(node, new_node)
           # 1.9.311: an absorbed element source moves through the raw
           # engine faces — the binding's sibling insert drops it.
-          if new_node.is_a?(::Leptris::XML::Element) &&
-              !new_node.is_a?(::Leptris::XML::NativeNode)
+          # NATIVE_READ_LAYER: the absorb needs the raw engine add to
+          # land the source; on the FFI lane the binding's own insert
+          # handles it and the absorbed-source splice loses the node.
+          if NATIVE_READ_LAYER && new_node.is_a?(::Leptris::XML::Element) &&
+              !new_node.is_a?(NN)
             new_doc = new_node.document
             node_doc = node.document
             if new_doc && node_doc && !new_doc.equal?(node_doc)

data/lib/moxml/adapter/libxml.rb

@@ -244,6 +244,9 @@ module Moxml
             return NATIVE_NODE_TYPE_MAP[node.node_type] || :unknown
           end
           return :document if node.is_a?(::LibXML::XML::Document)
+          # Attr is a separate class (not ::Node) — attribute-terminal
+          # XPath results mint as plain Node without this.
+          return :attribute if node.is_a?(::LibXML::XML::Attr)
 
           wrapper_type = WRAPPER_NODE_TYPE_MAP[node.class]
           return wrapper_type if wrapper_type
@@ -949,6 +952,16 @@ module Moxml
           native_node = unpatch_node(node)
           return [] unless native_node
 
+          # libxml-ruby's Document#find returns EMPTY for relative
+          # paths (nokogiri/libxml2 evaluate them fine): a relative
+          # expression from the document node is equivalent to the
+          # absolute form — the document's only name-testable child
+          # is the root — so rewrite instead of losing the match.
+          if native_node.is_a?(::LibXML::XML::Document) &&
+              expression.match?(/\A[A-Za-z_*@]/)
+            expression = "/#{expression}"
+          end
+
           # Build namespace context for LibXML
           # LibXML requires ALL prefixes in the XPath to be registered
           ns_context = build_xpath_namespaces(native_node, namespaces)

data/lib/moxml/adapter/nokogiri.rb

@@ -626,7 +626,11 @@ module Moxml
         end
 
         def xpath(node, expression, namespaces = nil)
-          result = node.xpath(expression, namespaces)
+          # An explicit bindings hash — even EMPTY — makes nokogiri
+          # register a prefix context, which disables libxml2's
+          # literal xmlns: default-namespace handling. Only pass the
+          # hash when the caller actually bound something.
+          result = namespaces.nil? || namespaces.empty? ? node.xpath(expression) : node.xpath(expression, namespaces)
           # Adapter contract: Array<native> | LazyNodeSet | scalar
           # (count(), string-length(), boolean functions return
           # scalars). The native node-set passes through lazily —

data/lib/moxml/adapter/rexml.rb

@@ -604,10 +604,13 @@ module Moxml
         end
 
         def xpath(node, expression, namespaces = {})
+          # XPath.match for every expression: get_elements only
+          # handles simple child-name paths — attribute terminals,
+          # absolute paths and predicates silently degrade there.
           if namespaces && !namespaces.empty?
-            ::REXML::XPath.match(node, expression, namespaces)
+            ::REXML::XPath.match(node, expression, namespaces).to_a
           else
-            node.get_elements(expression).to_a
+            ::REXML::XPath.match(node, expression).to_a
           end
         rescue ::REXML::ParseException => e
           raise Moxml::XPathError.new(

data/lib/moxml/version.rb

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

data/spec/consistency/xpath_idioms_spec.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# Cross-adapter XPath idioms that nokogiri consumers rely on:
+#
+# - The literal xmlns: prefix resolves against the default namespace
+#   (the libxml2 quirk that is nokogiri's documented way to match
+#   default-namespaced elements; leptris carries it since engine
+#   1.9.359 / leptris-ruby#469; moxml's own engine always has).
+# - Attribute-terminal steps work in every path position
+#   (leptris-ruby#458's table: //a/@id, //@id, r/a/@id,
+#   //*[f()]/@id — fixed by the engine's VM path work).
+RSpec.describe "XPath idioms across adapters" do
+  let(:default_ns_xml) do
+    '<svgmap xmlns="http://www.example.org/doc"><target href="a"/></svgmap>'
+  end
+  let(:plain_xml) { '<r><a id="x"><b/></a></r>' }
+
+  Moxml::Adapter::AVAILABLE_ADAPTERS.each do |adapter_name|
+    next if adapter_name == :headed_ox # same engine as :ox
+
+    context "with #{adapter_name}" do
+      let(:ctx) { Moxml.new(adapter_name) }
+
+      before do
+        if adapter_name == :leptris &&
+            Gem::Version.new(Leptris::VERSION) < Gem::Version.new("1.9.359.0")
+          skip "binding #{Leptris::VERSION} predates the xmlns: fix (1.9.359)"
+        end
+        if adapter_name == :oga
+          # oga's own Ruby XPath engine has no xmlns: default-ns
+          # support (third-party; explicit bindings work).
+          skip "oga's XPath engine does not implement the xmlns: idiom"
+        end
+      end
+
+      it "matches default-namespaced elements via the xmlns: prefix" do
+        doc = ctx.parse(default_ns_xml)
+        targets = doc.root.xpath("./xmlns:target")
+        expect(targets.length).to eq(1)
+        expect(targets.first.name).to eq("target")
+      end
+
+      it "keeps explicit namespace bindings winning over the idiom" do
+        doc = ctx.parse(default_ns_xml)
+        targets = doc.root.xpath("./xmlns:target", "xmlns" => "urn:bogus")
+        expect(targets).to be_empty
+      end
+
+      it "resolves attribute-terminal steps in every path position" do
+        doc = ctx.parse(plain_xml)
+        expect(doc.xpath("//a/@id").first&.value).to eq("x")
+        expect(doc.xpath("//@id").first&.value).to eq("x")
+        expect(doc.xpath("r/a/@id").first&.value).to eq("x")
+        expect(
+          doc.xpath("//*[local-name()='a']/@id").first&.value,
+        ).to eq("x")
+      end
+    end
+  end
+end

data/spec/moxml/adapter/leptris_document_declaration_spec.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# leptris-ruby#459 exposes the declaration as a Document#children
+# entry (binding 1.9.360). The serialize child walk must skip it —
+# the composed preamble owns the emission — or declaration-bearing
+# round trips duplicate the line (1.9.359) or raise (1.9.360's
+# 0-arity Declaration#to_xml under the options-passing call).
+RSpec.describe "leptris document declaration child" do
+  let(:ctx) { Moxml.new(:leptris) }
+  let(:xml) { %(<?xml version="1.0" encoding="UTF-8"?>\n<documents></documents>) }
+
+  before do
+    unless Gem::Version.new(Leptris::VERSION) >= Gem::Version.new("1.9.360.0")
+      skip "binding #{Leptris::VERSION} predates the declaration child (1.9.360)"
+    end
+  end
+
+  it "round trips byte-identical with exactly one declaration" do
+    doc = ctx.parse(xml)
+    out = doc.to_xml
+
+    expect(out).to eq("#{xml}\n")
+    expect(out.scan("<?xml").length).to eq(1)
+  end
+
+  it "never lists the declaration among document children" do
+    doc = ctx.parse(xml)
+    first = doc.children.to_a
+    second = doc.children.to_a
+
+    expect(first.map(&:node_type)).to eq(%i[element])
+    expect(second.map(&:node_type)).to eq(first.map(&:node_type))
+    expect(doc.to_xml).to eq("#{xml}\n")
+  end
+
+  it "keeps declaration-less documents unchanged" do
+    doc = ctx.parse("<r/>")
+    expect(doc.to_xml).to eq("<r></r>\n")
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: moxml
 version: !ruby/object:Gem::Version
-  version: 0.5.137
+  version: 0.5.139
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-10-15 00:00:00.000000000 Z
+date: 2026-10-16 00:00:00.000000000 Z
 dependencies: []
 description: |
   Moxml is a unified XML manipulation library that provides a common API
@@ -313,6 +313,7 @@ files:
 - spec/consistency/eol_normalization_spec.rb
 - spec/consistency/html_doctype_spec.rb
 - spec/consistency/round_trip_spec.rb
+- spec/consistency/xpath_idioms_spec.rb
 - spec/consistency/xslt_spec.rb
 - spec/examples/README.md
 - spec/examples/attribute_examples_spec.rb
@@ -452,6 +453,7 @@ files:
 - spec/moxml/adapter/leptris_attribute_snapshot_spec.rb
 - spec/moxml/adapter/leptris_binding_cap_spec.rb
 - spec/moxml/adapter/leptris_doc_parts_spec.rb
+- spec/moxml/adapter/leptris_document_declaration_spec.rb
 - spec/moxml/adapter/leptris_parse_skips_spec.rb
 - spec/moxml/adapter/leptris_record_driver_spec.rb
 - spec/moxml/adapter/leptris_sax_dup_attr_spec.rb