moxml 0.5.113 → 0.5.114

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c61331ea3536aa41170080eb6233643b3b48da707d268da9185ed11fbdcad87d
-  data.tar.gz: ef1765b2e2651438c8d38012ea374e2a8b9fe6ebcaff63d2afaf476eb0f727ab
+  metadata.gz: 6cc0d0436680fb9c46169bc93e45197b20b71bf6970d737750e63fb110a5e75e
+  data.tar.gz: 8f71ca799b845b4fb28a977f6515ac1b702b6557259667c5b034f5b612ef6b67
 SHA512:
-  metadata.gz: 2058949ca13a105d38f86b5c38acf3fb974ca9445faedda64ea7d857bf8f10561d5b6df42d7b56ede501d0fcb9186f0347349faee29dd66868b83ec47a94ac4c
-  data.tar.gz: c7c7b4f0b0d529ec793e790072d2115fe6ff7c17a389e08a84abadc2ab324e058f4f49d1e5d5a6e1143b0f688ac893b5ebae083638f1482b9b526b99d7c636fd
+  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

@@ -1900,6 +1900,16 @@ module Moxml
         # 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 =
@@ -2348,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.113"
+  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/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.113
+  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