moxml 0.5.105 → 0.5.107

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0c57aa62d4c524daa9096eb565711a4ebbed7525ba851cb6e327c98de842c4e4
-  data.tar.gz: 604a922868c9ba3fb656c41e84e7b2f848bdd20defcd5259d697da32e2fd7e0e
+  metadata.gz: abbc78c5ee5efd00d9513dbe54fa844d69518c656f2eaec2c16984230ef86e09
+  data.tar.gz: 2d45e9d308e8c5826d1dafdbeab32e1c0ef1f44dbbb51586283183436b6e42cf
 SHA512:
-  metadata.gz: 80f4dc813942807549d58b93492e731dceeb3528e7cfcfd3f3a3d4c5fbd1a2c4d5b234cbc1cad9b8945efc1c280e4408b373ac8d0bf2e489051277b98716fc82
-  data.tar.gz: c91474a18a6877d6c0a012765f27c37c2ccd42260c810b130d62c3d69a6f55f2e08019a6472bb6f1b5d1f8649f99c3747f0139c72a80a606322850e56a98f134
+  metadata.gz: 3074fb3116eab8bc30697dd0fb75221c10be71f2d2cc884d1954911c7b054ca314db8407a31637fa9c59bd53c00d7bf9b648d436d87cfaec3bffe1102c7af366
+  data.tar.gz: 3a08135e70f29be37a8c97c75e01239386bd43a4d14c32837525b9395b68ff2778181a1a5499116884eb796bb6b08e30a40509c7d2a5ee25b4056d34ff188dcf

data/README.adoc

@@ -108,10 +108,15 @@ REQUIRED for that drain to be CORRECT: 1.9.240/241 drain documents
 containing duplicate attributes without surfacing the fatal error
 (moxml#281), so the drain arms only on 1.9.242+, where such
 documents fall back to the callback path and the error fires.
-Current recommendation: 1.9.242+ (the record-drain train; carries
-the plan-ABI surface — bound plan rows, typed scalars, fused
-Descriptor#materialize — plus the 1.9.217+ borrowed-text-run and
-1.9.221+ memory wins).
+1.9.255.2+ C-minted walk/build wrappers (construction identity
+without the Ruby mint); 1.9.273.1+ opt-in parse-skip flags
+(`skip_dup_detection`, `skip_source_positions`); 1.9.290.0+ XSLT
+top-level params threading and the bulk child-list append
+(one crossing for N children); 1.9.292.0+ native cross-document
+root adoption (the engine deep-copies a foreign root in C).
+Current recommendation: 1.9.292+ (the native-adoption train;
+carries the plan-ABI surface, the 1.9.290 XSLT-params and
+bulk-append faces, and the 1.9.292 engine deep-copy root install).
 |===
 
 NOTE: moxml's dev Gemfile pins `leptris ~> 1.9.174`, `nokogiri ~> 1.18`,
@@ -663,7 +668,22 @@ element.attribute_pairs.each do |name, value|
 end
 ----
 
+Wrapper read memos — `Element#text`, `Element#inner_text` and
+`Attribute#value` memoize on the mutation clocks (`#321`): re-read
+walks pay zero string allocation per node (a text write, child
+mutation or attribute write retires the memo; bulk builders keep
+their local-invalidation shape).
+
+Nokogiri-compatible node surface — `<<` (strings parse as markup),
+`Element#delete(name)`, `Element#children=` (whole-list batch
+replacement; one crossing to clear, one to append on leptris),
+`Element#elements`/`element_children` (engine-level element-only
+filtering), plus `next=`/`previous=`, `add_first_child`,
+`parent=`, `ancestors(sel)`, `NodeSet#-`/`to_ary`/`to_xml`,
+`to_s`/`to_str`, `content=` and `default_namespace=`.
+
 Typed struct members on `Moxml::StructPlan` — the executor casts
+
 in C with no intermediate String (unparseable input degrades to
 the raw String):
 

data/lib/moxml/adapter/base.rb

@@ -175,6 +175,14 @@ module Moxml
           node
         end
 
+        # Cross-document root adoption: adapters whose engine deep-copies
+        # a foreign root into the target document natively answer the
+        # installed native here (leptris >= 1.9.292, engine #1495);
+        # nil keeps the Ruby splice.
+        def adopt_root(_doc, _element)
+          nil
+        end
+
         # Element-only children: adapters whose engine carries the
         # face override (leptris C filter, nokogiri native); the
         # default type-filters the native child list so non-element

data/lib/moxml/adapter/leptris.rb

@@ -1437,6 +1437,23 @@ module Moxml
           end
         end
 
+        NATIVE_ROOT_ADOPT =
+          NATIVE_READ_LAYER &&
+          Gem::Version.new(::Leptris::VERSION) >= Gem::Version.new("1.9.292.0")
+
+        # The engine deep-copies the foreign subtree into the target
+        # document's pool (leptris#1495) and the binding memoizes the
+        # INSTALLED handle — a fresh pointer distinct from the consumed
+        # source. Answer the installed binding element; callers re-point
+        # wrappers at it.
+        def adopt_root(doc, element)
+          return nil unless NATIVE_ROOT_ADOPT
+
+          binding_doc = to_binding(doc)
+          binding_doc.root = to_binding(element)
+          binding_doc.root
+        end
+
         # Element-only children through the engine-level filter: the
         # C face mints element-kind natives directly (klass-children),
         # so interleaved text/comment nodes cost nothing. Entity
@@ -1845,6 +1862,51 @@ module Moxml
           attr
         end
 
+        # Rebuild a cross-document ELEMENT inside the parent's document
+        # through the binding's create faces, recursing over the source
+        # subtree (namespace declarations ride the copy). Returns the
+        # INSTALLED binding element.
+        def structural_adopt(parent_nn, child_nn)
+          doc = NN_DOCUMENT.bind_call(parent_nn)
+          src = to_binding(child_nn)
+          installed = copy_binding_subtree(doc, src)
+          ::Leptris::XML::FFI.check_status(
+            ::Leptris::XML::FFI.leptris_element_append_child(
+              ::FFI::Pointer.new(parent_nn.address), installed.c_ptr
+            ),
+          )
+          installed
+        end
+
+        def copy_binding_subtree(doc, src)
+          sub = doc.create_element(src.name.to_s)
+          (src.respond_to?(:attributes) ? src.attributes : {}).each do |k, v|
+            sub[k.to_s] = v.to_s
+          end
+          src.namespace_definitions.each do |decl|
+            sub.add_namespace_definition(decl.prefix, decl.href)
+          rescue ::Leptris::XML::Error
+            nil
+          end
+          src.children.to_a.each do |c|
+            case c
+            when ::Leptris::XML::Text
+              sub.add_child(doc.create_text_node(c.content.to_s))
+            when ::Leptris::XML::Element
+              sub.add_child(copy_binding_subtree(doc, c))
+            when ::Leptris::XML::CDATA
+              sub.add_child(doc.create_cdata(c.content.to_s))
+            when ::Leptris::XML::Comment
+              sub.add_child(doc.create_comment(c.content.to_s))
+            when ::Leptris::XML::ProcessingInstruction
+              sub.add_child(
+                doc.create_processing_instruction(c.target.to_s, c.content.to_s),
+              )
+            end
+          end
+          sub
+        end
+
         def actual_native(child_native, parent_native)
           if NATIVE_DOC_PARTS && child_native.is_a?(CustomizedLeptris::Doctype) &&
               parent_native.is_a?(::Leptris::XML::Document)
@@ -1904,9 +1966,35 @@ module Moxml
               return child
             end
             if NATIVE_MUTATIONS_COHERENT && parent.is_a?(NN) && child.is_a?(NN)
+              # 1.9.304 (leptris-ruby#376): the plain C add rejects
+              # foreign-pool children (-1) and the adoption seam's
+              # namespace lift crashes on moxml's created shapes.
+              # Rebuild the child in the parent's pool through the
+              # 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.
+              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)
+              end
+
               doc = NN_DOCUMENT.bind_call(parent)
               child = doc.create_text_node(child) if child.is_a?(String)
-              return NN_ADD_CHILD.bind_call(parent, child)
+              # The engine's document resolution can mis-report pool
+              # ownership under spec-order state (the #1242 TLS-memo
+              # family) — an -1 rejection falls back to the structural
+              # adopt for elements rather than raising through the flow.
+              begin
+                return NN_ADD_CHILD.bind_call(parent, child)
+              rescue ::Leptris::XML::Error, ::RuntimeError => e
+                raise unless e.message.include?("append_child failed")
+                raise unless child.node_type == :element
+
+                structural_adopt(parent, child)
+              end
             end
 
             child = parent.document.create_text_node(child) if child.is_a?(String)

data/lib/moxml/document.rb

@@ -29,6 +29,21 @@ module Moxml
         (owner.is_a?(Document) && owner.root.equal?(element))
       if owner.is_a?(Document) && attached &&
           !owner.equal?(self) && element.context.equal?(context)
+        installed = adapter.adopt_root(@native, element.native)
+        if installed
+          # The engine deep-copies the foreign subtree into this
+          # document's pool (leptris >= 1.9.292, engine #1495) and the
+          # binding memoizes the INSTALLED handle — a fresh pointer.
+          # Re-point the source wrapper so later writes reach the live
+          # tree, and recompute its scope-derived memos.
+          unless installed.equal?(element.native)
+            element.refresh_native!(Moxml::Node.wrap(installed, context).native)
+            element.invalidate_namespace_cache!
+          end
+          context.bump_children_generation
+          invalidate_children_cache!
+          return
+        end
         # libleptris refuses a root owned by another document (the
         # engine's set_root ownership check), while Nokogiri adopts.
         # Cross-document CHILD attaches are supported, so build the

data/lib/moxml/element.rb

@@ -360,9 +360,18 @@ module Moxml
 
     alias content= text=
 
+    # Generation-gated memo (the #321 shape): the native read
+    # allocates a fresh String per call and hydration walks re-read
+    # the same wrappers — 122k births over 10 passes of 2,000
+    # elements before this memo, 5 after. All inner-text writers are
+    # children mutations, which bump the children generation.
     def inner_text
-      text = raw_inner_text
-      entity_bearing? ? adapter.restore_entities(text) : text
+      @inner_text = nil if @inner_text_gen != context.children_generation
+      @inner_text_gen = context.children_generation
+      @inner_text ||= begin
+        text = raw_inner_text
+        entity_bearing? ? adapter.restore_entities(text) : text
+      end
     end
 
     # Returns inner text without entity marker restoration.

data/lib/moxml/node.rb

@@ -160,6 +160,9 @@ module Moxml
         nodes.each { |child| attach_child(child) }
         return NodeSet.new(nodes.map(&:native), context)
       end
+      # Nokogiri semantics: appending a NodeSet appends each node
+      return add_child_nodeset(node) if node.is_a?(NodeSet)
+
       attach_child(node)
       self
     end
@@ -173,6 +176,8 @@ module Moxml
         nodes.each { |n| attach_previous_sibling(n) }
         return NodeSet.new(nodes.map(&:native), context)
       end
+      return insert_nodeset(node) { |n| attach_previous_sibling(n) } if node.is_a?(NodeSet)
+
       attach_previous_sibling(node)
       self
     end
@@ -271,6 +276,15 @@ module Moxml
 
     def replace(node)
       context.bump_children_generation
+      # Nokogiri semantics: replacing with a NodeSet replaces with its
+      # nodes in order
+      if node.is_a?(NodeSet)
+        # each node lands immediately before self, after the
+        # previously inserted one, so forward iteration preserves
+        # order
+        node.to_a.each { |n| add_previous_sibling(adopt(n)) }
+        return remove
+      end
       node = prepare_node(node)
       invalidate_parent_children_cache!
       adapter.replace(@native, node.native)
@@ -708,6 +722,25 @@ module Moxml
       "#{name}[#{same_kind.find_index(node) + 1}]"
     end
 
+    # Nodes from another document must be adopted before attachment:
+    # the leptris C layer faults on serializing cross-document
+    # pointers. Re-parsing into this document is the adoption.
+    def adopt(node)
+      return node if node.document == document
+
+      context.parse_fragment(node.to_xml).to_a.first || node
+    end
+
+    def add_child_nodeset(node_set)
+      node_set.each { |n| attach_child(adopt(n)) }
+      node_set
+    end
+
+    def insert_nodeset(node_set)
+      node_set.each { |n| yield adopt(n) }
+      node_set
+    end
+
     def prepare_node(node)
       case node
       when String then Moxml::Node.wrap(adapter.create_text(node), context)

data/lib/moxml/node_set.rb

@@ -15,6 +15,27 @@ module Moxml
       self.class.new(remaining, @context, @parent_node)
     end
 
+    # Nokogiri-compatible set intersection: nodes present in both
+    # sets, identity-compared on natives, in this set's order.
+    def &(other)
+      included = {}.compare_by_identity
+      other.native_nodes.each { |n| included[n] = true }
+      common = native_nodes.select { |n| included.key?(n) }
+      self.class.new(common, @context, @parent_node)
+    end
+
+    # Nokogiri-compatible set union: this set's nodes followed by the
+    # other's, duplicates removed by native identity.
+    def |(other)
+      seen = {}.compare_by_identity
+      merged = (native_nodes + other.native_nodes).select do |n|
+        next false if seen.key?(n)
+
+        seen[n] = true
+      end
+      self.class.new(merged, @context, @parent_node)
+    end
+
     # nodes: Array of natives, or an adapter's LazyNodeSet — the
     # native set is held unmaterialized until an operation needs an
     # Array (#+, #<<, #delete, Range slices).

data/lib/moxml/version.rb

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

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

@@ -64,12 +64,22 @@ 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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+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.
+RSpec.describe "leptris cross-document adoption" do
+  let(:ctx) { Moxml.new(:leptris) }
+
+  it "add_child lands the adopted copy in the tree" do
+    doc = ctx.parse("<r><a/></r>")
+    other = ctx.parse("<other><new/></other>")
+    child = other.root.children.first
+    doc.root.add_child(child)
+    last = doc.root.children.last
+    expect(last.name).to eq("new")
+    expect(last.text).to eq(child.text)
+    expect(doc.root["unrelated"]).to be_nil
+  end
+
+  it "next= lands the adopted copy as the sibling" do
+    doc = ctx.parse("<r><a/><b/></r>")
+    other = ctx.parse("<other><x/></other>")
+    child = other.root.children.first
+    doc.at("//a").add_next_sibling(child)
+    expect(doc.root.children.to_a[1].name).to eq("x")
+    expect(doc.at("//r/x")).not_to be_nil
+  end
+end

data/spec/moxml/adapter/shared_examples/adapter_contract.rb

@@ -86,7 +86,14 @@ RSpec.shared_examples "xml adapter" do
     it "adds child" do
       element = described_class.create_element("new")
       described_class.add_child(root, element)
-      expect(described_class.same_node?(described_class.children(root).last, element)).to be(true)
+      last = described_class.children(root).last
+      # Move-semantics adapters keep pointer identity; leptris
+      # >= 1.9.304 adopts cross-document children BY COPY
+      # (leptris-ruby#1528/#376 — the engine deep-copies at the splice
+      # so a scratch document can no longer dangle adopted nodes).
+      # Structure is the shared contract; leptris restores wrapper
+      # identity by rebuilding in the parent's pool.
+      expect(described_class.node_name(last)).to eq("new")
     end
 
     it "adds text child" do

data/spec/moxml/at_search_spec.rb

@@ -312,6 +312,22 @@ RSpec.describe "Nokogiri-compatible node sugar" do
     end
   end
 
+  describe "Document#root= native adoption re-points the source wrapper" do
+    it "writes through the original wrapper reach the installed tree" do
+      ctx = Moxml.new(:leptris)
+      other = ctx.parse('<r xmlns="urn:x" a="1"><p>hi<b>t</b></p></r>')
+      doc = ctx.create_document
+      src_root = other.root
+      doc.root = src_root
+      # the engine deep-copies; the wrapper now addresses the installed
+      # handle — a later write must serialize into the new document
+      src_root["a"] = "2"
+      expect(doc.to_xml(indent: 0)).to include('a="2"')
+      expect(doc.root["a"]).to eq("2")
+      expect(doc.root.namespace_uri.to_s).to eq("urn:x")
+    end
+  end
+
   describe "Document#root= with a foreign root" do
     it "adopts the subtree from another document" do
       doc = Moxml.parse("<old><x/></old>")
@@ -409,6 +425,17 @@ RSpec.describe "Nokogiri-compatible node sugar" do
       expect(a.text).to eq("w")
     end
 
+    it "Element#inner_text memoizes and invalidates on child mutations" do
+      doc = Moxml.parse("<r><a>x<b>y</b>z</a></r>")
+      a = doc.at("//a")
+      first = a.inner_text
+      expect(a.inner_text).to equal(first)
+      a.add_child(doc.create_element("c"))
+      expect(a.inner_text).not_to equal(first)
+      a.text = "plain"
+      expect(a.inner_text).to eq("plain")
+    end
+
     it "Attribute#value memoizes and invalidates on value=" do
       doc = Moxml.parse(%(<r a="1"/>))
       attr = doc.root.attributes.first

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: moxml
 version: !ruby/object:Gem::Version
-  version: 0.5.105
+  version: 0.5.107
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-10-03 00:00:00.000000000 Z
+date: 2026-10-05 00:00:00.000000000 Z
 dependencies: []
 description: |
   Moxml is a unified XML manipulation library that provides a common API
@@ -440,6 +440,7 @@ files:
 - spec/moxml/adapter/base_spec.rb
 - spec/moxml/adapter/entity_restoration_spec.rb
 - spec/moxml/adapter/headed_ox_spec.rb
+- spec/moxml/adapter/leptris_adoption_spec.rb
 - spec/moxml/adapter/leptris_append_gc_spec.rb
 - spec/moxml/adapter/leptris_binding_cap_spec.rb
 - spec/moxml/adapter/leptris_doc_parts_spec.rb