moxml 0.5.112 → 0.5.114

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 63a1ceed1b65075fbb6187383de91bba6fa8a4dc98d7b6c5e1a8b72c6cdbd5c8
-  data.tar.gz: f60b17278dd6ce812b27e7bcae595fe464d3192d24bfd68c0b6fb98c285b4dea
+  metadata.gz: 6cc0d0436680fb9c46169bc93e45197b20b71bf6970d737750e63fb110a5e75e
+  data.tar.gz: 8f71ca799b845b4fb28a977f6515ac1b702b6557259667c5b034f5b612ef6b67
 SHA512:
-  metadata.gz: 7a4fd16c91ce73fe9fd1ce72d617fe1d5009d454e5bf8418b1e96f36c804459e4b0186d593b813a84d9092fb9c5818f6b25a95aac6b69feedc34eeba2822ad26
-  data.tar.gz: 7f1238c394d8ad91e18176ca7d863477ed968fc91bf093a5113885c33665a15a1f83a2696fa68131e039344905679739f97d4c0b1f5ef06b1baf438231ad74c3
+  metadata.gz: 1edf604a33151f0079608d52231a1486a252cda307f49fd958e05f41e3229394a952245159939c2f4dac67ecba9f612ef6c4718d7f450c3260e1f78fc4d83135
+  data.tar.gz: 92aeae211e0b8abae0ce569c9dbd650f3b2b8426e975a42e3341317ebeb6c09928adbb0265b2ea7cdb726ca40d9ac376be1e537200d2166255fc30f365afd7ed

data/.rubocop.yml

@@ -23,6 +23,10 @@ AllCops:
 # the zero-allocation streaming form (issue #143). One parameter per
 # record key is the interface; a shorter list would need a wrapper
 # object, which is the allocation the API exists to avoid.
+Metrics/BlockLength:
+  Exclude:
+    - 'Rakefile'
+
 Metrics/ParameterLists:
   Exclude:
     - 'lib/moxml/materializer.rb'

data/Rakefile

@@ -190,7 +190,12 @@ namespace :spec do
 
   desc "Run unit tests only"
   RSpec::Core::RakeTask.new(:unit) do |t|
-    t.pattern = "spec/unit/**/*_spec.rb"
+    # Unit specs live under spec/moxml/ — the stale glob matched
+    # nothing (spec/unit/ holds only the rexml_isolated_test.rb
+    # entity-era investigation artifact), so this leg ran zero
+    # examples and hid the moxml suite from the fast gate.
+    t.pattern = "spec/moxml/**/*_spec.rb"
+    t.exclude_pattern = "spec/moxml/adapter/**/*_spec.rb"
   end
 
   desc "Run adapter tests only"

data/lib/moxml/adapter/leptris.rb

@@ -1893,6 +1893,54 @@ module Moxml
           installed
         end
 
+        # moxml#335: the engine's document resolution can mis-report
+        # pool ownership under spec-order state (the #1242 TLS-memo
+        # family), so a plain add can -1 for ANY node kind — not just
+        # elements and text. Elements rebuild structurally (the #376
+        # contract); every other kind carries no cross-document
+        # identity worth preserving, so reconstruct it in the parent's
+        # document through the binding's create faces.
+        def contains_foreign_child?(parent_nn, children)
+          parent_doc = NN_DOCUMENT.bind_call(parent_nn)
+          return false if parent_doc.nil?
+
+          children.any? do |child|
+            child_doc = NN_DOCUMENT.bind_call(child)
+            child_doc && !child_doc.equal?(parent_doc)
+          end
+        end
+
+        def rebuild_foreign_child(parent_nn, child_nn)
+          doc = NN_DOCUMENT.bind_call(parent_nn)
+          rebuilt =
+            case child_nn.node_type
+            when :element
+              return structural_adopt(parent_nn, child_nn)
+            when :text
+              doc.create_text_node(child_nn.text)
+            when :comment
+              doc.create_comment(child_nn.text)
+            when :cdata
+              doc.create_cdata(child_nn.text)
+            when :processing_instruction, :pi
+              doc.create_processing_instruction(
+                child_nn.target, child_nn.content.to_s
+              )
+            else
+              raise Moxml::DocumentStructureError.new(
+                "cannot rebuild a #{child_nn.node_type} node",
+              )
+            end
+          # The raw engine add rejects binding-family children —
+          # append through the FFI face like structural_adopt.
+          ::Leptris::XML::FFI.check_status(
+            ::Leptris::XML::FFI.leptris_element_append_child(
+              ::FFI::Pointer.new(parent_nn.address), rebuilt.c_ptr
+            ),
+          )
+          rebuilt
+        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|
@@ -2107,24 +2155,15 @@ module Moxml
               child = doc.create_text_node(child) if child.is_a?(String)
               # 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.
+              # family) — an -1 rejection rebuilds the child in the
+              # parent's document for every reconstructible kind
+              # (moxml#335), 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 %i[element text].include?(child.node_type)
 
-                if child.node_type == :element
-                  structural_adopt(parent, child)
-                else
-                  # A text node carries no cross-document identity worth
-                  # preserving: rebuild it in the parent's document
-                  NN_ADD_CHILD.bind_call(
-                    parent,
-                    doc.create_text_node(child.text),
-                  )
-                end
+                rebuild_foreign_child(parent, child)
               end
             end
 
@@ -2319,6 +2358,32 @@ module Moxml
           Gem::Version.new(::Leptris::VERSION) >= Gem::Version.new("1.9.290.0")
 
         def replace_children(node, new_children)
+          # Cross-pool children: the binding's bulk face adopts per
+          # node and fails on mixed kinds (inner_xml= with
+          # text+elements died with Memory allocation failed —
+          # pre-existing). Rebuild foreign children in this pool
+          # after the clear — fragment children carry no identity
+          # worth preserving; same-document children keep the plain
+          # add, in order.
+          if NATIVE_MUTATIONS_COHERENT && node.is_a?(NN) &&
+              new_children.all?(NN) &&
+              contains_foreign_child?(node, new_children)
+            ::Leptris::XML::FFI.check_status(
+              ::Leptris::XML::FFI.leptris_element_remove_children(
+                ::FFI::Pointer.new(node.address),
+              ),
+            )
+            node_doc = NN_DOCUMENT.bind_call(node)
+            new_children.each do |child|
+              child_doc = NN_DOCUMENT.bind_call(child)
+              if child_doc && !child_doc.equal?(node_doc)
+                rebuild_foreign_child(node, child)
+              else
+                NN_ADD_CHILD.bind_call(node, child)
+              end
+            end
+            return node
+          end
           if NATIVE_READ_LAYER
             node = to_binding(node)
             new_children = new_children.map { |child| to_binding(child) }

data/lib/moxml/element.rb

@@ -400,14 +400,17 @@ module Moxml
     end
 
     def inner_xml=(xml)
-      wrapper = "_moxml_inner_#{Process.pid}_#{object_id}"
-      doc = context.parse("<#{wrapper}>#{xml}</#{wrapper}>")
+      # Fragment parse, not a wrapper element around interpolated
+      # input (TODO.refactor/03): the fragment face is the same one
+      # add_child(String) uses, so semantics match and no wrapper
+      # name can collide with content.
+      nodes = context.parse_fragment(xml).to_a
       @text = nil
       # Whole-list replacement rides the children generation like
       # children= does (moxml#310) — text and elements memos across
       # wrappers recompute on next read.
       context.bump_children_generation
-      adapter.replace_children(@native, doc.root.children.map(&:native))
+      adapter.replace_children(@native, nodes.map(&:native))
       invalidate_children_cache!
     end
 

data/lib/moxml/version.rb

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

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

@@ -89,6 +89,25 @@ RSpec.shared_examples "Moxml::Element" do
         expect(element.children.first.name).to eq("child")
         expect(element.children.first.text).to eq("text")
       end
+
+      it "sets inner XML with mixed top-level nodes" do
+        # Structure, not serialization spelling: Ox renders bare
+        # text as <s> nodes and rexml/oga expand empty tags.
+        element.inner_xml = "a<c1/>b<c2 v='1'/>c"
+        kids = element.children
+        expect(
+          kids.map { |c| c.element? ? :element : :content },
+        ).to eq(%i[content element content element content])
+        expect(kids[0].text).to eq("a")
+        expect(kids[2].text).to eq("b")
+        expect(kids[4].text).to eq("c")
+        expect(kids[3]["v"]).to eq("1")
+      end
+
+      it "sets inner XML containing element-like text and entities" do
+        element.inner_xml = "<c>&lt;/element&gt; &amp; &#65;</c>"
+        expect(element.children.first.text).to eq("</element> & A")
+      end
     end
 
     describe "node manipulation" do

data/spec/moxml/adapter/leptris_adoption_spec.rb

@@ -10,6 +10,7 @@ require "spec_helper"
 # names, doc-owned).
 RSpec.describe "leptris cross-document adoption" do
   let(:ctx) { Moxml.new(:leptris) }
+  let(:ad) { Moxml::Adapter::Leptris }
 
   it "add_child lands the adopted copy in the tree" do
     doc = ctx.parse("<r><a/></r>")
@@ -100,4 +101,49 @@ RSpec.describe "leptris cross-document adoption" do
       expect(mid.root.to_xml).not_to include("<deep")
     end
   end
+
+  # moxml#335: the -1 fallback must not re-raise by node kind — the
+  # engine's document resolution can mis-report pool ownership for
+  # ANY child (the #1242 TLS-memo family), and only elements have a
+  # cross-document identity worth a structural rebuild. The helper
+  # is specced directly: the engine failure is CI-only, so forcing
+  # the -1 locally is not reproducible.
+  context "when the add_child -1 rebuild fallback fires" do
+    it "rebuilds comments in the parent's document" do
+      doc = ctx.parse("<r/>")
+      other = ctx.parse("<other><!-- note --></other>")
+      ad.rebuild_foreign_child(doc.root.native, other.root.children.first.native)
+      expect(doc.root.to_xml).to include("<!-- note -->")
+      expect(other.root.to_xml).to include("<!-- note -->")
+    end
+
+    it "rebuilds CDATA in the parent's document" do
+      doc = ctx.parse("<r/>")
+      other = ctx.parse("<other><![CDATA[x < y]]></other>")
+      ad.rebuild_foreign_child(doc.root.native, other.root.children.first.native)
+      expect(doc.root.to_xml).to include("<![CDATA[x < y]]>")
+    end
+
+    it "rebuilds processing instructions in the parent's document" do
+      doc = ctx.parse("<r/>")
+      other = ctx.parse("<other><?tgt data='1'?></other>")
+      ad.rebuild_foreign_child(doc.root.native, other.root.children.first.native)
+      expect(doc.root.to_xml).to include("<?tgt data='1'?>")
+    end
+
+    it "rebuilds text in the parent's document" do
+      doc = ctx.parse("<r/>")
+      other = ctx.parse("<other>t</other>")
+      ad.rebuild_foreign_child(doc.root.native, other.root.children.first.native)
+      expect(doc.root.to_xml).to include(">t<")
+    end
+
+    it "rebuilds elements structurally" do
+      doc = ctx.parse("<r/>")
+      other = ctx.parse("<other><e k='v'>t</e></other>")
+      ad.rebuild_foreign_child(doc.root.native, other.root.children.first.native)
+      expect(doc.at("//r/e")["k"]).to eq("v")
+      expect(doc.at("//r/e").text).to eq("t")
+    end
+  end
 end

data/spec/moxml/node_spec.rb

@@ -168,9 +168,10 @@ RSpec.describe Moxml::Node do
       end
     end
 
-    it "raises for node types without a path representation" do
+    it "locates non-element nodes through typed node tests" do
       text = doc.root.children.first.children.first
-      expect { text.path }.to raise_error(Moxml::NotImplementedError, /element and document/)
+      expect(text.path).to end_with("/text()")
+      expect(doc.at_xpath(text.path)).to eq(text)
     end
   end
 

data/spec/moxml/opal_oga_adapter_spec.rb

@@ -3,12 +3,18 @@
 require "spec_helper"
 require "moxml/adapter/shared_examples/adapter_contract"
 
-RSpec.describe Moxml::Adapter::Oga, if: RUBY_ENGINE == "opal" do
-  around do |example|
-    Moxml.with_config(:oga, true, "UTF-8") do
-      example.run
+# The describe resolves the adapter constant at load time — under
+# MRI nothing loads the Opal compat shim, so the whole describe must
+# sit behind the engine check (the `if:` metadata alone still
+# evaluates the constant reference).
+if RUBY_ENGINE == "opal"
+  RSpec.describe Moxml::Adapter::Oga do
+    around do |example|
+      Moxml.with_config(:oga, true, "UTF-8") do
+        example.run
+      end
     end
-  end
 
-  it_behaves_like "xml adapter"
+    it_behaves_like "xml adapter"
+  end
 end

data/spec/moxml/sax_entity_parity_spec.rb

@@ -164,7 +164,11 @@ RSpec.describe "SAX/DOM entity parity" do
         # double-escaping on round-trip.
         doc = ctx.create_document
         el = doc.create_element("doc")
-        el.add_child("a & b")
+        # Programmatically-built: a literal Text node, no markup parse.
+        # (add_child with a String operand is MARKUP since the nokogiri
+        # compat round — a bare "&" is ill-formed there and each
+        # engine recovers differently.)
+        el.add_child(doc.create_text("a & b"))
         doc.add_child(el)
 
         serialized = doc.to_xml.sub(/\A<\?[^>]*\?>\s*/, "").strip

metadata

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