moxml 0.5.136 → 0.5.138

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7ae551e19c600eba6d19a7a2a1c764275673d4ad7deba04d3778d407464ec8b9
-  data.tar.gz: e546f3c3290bfde650efb0d42625146abaf87f20741be65aee93ab8dad0a1c84
+  metadata.gz: 20467d4026cf631dd85798aaaa47a53526e1a6c8e26b1583ac896e56bb0fa4b4
+  data.tar.gz: 3d3829939332dfd24a1d552308d10fd7c0dbbe6eed998a5292ec5a5d82d53def
 SHA512:
-  metadata.gz: 30ba4c3744a7742dcde2b457fcfa99a0a32f7ddac8ebd721ca79eff029b0faeb4ab91b8577d4270975973933193594b3ff7e05926e7e84500dee25d20c90ce3b
-  data.tar.gz: 12791df8b1c31cc43204904abbe4f7b5e3f3d1e3e4be248637efbb67d734fe6be36f9384a6345be95ba3993efcec43c0f387086d63cafc623d0f63a66c9c69fa
+  metadata.gz: 353a615d10c7755a3d03a5dd13988eb57b1f30b2bc68f1506e68bc48d053deca42fd968cbba67f5df10cd14dff7da757bfd15f89a734cd1e607e34d3b319eb0a
+  data.tar.gz: bfa917028338657c3c09d91f32a964a653f4e50bc8d5abd1d0c7cf404d284d2efb216b0e62df1f17f1d731ef636c6d60bbe27a5f587ccca2c45bb65aa93c8e39

data/lib/moxml/adapter/customized_leptris.rb

@@ -12,7 +12,6 @@ module Moxml
       autoload :Doctype, "moxml/adapter/customized_leptris/doctype"
       autoload :EntityReference, "moxml/adapter/customized_leptris/entity_reference"
       autoload :TextSegment, "moxml/adapter/customized_leptris/text_segment"
-      autoload :DocumentPI, "moxml/adapter/customized_leptris/document_pi"
     end
   end
 end

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
@@ -83,8 +89,6 @@ module Moxml
             doc.root = child
           when ::Leptris::XML::ProcessingInstruction
             doc.add_pi(child.target, child.content.to_s)
-          when CustomizedLeptris::DocumentPI
-            doc.add_pi(child.target, child.data)
           when ::Leptris::XML::Text
             texts = attachments.get(doc, :document_text) || []
             texts << child
@@ -158,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/markers.rb

@@ -20,8 +20,7 @@ module Moxml
 
           case native
           when CustomizedLeptris::Declaration, CustomizedLeptris::Doctype,
-             CustomizedLeptris::EntityReference, CustomizedLeptris::TextSegment,
-             CustomizedLeptris::DocumentPI
+             CustomizedLeptris::EntityReference, CustomizedLeptris::TextSegment
             true
           else
             # Parentless elements come only from Iterparse —

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

@@ -86,7 +86,7 @@ module Moxml
           # binding, so a Text branch first would swallow CDATA nodes.
           case node
           when CustomizedLeptris::Declaration, CustomizedLeptris::Doctype,
-               CustomizedLeptris::EntityReference, CustomizedLeptris::DocumentPI
+               CustomizedLeptris::EntityReference
             return node.to_xml
           when ::Leptris::XML::CDATA
             return XmlEmitter.cdata(node.content)

data/lib/moxml/adapter/leptris.rb

@@ -1639,7 +1639,7 @@ module Moxml
           when ::Leptris::XML::Text, CustomizedLeptris::TextSegment then :text
           when ::Leptris::XML::Attr, ::Leptris::XML::ResultAttr then :attribute
           when ::Leptris::XML::Comment then :comment
-          when ::Leptris::XML::ProcessingInstruction, CustomizedLeptris::DocumentPI then :processing_instruction
+          when ::Leptris::XML::ProcessingInstruction then :processing_instruction
           when ::Leptris::XML::Document then :document
           when ::Leptris::XML::DocType, CustomizedLeptris::Doctype then :doctype
           when CustomizedLeptris::Declaration then :declaration
@@ -1666,7 +1666,6 @@ module Moxml
 
         def node_name(node)
           return node.root_name if node.is_a?(::Leptris::XML::DocType)
-          return node.target if node.is_a?(CustomizedLeptris::DocumentPI)
 
           if NATIVE_READ_LAYER && node.is_a?(::Leptris::XML::NativeNode)
             # PIs expose no name through the native layer.
@@ -1684,7 +1683,7 @@ module Moxml
         def set_node_name(node, name)
           node = to_binding(node) if NATIVE_READ_LAYER
           case node
-          when ::Leptris::XML::ProcessingInstruction, CustomizedLeptris::DocumentPI then node.target = name
+          when ::Leptris::XML::ProcessingInstruction then node.target = name
           else node.name = name
           end
         end
@@ -1698,8 +1697,6 @@ module Moxml
             CustomizedLeptris::Doctype.new(node.name, node.external_id, node.system_id)
           when CustomizedLeptris::EntityReference
             CustomizedLeptris::EntityReference.new(node.name)
-          when CustomizedLeptris::DocumentPI
-            CustomizedLeptris::DocumentPI.new(node.target, node.data, node.parent_doc)
           else
             node.dup
           end
@@ -1796,7 +1793,6 @@ module Moxml
             assemble_document_children(node)
           when CustomizedLeptris::Declaration, CustomizedLeptris::Doctype,
                CustomizedLeptris::EntityReference, CustomizedLeptris::TextSegment,
-               CustomizedLeptris::DocumentPI,
                # Terminal node kinds pay an FFI round trip for an empty
                # list; unfiltered recursions visit every text node.
                ::Leptris::XML::Text, ::Leptris::XML::Comment,
@@ -1832,8 +1828,7 @@ module Moxml
           case node
           when ::Leptris::XML::Element then root_parent(node)
           when ::Leptris::XML::Document then nil
-          when CustomizedLeptris::Declaration, CustomizedLeptris::Doctype,
-               CustomizedLeptris::DocumentPI then node.parent_doc
+          when CustomizedLeptris::Declaration, CustomizedLeptris::Doctype then node.parent_doc
           when CustomizedLeptris::TextSegment, CustomizedLeptris::EntityReference then node.parent
           # Same body as the Element arm by design (frequency
           # ordering); the generic kinds are cold.
@@ -2535,23 +2530,6 @@ module Moxml
             end
           when CustomizedLeptris::EntityReference
             marker_text_for(node.parent, node.name)&.unlink
-          when CustomizedLeptris::DocumentPI
-            if NATIVE_DOC_PARTS && node.parent_doc
-              pis = node.parent_doc.processing_instructions
-              index = pis.index do |target, data|
-                target == node.target && data == node.data
-              end
-              if index
-                node.parent_doc.remove_pi(index)
-                node.parent_doc = nil
-              end
-            else
-              raise Moxml::NotImplementedError.new(
-                "libleptris has no document-level PI removal",
-                adapter: :leptris,
-                feature: :remove,
-              )
-            end
           else
             begin
               node.unlink

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/attribute_resolver.rb

@@ -142,6 +142,16 @@ module Moxml
     # Remove the attribute named by XML-correct resolution (see
     # #assign for the name semantics).
     #
+    # #378: a bare name that matches no no-namespace attribute falls
+    # back to the SINGLE namespaced attribute carrying that local
+    # name — callers spelling the local part (the name
+    # attribute_nodes-style listings expose) expect removal, and the
+    # silent no-op broke remediation flows. Bare-name resolution
+    # keeps Namespaces 1.0 §5.2 semantics for reads; removal widens
+    # only when unambiguous. Several prefixed spellings sharing the
+    # local name remove nothing — guessing a prefix would corrupt
+    # documents.
+    #
     # @return [Moxml::Attribute, nil] the removed attribute
     def remove(element, name)
       name = name.to_s
@@ -153,6 +163,8 @@ module Moxml
       end
 
       attr = resolve(element, name)
+      attr ||= resolve_unique_local(element, name) unless name.include?(":")
+
       return nil unless attr
 
       adapter.remove_attribute_native(attr.native)
@@ -160,6 +172,17 @@ module Moxml
       attr
     end
 
+    # The single namespaced attribute whose local name matches, or
+    # nil when none or several do (see #remove).
+    def resolve_unique_local(element, local)
+      matches = element.attributes.select do |attr|
+        attr_name = attr.name
+        local_name(attr_name) == local &&
+          !attribute_uri(element, attr, attr_name).nil?
+      end
+      matches.one? ? matches.first : nil
+    end
+
     # XPath 1.0 attribute node test, sharing the resolver's
     # expanded-name semantics:
     #

data/lib/moxml/element.rb

@@ -233,11 +233,15 @@ module Moxml
       adapter.attachments.set(@native, :children_source_docs, merged)
     end
 
+    # Removes the attribute named by XML-correct resolution — a
+    # qualified name ("p:x"), or a bare name (the no-namespace
+    # attribute, falling back to the single namespaced attribute
+    # carrying that local name when no bare one exists, #378).
+    #
+    # @return [Moxml::Attribute, nil] the removed attribute, nil
+    #   when nothing matched (nokogiri-compatible)
     def remove_attribute(name)
-      # Both remove paths end in invalidate_attribute_cache!, which
-      # bumps the generation.
       Moxml::AttributeResolver.remove(self, name)
-      self
     end
 
     # Append a raw XML fragment's top-level nodes as children.

data/lib/moxml/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Moxml
-  VERSION = "0.5.136"
+  VERSION = "0.5.138"
 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/integration/shared_examples/node_wrappers/attribute_behavior.rb

@@ -126,6 +126,41 @@ RSpec.shared_examples "Moxml::Attribute" do
       end
     end
 
+    describe "removing by local name (#378)" do
+      before do
+        element.add_namespace("q", "http://x.org")
+        element["q:type"] = "namespaced"
+        element["type"] = "bare"
+      end
+
+      it "removes the single namespaced attribute carrying that local name" do
+        element.remove_attribute("type")
+        element.remove_attribute("type")
+
+        expect(element["q:type"]).to be_nil
+        expect(element["type"]).to be_nil
+        expect(element.attributes).to be_empty
+      end
+
+      it "returns the removed attribute, nil when nothing matched" do
+        removed = element.remove_attribute("type")
+
+        expect(removed).to be_a(described_class)
+        expect(element["type"]).to be_nil
+        expect(element.remove_attribute("nonexistent")).to be_nil
+      end
+
+      it "removes nothing when several prefixes share the local name" do
+        element.remove_attribute("type")
+        element.add_namespace("other", "http://other.org")
+        element["other:type"] = "second"
+
+        expect(element.remove_attribute("type")).to be_nil
+        expect(element["q:type"]).to eq("namespaced")
+        expect(element["other:type"]).to eq("second")
+      end
+    end
+
     describe "manipulation" do
       before do
         element["test"] = "value"

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.136
+  version: 0.5.138
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-10-14 00:00:00.000000000 Z
+date: 2026-10-15 00:00:00.000000000 Z
 dependencies: []
 description: |
   Moxml is a unified XML manipulation library that provides a common API
@@ -134,7 +134,6 @@ files:
 - lib/moxml/adapter/customized_leptris.rb
 - lib/moxml/adapter/customized_leptris/declaration.rb
 - lib/moxml/adapter/customized_leptris/doctype.rb
-- lib/moxml/adapter/customized_leptris/document_pi.rb
 - lib/moxml/adapter/customized_leptris/entity_reference.rb
 - lib/moxml/adapter/customized_leptris/text_segment.rb
 - lib/moxml/adapter/customized_libxml.rb
@@ -314,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
@@ -453,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

data/lib/moxml/adapter/customized_leptris/document_pi.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-module Moxml
-  module Adapter
-    module CustomizedLeptris
-      # Document-level processing instruction. libleptris stores these
-      # outside the element tree (a flat, document-ordered list with no
-      # prolog/epilog anchoring — its serializer emits them all before
-      # the root), reachable through Document#processing_instructions
-      # as [target, data] pairs. This pseudo-native gives the pairs a
-      # node identity so the moxml contract can list them as document
-      # children (and answer mutations: creation routes native via
-      # add_pi; removal has no engine entry).
-      class DocumentPI
-        attr_accessor :target, :data, :parent_doc
-        alias content data
-        alias content= data=
-
-        def initialize(target, data = "", parent_doc = nil)
-          @target = target
-          @data = data.to_s
-          @parent_doc = parent_doc
-        end
-
-        def to_xml
-          data.empty? ? "<?#{target}?>" : "<?#{target} #{data}?>"
-        end
-
-        def ==(other)
-          other.is_a?(self.class) && target == other.target && data == other.data
-        end
-      end
-    end
-  end
-end