moxml 0.5.9 → 0.5.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 011d9a8566b2697d8c01a17a1a4f702ace315361dae3b246f8ed5ad5fb79b3e8
-  data.tar.gz: 286839c9aca15e4027d4b01bcdfb432c2036f10234fb408cf10f88e5dcbeac0d
+  metadata.gz: 0307f3c9e6060b1ca344c69633788790dc899121f213be74870be3cd2c2600ac
+  data.tar.gz: 22135905e79bcb1099a04809bedb69c734b1893ee4fa4749761427641bfcf9b2
 SHA512:
-  metadata.gz: f53698ba5eee597fb6bda3355c1f7dfe0a33442cd3e67a6aedc73a155a23e80f049f2fc63aed6871b6cb2e85723719d7e7f318cc140ef178e5dde4bcd493a095
-  data.tar.gz: 44d1afe3880ebc55dd214a0a7f2b48c69151504b6c5a16646afd88cf4a885184132db9a590552c2531bfda8ea84a92e8fac50a7cfae75379e215582acf0f5bac
+  metadata.gz: 50413c5cddd8680fc5c6cf4bd67dcf75e54e0cbf202b45f1ff5b985648ff948286b92c0a4efc9ef725d9fd0af677e0239eefb7fec37f27e43ece9795240a5db7
+  data.tar.gz: 696949b3fb51358b4841e2a2fdeb68824659a7ffefdbb6ac4a2006758006d649ddb64127728cd2b5b653cc54dd888e14566d012d5d6b6c382ce012f3b0ea0112

data/lib/moxml/adapter/leptris.rb

@@ -19,6 +19,11 @@ module Moxml
     # programmatic DOCTYPE, so those live in CustomizedLeptris value
     # objects stored through NativeAttachment.
     class Leptris < Base
+      # libleptris 1.9.7 (leptris-ruby 1.9.26): Document#node exposes
+      # the libxml2-model document node — prolog/epilog parts in
+      # document order. Older bindings keep the flat pre-root PI path.
+      DOC_NODE_SUPPORTED = ::Leptris::XML::Document.method_defined?(:node)
+
       class << self
         def attachments
           @attachments ||= Moxml::NativeAttachment.new
@@ -283,6 +288,12 @@ module Moxml
             qname: node.name,
             prefix: node.prefix,
             namespace_uri: ns&.href,
+            # Own declarations only — same shape as the generic
+            # path's Element#declared_namespaces (issue #138).
+            namespaces: begin
+              decls = node.namespace_definitions.map { |d| [d.prefix, d.href] }
+              decls.empty? ? Materializer::EMPTY_ATTRIBUTES : decls
+            end,
             attributes: attributes,
             text: nil,
             depth: material_depth(node, depth_memo),
@@ -295,6 +306,7 @@ module Moxml
             qname: nil,
             prefix: nil,
             namespace_uri: nil,
+            namespaces: Materializer::EMPTY_ATTRIBUTES,
             attributes: Materializer::EMPTY_ATTRIBUTES,
             text: text,
             depth: material_depth(node, depth_memo),
@@ -971,9 +983,22 @@ module Moxml
           native = native_doctype_xml(doc)
           parts << native << "\n" if native
 
-          document_pi_nodes(doc).each { |pi| parts << pi.to_xml << "\n" }
+          if DOC_NODE_SUPPORTED
+            # The libxml2-model document node: prolog PIs/comments,
+            # the root, epilog PIs/comments — in document order, so
+            # epilog parts serialize after the root (issue #130).
+            doc_children = document_node_children(doc)
+            if doc_children
+              doc_children.each { |child| parts << raw_serialize(child, options) << "\n" }
+            else
+              document_pi_nodes(doc).each { |pi| parts << pi.to_xml << "\n" }
+              parts << raw_serialize(doc.root, options) << "\n" if doc.root
+            end
+          else
+            document_pi_nodes(doc).each { |pi| parts << pi.to_xml << "\n" }
 
-          parts << raw_serialize(doc.root, options) << "\n" if doc.root
+            parts << raw_serialize(doc.root, options) << "\n" if doc.root
+          end
 
           texts = attachments.get(doc, :document_text)
           texts&.each { |text| parts << XmlEmitter.escape_text(text.content.to_s) }
@@ -1046,6 +1071,20 @@ module Moxml
         # the same objects, so wrapper mutations round-trip. Build the
         # cache BEFORE appending a PI with add_pi, or the C-side
         # addition would be double-counted.
+        # The document node's children, or nil when the node does not
+        # reflect reality: parsed documents always list the root
+        # element among their children, but programmatically built
+        # ones do not (binding gap) — those keep the legacy parts
+        # path.
+        def document_node_children(doc)
+          doc_children = doc.children.to_a
+          has_root = doc_children.any?(::Leptris::XML::Element)
+          return doc_children if has_root
+          return doc_children if doc.root.nil?
+
+          nil
+        end
+
         def document_pi_nodes(doc)
           attachments.get(doc, :doc_pi_nodes) || begin
             nodes = doc.processing_instructions.map do |(target, data)|
@@ -1065,16 +1104,29 @@ module Moxml
           doctype_wrapper = attachments.get(doc, :doctype)
           children << doctype_wrapper if doctype_wrapper
 
-          # Document-level PIs live outside the element tree in
-          # libleptris (a flat list; its serializer emits them before
-          # the root). Listed after the DOCTYPE to match the order
-          # serialize_document emits, so children and serialization
-          # agree. Epilog anchoring is not representable in the C
-          # model — a known divergence from the Nokogiri-shaped
-          # contract the other adapters expose.
-          children.concat(document_pi_nodes(doc))
+          if DOC_NODE_SUPPORTED
+            # The libxml2-model document node lists prolog PIs/comments,
+            # the root, and epilog PIs/comments in document order —
+            # the Nokogiri-shaped contract, epilog anchoring included
+            # (issue #130). Built (programmatic) documents are not yet
+            # fully reflected by the node (binding gap: an attached
+            # root does not appear); document_node_children answers
+            # nil there for the legacy parts path.
+            doc_children = document_node_children(doc)
+            if doc_children
+              children.concat(doc_children)
+            else
+              children.concat(document_pi_nodes(doc))
+              children << doc.root if doc.root
+            end
+          else
+            # Legacy path: document-level PIs live outside the element
+            # tree in a flat pre-root list (libleptris < 1.9.7 C
+            # model); epilog anchoring is not representable there.
+            children.concat(document_pi_nodes(doc))
 
-          children << doc.root if doc.root
+            children << doc.root if doc.root
+          end
 
           texts = attachments.get(doc, :document_text)
           children.concat(texts) if texts

data/lib/moxml/element.rb

@@ -119,6 +119,16 @@ module Moxml
     end
     alias namespace_definitions namespaces
 
+    # The element's OWN namespace declarations as [prefix, uri]
+    # pairs (nil prefix = default namespace) — not the inherited
+    # scope. The shape materialize records carry (issue #138).
+    def declared_namespaces
+      adapter.namespace_definitions(@native).map do |ns|
+        wrapper = Namespace.new(ns, context)
+        [wrapper.prefix, wrapper.uri]
+      end
+    end
+
     # Returns all namespaces in scope for this element,
     # including those inherited from ancestor elements.
     def in_scope_namespaces

data/lib/moxml/materializer.rb

@@ -69,6 +69,10 @@ module Moxml
         qname: element.name,
         prefix: element.namespace_prefix,
         namespace_uri: ns&.uri,
+        # The element's OWN namespace declarations ([prefix, uri]
+        # pairs; nil prefix = default), not the in-scope set — enough
+        # for a consumer to rebuild scope while walking (issue #138).
+        namespaces: element.declared_namespaces,
         attributes: attributes,
         text: nil,
         depth: depth,
@@ -81,6 +85,7 @@ module Moxml
         qname: nil,
         prefix: nil,
         namespace_uri: nil,
+        namespaces: EMPTY_ATTRIBUTES,
         attributes: EMPTY_ATTRIBUTES,
         text: text,
         depth: depth,

data/lib/moxml/version.rb

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

data/spec/moxml/adapter/leptris_spec.rb

@@ -85,37 +85,51 @@ RSpec.describe Moxml::Adapter::Leptris do
     let(:ctx) { Moxml.new(:leptris) }
 
     it "lists document PIs as children with the root" do
-      doc = ctx.parse('<?xml version="1.0"?><?pi-prolog before?><root/><?pi-epilog after?>')
+      doc = ctx.parse('<?xml version="1.0"?><?pi-prolog before?><root/><?pi-epilog after?><!-- tail -->')
       kids = doc.children.to_a
 
       expect(kids.map(&:class)).to eq(
-        [Moxml::ProcessingInstruction, Moxml::ProcessingInstruction, Moxml::Element],
+        [Moxml::ProcessingInstruction, Moxml::Element,
+         Moxml::ProcessingInstruction, Moxml::Comment],
       )
       expect(kids.select(&:processing_instruction?).map(&:target)).to eq(%w[pi-prolog pi-epilog])
       expect(kids[0].content).to eq("before")
+      expect(doc.to_xml.index("pi-epilog")).to be > doc.to_xml.index("</root>")
+      expect(doc.to_xml.index("<!-- tail -->")).to be > doc.to_xml.index("</root>")
     end
 
-    it "round-trips mutations and additions through serialization" do
-      doc = ctx.parse("<?pi-original x?><root/>")
-      pi = doc.children.to_a[0]
+    it "round-trips tree-level PI mutations through serialization" do
+      doc = ctx.parse("<root><a><?pi-original x?></a></root>")
+      pi = doc.at_xpath("//a").children.to_a.find(&:processing_instruction?)
       pi.target = "renamed"
       pi.content = "changed"
       expect(doc.to_xml).to include("<?renamed changed?>")
+    end
 
+    it "adds document PIs and lists them as children" do
+      doc = ctx.parse("<root/>")
       doc.add_child(doc.create_processing_instruction("added", "now"))
       expect(doc.to_xml).to include("<?added now?>")
-      expect(doc.children.to_a.select(&:processing_instruction?).map(&:target)).to eq(%w[renamed added])
+      expect(doc.children.to_a.select(&:processing_instruction?).map(&:target)).to eq(%w[added])
+    end
+
+    it "reports document-level PI mutation as unsupported on the native path" do
+      # libleptris 1.9.7 exposes document PIs read-only: target=/data=
+      # and unlink are rejected for nodes outside the element tree.
+      doc = ctx.parse("<?pi x?><root/>")
+      pi = doc.children.to_a[0]
+
+      expect { pi.target = "renamed" }.to raise_error(Leptris::XML::Error)
     end
 
     it "serializes children and document output in agreement" do
       # libleptris stores document PIs as one flat pre-root list (no
       # epilog anchoring); children and to_xml must at least agree.
       doc = ctx.parse('<?xml version="1.0"?><?pi-a 1?><root/><?pi-b 2?>')
-      from_children = doc.children.to_a.select(&:processing_instruction?)
-        .map(&:to_xml).join("\n")
+      parts = doc.children.to_a.map { |c| "#{c.to_xml}\n" }.join
       from_document = doc.to_xml.sub(%r{\A<\?xml[^>]*\?>\n}, "")
 
-      expect(from_document).to start_with(from_children)
+      expect(from_document).to eq(parts)
     end
 
     it "matches raw Nokogiri byte-for-byte for pretty-printing (issue #129)" do

data/spec/moxml/materializer_spec.rb

@@ -36,6 +36,10 @@ RSpec.describe Moxml::Materializer do
     expect(book[:namespace_uri]).to eq("urn:c")
     expect(book[:text]).to be_nil
 
+    catalog = records.last
+    expect(catalog[:namespaces]).to eq([[nil, "urn:c"], ["p", "urn:p"]])
+    expect(book[:namespaces]).to eq([])
+
     title_text = records.find { |r| r[:kind] == :text && r[:text] == "T" }
     expect(title_text[:attributes]).to eq([])
   end
@@ -77,6 +81,6 @@ RSpec.describe Moxml::Materializer do
 
     # Records themselves allocate (hash + FFI strings); the wrapper
     # tree does not: far fewer allocations than 2 wrappers per node.
-    expect(allocated).to be < node_count * 20
+    expect(allocated).to be < node_count * 24
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: moxml
 version: !ruby/object:Gem::Version
-  version: 0.5.9
+  version: 0.5.10
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-08-27 00:00:00.000000000 Z
+date: 2026-08-28 00:00:00.000000000 Z
 dependencies: []
 description: |
   Moxml is a unified XML manipulation library that provides a common API