moxml 0.5.56 → 0.5.58

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 30ad2e1e2f91d4d31eb467d5a2beee85bc3112585d6383bf37b0a66e6d1bca40
-  data.tar.gz: ff7ef79362aa97205ce0b16c7161a9c5d7f25720a3794a967cfb9dbf4afa3a5e
+  metadata.gz: 03fd3940f1334b3f417e4847f35e87497581404372209de4426819a8acc6d363
+  data.tar.gz: 805f6966495456ff6e36c4f1be3df9fcbbf1c89cfcf2ddc6a4153c37e1bcec71
 SHA512:
-  metadata.gz: 580fe3a426ebf5d37017fa727527518a76e2221c34543e58c22a08c41d92300e23dbc8bfc391d7f39b09ffd9b78921b1434dc2a51154af4e507e2be409935e08
-  data.tar.gz: 15cbb5eb0ca6795715aea82f2b05e017c6d5726c0b6e814713955aa4da0c7e045b21afd9304b7fd1bfdc1cc685f9b45ee743d80f5e06025770218ae383d76060
+  metadata.gz: 872ba59e6f8b72779d2ea43c8af201052a69be9d75ad1add3fa2618bc58e81cee0503ce352d06c8b46c64cc6340859006b36afeadef4302f29c81e2760285baa
+  data.tar.gz: 01eed98fc6ac76efb35d2456c9af57487bbdddf13092a09b0667d11e6e2d48a1905865046aab6a59ca8a89523fc4337a705c1b1cf95d98342d56cb4494c0d91e

data/lib/moxml/adapter/leptris.rb

@@ -246,6 +246,31 @@ module Moxml
             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
+          # already carrying the contract — wrap_native's is_a?
+          # guard short-circuits and the per-visit from() mint
+          # (the second allocation of the pair) drops out. Kind
+          # order is the C layer's node-type ints: element, text,
+          # comment, cdata, pi.
+          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,
+              Identity::TEXT,
+              Identity::COMMENT,
+              Identity::CDATA,
+              Identity::PROCESSING_INSTRUCTION,
+            ]
+            kind_classes.each do |klass|
+              klass.install_child_klasses(kind_classes)
+            end
+          end
+
           def wrap_native(node, type, _context)
             return nil unless NATIVE_IDENTITY &&
               node.is_a?(::Leptris::XML::NativeNode)
@@ -598,7 +623,21 @@ module Moxml
         # entity-marker splitting applies.
         def parse_fragment(xml, _context = nil)
           doc = parse("<m>#{xml}</m>")
-          children(doc.native.root)
+          # Lifetime seam (#245): the fragment's natives live in the
+          # parse document's C tree, and the binding Document is the
+          # sole owner with a GC finalizer. The parent_node chain
+          # (fragment -> synthetic <m> -> Document wrapper) keeps the
+          # owning wrappers strongly reachable from every returned
+          # node; the wrappers are minted HERE and returned as-is —
+          # re-wrapping at the caller would race the context map's
+          # weak values and silently drop the chain.
+          root_wrapper = doc.root
+          root_wrapper.parent_node = doc
+          children(root_wrapper.native).map do |child|
+            wrapped = Node.wrap(child, doc.context)
+            wrapped.parent_node = root_wrapper
+            wrapped
+          end
         end
 
         def iterparse(xml, mode = :top_level, _context = nil, &block)
@@ -794,6 +833,10 @@ module Moxml
 
           element = node
           if namespace.nil?
+            # Supported un-prefix (#245, relaton migration): rename
+            # the node to its local part (name = local) — the
+            # serializer re-attaches the old prefix after namespace=
+            # nil on prefixed elements until leptris-ruby#244 lands.
             # Nil-clear contract (issue #164): undeclare the default
             # namespace (xmlns="") and drop any name prefix — the
             # element then reports no namespace, matching the other
@@ -1359,7 +1402,17 @@ module Moxml
             node.document.add_pi(new_node.target, new_node.content.to_s)
             return new_node
           end
-          node.add_previous_sibling(new_node)
+          return node.add_previous_sibling(new_node) if node.is_a?(::Leptris::XML::Element)
+
+          # Non-element receivers: raw-FFI anchor (issue #245, same
+          # shape as add_next_sibling).
+          adopt_for_sibling_insert(new_node, node)
+          ::Leptris::XML::FFI.check_status(
+            ::Leptris::XML::FFI.leptris_element_insert_before(
+              node.c_ptr, new_node.c_ptr
+            ),
+          )
+          new_node
         end
 
         def add_next_sibling(node, new_node)
@@ -1367,7 +1420,31 @@ module Moxml
             node = to_binding(node)
             new_node = to_binding(new_node)
           end
-          node.add_next_sibling(new_node)
+          return node.add_next_sibling(new_node) if node.is_a?(::Leptris::XML::Element)
+
+          # Non-element receivers (Text/Comment/CDATA): the binding's
+          # method is Element-only, but the C insert anchors on any
+          # node — route through the FFI entry directly, keeping the
+          # binding's namespace-lift adoption for element inserts
+          # (issue #245).
+          adopt_for_sibling_insert(new_node, node)
+          ::Leptris::XML::FFI.check_status(
+            ::Leptris::XML::FFI.leptris_element_insert_after(
+              node.c_ptr, new_node.c_ptr
+            ),
+          )
+          new_node
+        end
+
+        # The binding's add_*_ sibling methods lift an adopted
+        # element's namespace declarations into the target scope;
+        # the raw-FFI path above must preserve that.
+        def adopt_for_sibling_insert(new_node, anchor)
+          return unless new_node.is_a?(::Leptris::XML::Element)
+          return if ::Leptris::XML::Element.skip_adoption_lift?(new_node)
+
+          scope = anchor.parent.is_a?(::Leptris::XML::Element) ? anchor.parent.namespaces : {}
+          ::Leptris::XML::Element.lift_namespaces_for_adoption(new_node, scope)
         end
 
         def remove(node)

data/lib/moxml/context.rb

@@ -124,8 +124,11 @@ module Moxml
     # are the result either way.
     def parse_fragment(xml)
       adapter = config.adapter
-      adapter.parse_fragment(xml, self).map do |native|
-        Moxml::Node.wrap(native, self)
+      adapter.parse_fragment(xml, self).map do |node|
+        # Adapters that tie a parent_node lifetime chain (#245)
+        # return wrapped nodes — pass them through untouched;
+        # re-wrapping would race the weak wrapper map.
+        node.is_a?(Moxml::Node) ? node : Moxml::Node.wrap(node, self)
       end
     end
 

data/lib/moxml/node.rb

@@ -593,10 +593,16 @@ module Moxml
 
       # Extend-in-place (issue #230): adapters whose natives can
       # carry the contract modules directly (leptris TypedData) mint
-      # the native itself as the wrapper — @native is self.
+      # the native itself as the wrapper — @native is self. The
+      # minted wrapper primes with ITSELF (not the input native):
+      # adapter calls then receive the contract-bearing receiver,
+      # which klass-propagating reads (#246) dispatch on — and the
+      # input native keeps its registration so later wraps of the
+      # same base object hit the cache instead of re-minting.
       if (extended = adapter.wrap_native(node, type, context))
-        extended.prime_contract(node, context, adapter, type)
+        extended.prime_contract(extended, context, adapter, type)
         context.register_wrapper(node, extended)
+        context.register_wrapper(extended, extended) unless extended.equal?(node)
         return extended
       end
 

data/lib/moxml/version.rb

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

data/spec/moxml/adapter/leptris_spec.rb

@@ -672,6 +672,39 @@ RSpec.describe Moxml::Adapter::Leptris do
     end
   end
 
+  describe "adapter seams from the relaton migration (issue #245)" do
+    let(:ctx) { Moxml.new(:leptris) }
+
+    it "keeps parse_fragment nodes' owning document alive" do
+      nodes = ctx.parse_fragment("<em>x</em>")
+      element = nodes.first
+      expect(element.parent_node).not_to be_nil
+      GC.start
+      GC.start
+      expect(element.name).to eq("em")
+      expect(element.text).to eq("x")
+      document = element.document
+      expect(document.children.first.name).to eq("m")
+      expect(document.children.first.children.first.name).to eq("em")
+    end
+
+    it "inserts siblings after a text node" do
+      doc = ctx.parse("<root><p>a<!--c1-->b</p></root>")
+      paragraph = doc.root.children.first
+      cursor = paragraph.children.first
+      cursor.add_next_sibling(doc.create_text("Z"))
+      expect(paragraph.to_xml).to eq("<p>aZ<!--c1-->b</p>")
+    end
+
+    it "inserts siblings before a text node" do
+      doc = ctx.parse("<root><p><!--c1-->ab</p></root>")
+      paragraph = doc.root.children.first
+      cursor = paragraph.children.last
+      cursor.add_previous_sibling(doc.create_text("Y"))
+      expect(paragraph.to_xml).to eq("<p><!--c1-->Yab</p>")
+    end
+  end
+
   describe "to_binding is defined regardless of the native layer (issue #217)" do
     it "is the identity for binding nodes" do
       ctx = Moxml.new(:leptris)
@@ -765,4 +798,32 @@ RSpec.describe Moxml::Adapter::Leptris do
       expect(pi[2]).to be_a(Integer)
     end
   end
+
+  describe "klass-propagating children" do
+    let(:ctx) { Moxml.new(:leptris) }
+
+    it "mints contract-bearing children in C" do
+      skip "requires klass-propagating reads (leptris 1.9.193.2+)" unless described_class.singleton_class.const_get(:NATIVE_KLASS_CHILDREN)
+
+      doc = ctx.parse(%(<r><e a="1"/>t</r>))
+      kids = doc.root.children
+      expect(kids.first).to be_a(Moxml::Element)
+      expect(kids.last).to be_a(Moxml::Text)
+      expect(kids.first["a"]).to eq("1")
+      expect(kids.last.text).to eq("t")
+      # The C mint IS the wrapper — @native is self, no re-mint.
+      expect(kids.first.native).to equal(kids.first)
+    end
+
+    it "keeps identity across access paths" do
+      skip "requires klass-propagating reads (leptris 1.9.193.2+)" unless described_class.singleton_class.const_get(:NATIVE_KLASS_CHILDREN)
+
+      doc = ctx.parse(%(<r><a/>t</r>))
+      first = doc.root.children.first
+      expect(doc.root.element_children.first).to equal(first)
+      expect(first.parent.children.first).to equal(first)
+      expect(first.next_sibling.text).to eq("t")
+      expect(first.next_sibling.parent).to eq(doc.root)
+    end
+  end
 end

metadata

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