moxml 0.5.109 → 0.5.111

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 04f63f1599959406386523aafe8289335b021ee5b729b0ac88dec032e08fac55
-  data.tar.gz: f4d6cbd0012ef39253c519edd2af087c8ff230b7689622bad6143138e21c9d7d
+  metadata.gz: 24c16db3331672007afc4d08d042c3c44b52cfd00b3c20a026d88646afc842a7
+  data.tar.gz: 412edab11fe3895ef32a0f0520fb819fd2b5ea01b4436f08d715c0b38b132d1f
 SHA512:
-  metadata.gz: f18cb5879bc64127726fc090c2c0f570edb813a032186e883d0c8ac3af7c96ec544f5c3fae7ca3d760b4fb5aba8ac5a1fb2a6a1422e27e7029f074543a036389
-  data.tar.gz: a22ade19383fc5da7052f713761fe7bd458e062c59de10e6c8ab00d07f747a00b9627d7503148092630c798359074cbcabb05b91512b1953fd237087beafc2b5
+  metadata.gz: dc6537c232494b1b33ec4f4f821e392ca38e8f274e01d0973f5725449b6688c5ba5ec598b50ef74dbb3a9d0b26fce15f411bde9d93d02744b0d663482e603d05
+  data.tar.gz: '019eb6bacde42ea30d76d6207da5f95d5c05e907c6f144e7f4c21cf92790bc150780f9289ac88fdc5ac94223f862ba198096bd040c90d26f146f54e52c6dc797'

data/lib/moxml/adapter/leptris.rb

@@ -146,6 +146,21 @@ module Moxml
       NATIVE_SAX_RECORDS =
         Gem::Version.new(::Leptris::VERSION) >= Gem::Version.new("1.9.242")
 
+      # Document#absorb (engine #1548): one call transfers a source
+      # document's pool ownership into the destination, so
+      # cross-document attaches of its nodes move by reference (O(1),
+      # no deep copy) instead of rebuilding or copying at every seam.
+      # Floor 1.9.311.3, not .0: the .0 finalizer double-freed pools
+      # whose absorbed sources survived to process exit, and its
+      # splice paths dropped absorbed nodes (both fixed in .3 —
+      # leptris-ruby#386). The method_defined probe pairs with the
+      # version gate (misrelease races — the NATIVE_PLAN_STRUCTS
+      # lesson).
+      NATIVE_DOC_ABSORB =
+        defined?(::Leptris::XML::Document) &&
+        ::Leptris::XML::Document.method_defined?(:absorb) &&
+        Gem::Version.new(::Leptris::VERSION) >= Gem::Version.new("1.9.311.3")
+
       # XSLT 1.0/2.0/3.0 through the engine's compiled-stylesheet
       # faces (Moxml::XSLT contract). Top-level parameters are not
       # threaded through the faces yet (leptris-ruby#360) — non-empty
@@ -1921,13 +1936,17 @@ module Moxml
         # collected its arena dies and the subtree vanishes (empty
         # output, nameless element pairs — silent, GC-dependent). Pin
         # the owning document on the target's document so the arena
-        # outlives every attached subtree.
+        # outlives every attached subtree. Absorb (1.9.311) is NOT
+        # taken here: the binding's splice paths are unreliable for
+        # absorbed sources (transitively-stale handles drop nodes), so
+        # only the element moves that route through the raw engine add
+        # (add_child / sibling inserts below) absorb first.
         def pin_foreign_owner_document(parent, child)
           return unless child.is_a?(NN) || child.is_a?(::Leptris::XML::Node)
 
           # Two document fetches + identity compare on the same-document
-          # hot path (every builder add_child); the WeakMap bridge and
-          # the pin only pay when the child actually comes from another
+          # hot path (every builder add_child); the bridge and the
+          # pin only pay when the child actually comes from another
           # document.
           child_doc = child.is_a?(NN) ? NN_DOCUMENT.bind_call(child) : child.document
           return if child_doc.nil?
@@ -1947,7 +1966,103 @@ module Moxml
           attachments.set(parent_doc, :adopted_docs, docs)
         end
 
+        # True when new_node's owning document (or the absorber its
+        # pool moved into) was absorbed into node's document: the pool
+        # is already the destination's, so splices must not take the
+        # adopt/copy paths. The engine re-parents pool ownership but
+        # NOT the node→document handles (they keep answering the
+        # original parse document), so the absorbed-sources set is the
+        # only authority. The binding's splice paths also drop
+        # absorbed-source nodes upstream (their absorbed_into? check
+        # is not transitive) — route absorbed splices through the raw
+        # engine faces.
+        def source_absorbed_into?(node, new_node)
+          return false unless NATIVE_DOC_ABSORB
+
+          node_doc = node.is_a?(NN) ? NN_DOCUMENT.bind_call(node) : node.document
+          new_doc = new_node.is_a?(NN) ? NN_DOCUMENT.bind_call(new_node) : new_node.document
+          return false if node_doc.nil? || new_doc.nil? || node_doc.equal?(new_doc)
+
+          owner = new_doc.is_a?(NN) ? to_binding(new_doc) : new_doc
+          dest = node_doc.is_a?(NN) ? to_binding(node_doc) : node_doc
+          attachments.get(dest, :absorbed_sources)&.include?(owner) || false
+        end
+
+        # 1.9.311 (engine #1548): move semantics for doomed splice
+        # sources. Absorbing the child's document into the target
+        # transfers pool ownership, so every later attach of its nodes
+        # moves by reference instead of copying (the #376 structural
+        # rebuild and its pointer-identity loss disappear; the engine
+        # re-parents node→document so the same-doc gates resolve).
+        # Absorb exactly once per (dest, owner): re-absorbing is an
+        # engine error. On success the source's free becomes
+        # handle-only — the reverse attachment pins the new pool owner
+        # on the source, so a living source can never outlive the
+        # memory its reads still touch.
+        def absorb_source_document(dest, owner)
+          return nil unless NATIVE_DOC_ABSORB
+          return :direct if attachments.get(dest, :absorbed_sources)&.include?(owner)
+
+          # The child's document handle keeps answering its original
+          # parse document even after that document's pool was
+          # absorbed upward — the pool follows the absorber. On a
+          # rejected absorb (already owned elsewhere), chase the
+          # absorber chain and absorb the current pool owner. Returns
+          # :direct on a first-attempt absorb, :chased when the pool
+          # had to be taken from an upstream absorber (the binding's
+          # splice paths drop such nodes — their absorbed_into? checks
+          # are not transitive — so only raw engine faces may follow a
+          # chase), nil when absorb is unavailable/refused.
+          status = :direct
+          candidate = owner
+          while candidate
+            begin
+              dest.absorb(candidate)
+            rescue ::Leptris::XML::Error, ::RuntimeError
+              status = :chased
+              candidate = attachments.get(candidate, :absorbed_by)
+              next
+            end
+            sources = attachments.get(dest, :absorbed_sources) || []
+            sources << candidate
+            sub = attachments.get(candidate, :absorbed_sources)
+            sources.concat(sub) if sub
+            sources << owner unless sources.include?(owner)
+            attachments.set(dest, :absorbed_sources, sources)
+            # Un-pin: a pinned absorbed owner lives until exit and
+            # its finalizer double-frees the transferred pool
+            # (leptris-ruby#386).
+            docs = attachments.get(dest, :adopted_docs)
+            if docs
+              docs.delete(owner)
+              attachments.set(dest, :adopted_docs, docs)
+            end
+            attachments.set(candidate, :absorbed_by, dest)
+            attachments.set(owner, :absorbed_by, dest) unless owner.equal?(candidate)
+            return status
+          end
+          nil
+        end
+
         def add_child(parent, child)
+          # 1.9.311: binding-family children (created PIs, texts...) —
+          # a DIRECT absorb makes the binding add below move the node
+          # by reference. A source already owned elsewhere would need
+          # a chase, and the binding's splice drops chased sources
+          # 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) &&
+              child.is_a?(::Leptris::XML::Node) &&
+              !child.is_a?(CustomizedLeptris::EntityReference)
+            child_doc = child.document
+            parent_doc = parent.is_a?(NN) ? NN_DOCUMENT.bind_call(parent) : parent.document
+            if child_doc && parent_doc && !child_doc.equal?(parent_doc)
+              owner = to_binding(child_doc)
+              absorb_source_document(to_binding(parent_doc), owner) if
+                attachments.get(owner, :absorbed_by).nil?
+            end
+          end
           if NATIVE_READ_LAYER && !(NATIVE_MUTATIONS_COHERENT &&
                    parent.is_a?(::Leptris::XML::NativeNode) &&
                    child.is_a?(::Leptris::XML::NativeNode))
@@ -1973,12 +2088,19 @@ module Moxml
               # binding's create faces — correct tree; the caller's
               # wrapper keeps addressing the source original (pointer
               # identity waits on the upstream installed-handle face).
-              # Non-element kinds keep the plain C add.
+              # 1.9.311 (engine #1548): absorb the source document
+              # first and the plain add MOVES the element by reference
+              # (O(1), no copy, no live-set doubling) — the rebuild
+              # only fires when absorb is refused. Non-element kinds
+              # keep the pin + plain C add: the binding's splices drop
+              # absorbed-source nodes upstream.
               child_doc = NN_DOCUMENT.bind_call(child)
               parent_doc = NN_DOCUMENT.bind_call(parent)
               if child_doc && parent_doc &&
                   !child_doc.equal?(parent_doc) && child.node_type == :element
-                return structural_adopt(parent, child)
+                absorb_source_document(to_binding(parent_doc), to_binding(child_doc))
+                return structural_adopt(parent, child) unless
+                  source_absorbed_into?(parent, child)
               end
 
               doc = NN_DOCUMENT.bind_call(parent)
@@ -2015,7 +2137,18 @@ module Moxml
             node.document.add_pi(new_node.target, new_node.content.to_s)
             return new_node
           end
-          return node.add_previous_sibling(new_node) if node.is_a?(::Leptris::XML::Element)
+          # 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)
+            new_doc = new_node.document
+            node_doc = node.document
+            if new_doc && node_doc && !new_doc.equal?(node_doc)
+              absorb_source_document(node_doc, new_doc)
+            end
+          end
+          return node.add_previous_sibling(new_node) if node.is_a?(::Leptris::XML::Element) &&
+            !source_absorbed_into?(node, new_node)
 
           # Non-element receivers: raw-FFI anchor (issue #245, same
           # shape as add_next_sibling).
@@ -2034,7 +2167,18 @@ module Moxml
             new_node = to_binding(new_node)
           end
           pin_foreign_owner_document(node, new_node)
-          return node.add_next_sibling(new_node) if node.is_a?(::Leptris::XML::Element)
+          # 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)
+            new_doc = new_node.document
+            node_doc = node.document
+            if new_doc && node_doc && !new_doc.equal?(node_doc)
+              absorb_source_document(node_doc, new_doc)
+            end
+          end
+          return node.add_next_sibling(new_node) if node.is_a?(::Leptris::XML::Element) &&
+            !source_absorbed_into?(node, new_node)
 
           # Non-element receivers (Text/Comment/CDATA): the binding's
           # method is Element-only, but the C insert anchors on any
@@ -2132,6 +2276,10 @@ module Moxml
           # content node (text/comment/CDATA/PI) is replaced by
           # unlinking and re-inserting: after an element sibling when
           # one exists, else appended (end-of-list) to the parent.
+          # Raw engine faces, not the binding add: a parent resolved
+          # through an absorbed source's stale document handle sends
+          # same-pool adds down the adoption path, which drops
+          # non-element kinds (leptris-ruby#376 family).
           parent = node.parent
           unless parent
             raise Moxml::DocumentStructureError.new(
@@ -2142,9 +2290,17 @@ module Moxml
           prev = node.previous_sibling
           node.unlink
           if prev.is_a?(::Leptris::XML::Element)
-            prev.add_next_sibling(new_node)
+            ::Leptris::XML::FFI.check_status(
+              ::Leptris::XML::FFI.leptris_element_insert_after(
+                prev.c_ptr, new_node.c_ptr
+              ),
+            )
           else
-            parent.add_child(new_node)
+            ::Leptris::XML::FFI.check_status(
+              ::Leptris::XML::FFI.leptris_element_append_child(
+                parent.c_ptr, new_node.c_ptr
+              ),
+            )
           end
           new_node
         end

data/lib/moxml/element.rb

@@ -127,8 +127,8 @@ module Moxml
     # writes bump it (see invalidate_attribute_value_cache!).
     def attribute_pairs
       generation = attribute_value_generation
-      @pairs = nil if @pairs_gen != generation
-      @pairs_gen = generation
+      @attribute_pairs = nil if @attribute_pairs_gen != generation
+      @attribute_pairs_gen = generation
       @attribute_pairs ||= adapter.attribute_pairs(@native)
     end
 

data/lib/moxml/version.rb

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

data/spec/integration/shared_examples/node_wrappers/processing_instruction_behavior.rb

@@ -64,22 +64,12 @@ RSpec.shared_examples "Moxml::ProcessingInstruction" do
     end
 
     it "removes from element" do
-      # leptris >= 1.9.304 adopts the cross-document PI by copy and
-      # removes the source; the wrapper still addresses the removed
-      # source, so a later remove misses the tree's copy — parked on
-      # the upstream installed-handle face (leptris-ruby#376).
-      if context.config.adapter_name == :leptris
-        skip "PI copy-identity parked on leptris-ruby#376"
-      end
       element.add_child(pi)
       pi.remove
       expect(element.children).to be_empty
     end
 
     it "replaces with another node" do
-      if context.config.adapter_name == :leptris
-        skip "PI copy-identity parked on leptris-ruby#376"
-      end
       element.add_child(pi)
       text = doc.create_text("replacement")
       pi.replace(text)

data/spec/moxml/adapter/leptris_adoption_spec.rb

@@ -2,13 +2,12 @@
 
 require "spec_helper"
 
-# leptris >= 1.9.304 adopts cross-document children BY COPY
-# (leptris-ruby#1528 — the engine deep-copies at the splice so a
-# scratch document can no longer dangle adopted nodes). The engine's
-# status-returning splices cannot report the installed handle, so
-# wrapper-level pointer identity for the appended node is not
-# restorable yet (filed upstream): these pin the ADOPTION contract —
-# the copy lands in the tree, correct names, doc-owned.
+# Cross-document adoption contract. leptris >= 1.9.311 absorbs the
+# source document's pool into the destination (engine #1548) so
+# attaches move by reference — wrapper identity survives; older
+# bindings deep-copy at the splice (leptris-ruby#1528) and only the
+# ADOPTION shape is pinned (the copy lands in the tree, correct
+# names, doc-owned).
 RSpec.describe "leptris cross-document adoption" do
   let(:ctx) { Moxml.new(:leptris) }
 
@@ -31,4 +30,74 @@ RSpec.describe "leptris cross-document adoption" do
     expect(doc.root.children.to_a[1].name).to eq("x")
     expect(doc.at("//r/x")).not_to be_nil
   end
+
+  context "when the binding offers Document#absorb (>= 1.9.311)" do
+    before do
+      unless Moxml::Adapter::Leptris::NATIVE_DOC_ABSORB
+        skip "binding #{Leptris::VERSION} has no absorb face"
+      end
+    end
+
+    it "moves the child by reference — the wrapper addresses the attached node" do
+      doc = ctx.parse("<r><a/></r>")
+      other = ctx.parse("<other><new/></other>")
+      child = other.root.children.first
+      doc.root.add_child(child)
+      expect(doc.root.children.last).to eq(child)
+      expect(doc.root.to_xml).not_to include("<other")
+      child["probe"] = "1"
+      expect(doc.at("//r/new")["probe"]).to eq("1")
+      expect(child.parent.name).to eq("r")
+    end
+
+    it "keeps the pre-311 adoption behavior for non-element kinds" do
+      # Absorb is scoped to element moves: the binding's splice paths
+      # drop absorbed-source nodes upstream (their absorbed_into?
+      # check is not transitive), so binding-family children keep
+      # the 1.9.304 adoption copy.
+      doc = ctx.parse("<r/>")
+      other = ctx.parse("<other/>")
+      pi = other.create_processing_instruction("xml-stylesheet", 'href="s.xsl"')
+      other.root.add_child(pi)
+      doc.root.add_child(pi)
+      expect(doc.root.to_xml).to include("<?xml-stylesheet")
+    end
+
+    it "keeps the tree alive after the source document is collected" do
+      doc = ctx.parse("<r/>")
+      child = nil
+      3.times do
+        other = ctx.parse("<other><deep><leaf v='1'>t</leaf></deep></other>")
+        child = other.root.children.first
+        doc.root.add_child(child)
+        nil
+        GC.start
+      end
+      expect(doc.at("//r/deep/leaf")["v"]).to eq("1")
+      expect(doc.at("//r/deep/leaf").text).to eq("t")
+      expect(child.name).to eq("deep")
+    end
+
+    it "keeps a living source readable after its pool is absorbed" do
+      doc = ctx.parse("<r/>")
+      other = ctx.parse("<other><x>1</x></other>")
+      doc.root.add_child(other.root.children.first)
+      expect(other.root.name).to eq("other")
+      expect(other.at("//other")).not_to be_nil
+    end
+
+    it "moves elements whose pool was absorbed through an intermediate document" do
+      # scratch → mid (first splice) → doc: the chase takes the pool
+      # from mid; the raw engine add then moves by pool identity.
+      doc = ctx.parse("<r/>")
+      mid = ctx.parse("<mid/>")
+      scratch = ctx.parse("<scratch><deep v='1'>t</deep></scratch>")
+      mid.root.add_child(scratch.root.children.first)
+      expect(mid.root.to_xml).to include("<deep")
+      doc.root.add_child(mid.root.children.first)
+      expect(doc.at("//r/deep")["v"]).to eq("1")
+      expect(doc.root.to_xml).not_to include("<mid>")
+      expect(mid.root.to_xml).not_to include("<deep")
+    end
+  end
 end

data/spec/moxml/element_attribute_pairs_spec.rb

@@ -39,4 +39,23 @@ RSpec.describe Moxml::Element do
       end
     end
   end
+
+  context "when memoized" do
+    it "returns the same object on repeated reads" do
+      with_adapter(:leptris) do |ctx|
+        root = ctx.parse(xml).root
+        expect(root.attribute_pairs).to equal(root.attribute_pairs)
+      end
+    end
+
+    it "refreshes after a value write" do
+      with_adapter(:leptris) do |ctx|
+        root = ctx.parse(xml).root
+        before = root.attribute_pairs
+        root["id"] = "r9"
+        expect(root.attribute_pairs).not_to equal(before)
+        expect(root.attribute_pairs).to include(["id", "r9"])
+      end
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: moxml
 version: !ruby/object:Gem::Version
-  version: 0.5.109
+  version: 0.5.111
 platform: ruby
 authors:
 - Ribose Inc.