moxml 0.5.8 → 0.5.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 77a959afbe83b0cc46a158571f792d07888f7bf29f3a65c1ea88be867892ffcc
-  data.tar.gz: 1a5a9515ba125977cd26e33b878e7ecaaed1a788e450e79f356c54a117c9e6c7
+  metadata.gz: 0307f3c9e6060b1ca344c69633788790dc899121f213be74870be3cd2c2600ac
+  data.tar.gz: 22135905e79bcb1099a04809bedb69c734b1893ee4fa4749761427641bfcf9b2
 SHA512:
-  metadata.gz: ff6e651e53a55b5ed4aed1e68eff9fa40e9a58aed81a3709ce101fb315bddbef928dcd1a8b31317fcf7dd42e65b92158191647365bc7c43fba46677551bd82d6
-  data.tar.gz: 3c3ad8fac372d42a2dd9d3e4660bc30987015975031fed6b80c1bfeea864f47ed36676d125132384b72d7ba51a3a1ef743877efd5611fd0ecc2cda96efae29e7
+  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
@@ -30,7 +35,9 @@ module Moxml
 
         def parse(xml, options = {}, _context = nil)
           xml_string = xml.is_a?(IO) || xml.is_a?(StringIO) ? xml.read : xml.to_s
-          processed = preprocess_entities(xml_string)
+          # The marker flag rides preprocess's own `&` scan — no
+          # second full-buffer probe (issue #132 parse-side note).
+          processed, entity_markers = Entity.preprocess_with_marker_flag(xml_string)
 
           # readonly: true (issue #133): the binding memoizes reads and
           # refuses mutations — the parse-and-read lifecycle for
@@ -49,7 +56,7 @@ module Moxml
           doc = Document.new(native_doc, ctx)
 
           record_source_declaration(native_doc, processed)
-          attachments.set(native_doc, :entity_markers, processed.include?(Entity::MARKER))
+          attachments.set(native_doc, :entity_markers, entity_markers)
 
           doc
         end
@@ -281,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),
@@ -293,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),
@@ -310,17 +324,21 @@ module Moxml
         end
 
         def node_type(node)
+          # Frequency-ordered: elements and text dominate every real
+          # document, and Node.wrap dispatches here once per cold
+          # wrap. CDATA must precede Text (CDATA < Text in the
+          # binding).
           case node
+          when ::Leptris::XML::Element then :element
+          when ::Leptris::XML::CDATA then :cdata
+          when ::Leptris::XML::Text, CustomizedLeptris::TextSegment then :text
+          when ::Leptris::XML::Attr then :attribute
+          when ::Leptris::XML::Comment then :comment
+          when ::Leptris::XML::ProcessingInstruction, CustomizedLeptris::DocumentPI then :processing_instruction
           when ::Leptris::XML::Document then :document
           when ::Leptris::XML::DocType, CustomizedLeptris::Doctype then :doctype
           when CustomizedLeptris::Declaration then :declaration
           when CustomizedLeptris::EntityReference then :entity_reference
-          when ::Leptris::XML::CDATA then :cdata
-          when ::Leptris::XML::Comment then :comment
-          when ::Leptris::XML::ProcessingInstruction, CustomizedLeptris::DocumentPI then :processing_instruction
-          when ::Leptris::XML::Text, CustomizedLeptris::TextSegment then :text
-          when ::Leptris::XML::Element then :element
-          when ::Leptris::XML::Attr then :attribute
           else :unknown
           end
         end
@@ -965,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) }
@@ -1040,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)|
@@ -1059,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/entity.rb

@@ -55,9 +55,12 @@ module Moxml
     module_function
 
     # Replace non-standard entity references with markers before
-    # parsing. Always returns a UTF-8 encoded string.
-    def preprocess_entities(xml)
-      return "" if xml.nil?
+    # parsing. Always returns a UTF-8 encoded string, and reports
+    # whether the result can contain markers: the flag rides the
+    # same `&` scan, so callers needing it (leptris parse) avoid a
+    # second full-buffer multibyte probe.
+    def preprocess_with_marker_flag(xml)
+      return ["", false] if xml.nil?
 
       str = if xml.encoding == Encoding::BINARY
               # Binary strings are assumed to be UTF-8. If the bytes are
@@ -78,11 +81,23 @@ module Moxml
       # Fast path: no `&` means no entity references to mark — skip
       # the regex scan and string allocation entirely. The vast
       # majority of XML payloads contain no entity references.
-      return str unless str.include?("&")
+      return [str, false] unless str.include?("&")
 
-      str.gsub(NAME_RE) do |match|
-        STANDARD_ENTITIES.include?(::Regexp.last_match(1)) ? match : "#{MARKER}#{::Regexp.last_match(1)};"
+      marked = false
+      processed = str.gsub(NAME_RE) do |match|
+        name = ::Regexp.last_match(1)
+        if STANDARD_ENTITIES.include?(name)
+          match
+        else
+          marked = true
+          "#{MARKER}#{name};"
+        end
       end
+      [processed, marked]
+    end
+
+    def preprocess_entities(xml)
+      preprocess_with_marker_flag(xml)[0]
     end
 
     # Resolve numeric (&#NN; / &#xNN;) and the five standard named

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.8"
+  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.8
+  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