moxml 0.5.32 → 0.5.34

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 627111c496efca4687eabeeb78989d611d3d308adc5ed32443c7058da51c57c9
-  data.tar.gz: 86d1cc6c471d07084e0d2e0de9412b286b5486b202f9fe677b7417f514c1fe55
+  metadata.gz: d43dcd89303022c12889585b26d38ab3bf199046d869b6412d45c6f3f9249347
+  data.tar.gz: e09d8585d90c5a2765040aaf4060bedaececca5228fe7808c11841088415d2e0
 SHA512:
-  metadata.gz: f1108c98dc8af92913605dd08b84eb50bbfec92a5dd286e15656c3ecd57937ce56bc186c9393a740f6bd8a8316f06fb059db226f20ffc9f0b84cfb433e1a532d
-  data.tar.gz: 02d109a32659b30fc34ac5d6d3f01bc0d32d9e1ca6a38cfdc2fe3880a02c779ce5ff41fa2f0eda04adc2a9ccd6702f372d29b4d2a6fe33faeb0456cb8852d26b
+  metadata.gz: ff23fcc8eaa05cefd83e236a387b707803d8fd06968e9bc84aefd450ff3f2eeca6445fe5a16e3ddd65bcf315b78e140bf27de3f45c30125a34eb6723cee26768
+  data.tar.gz: af7d2a75a27d30be26dc4daf750a77661235cf9c203b7e5c0638fde4fe58bed062499f4fa0b1f6648cb6aabc5b45768dfcfa101f095e1037143be67366ad8d94

data/Rakefile

@@ -244,6 +244,14 @@ namespace :benchmark do
     ENV.delete("SKIP_BENCHMARKS")
     sh "bundle exec rspec spec/performance/xpath_benchmark_spec.rb"
   end
+  # Consumer-pipeline leg (issue #198): nested document walked into
+  # typed objects — median time + GC.stat allocation deltas, where
+  # engine-level numbers hide wrapper overhead. PIPELINE_ADAPTER and
+  # PIPELINE_REPS env-overridable.
+  desc "Consumer-pipeline benchmark (typed-object walk, issue #198)"
+  task :pipeline do
+    sh "ruby", "benchmark/pipeline_bench.rb"
+  end
 
   desc "Generate adapter benchmark report"
   task :report do

data/benchmark/pipeline_bench.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+# Consumer-pipeline benchmark leg (issue #198): measures a nested
+# document walked into typed objects — the shape consumers actually
+# run, where engine-level numbers hide wrapper overhead (Amdahl).
+# Reports fresh-run medians with GC.stat allocation deltas.
+require "moxml"
+require "nokogiri"
+
+ADAPTER = (ENV["PIPELINE_ADAPTER"] || "leptris").to_sym
+REPS = (ENV["PIPELINE_REPS"] || 7).to_i
+
+parts = [%(<?xml version="1.0"?><catalog>)]
+150.times do |i|
+  parts << %(<record id="r#{i}" kind="k#{i % 3}">)
+  6.times { |j| parts << %(<field name="f#{j}" unit="u#{j}">value #{i}.#{j}</field>) }
+  parts << %(</record>)
+end
+parts << %(</catalog>)
+XML = parts.join
+
+Field = Struct.new(:name, :unit, :value)
+Record = Struct.new(:id, :kind, :fields)
+Catalog = Struct.new(:records)
+
+def walk_document(adapter_name)
+  ctx = Moxml.new(adapter_name)
+  doc = ctx.parse(XML)
+  catalog = Catalog.new([])
+  doc.root.children.each do |rec|
+    next unless rec.is_a?(Moxml::Element)
+
+    record = Record.new(rec["id"], rec["kind"], [])
+    rec.children.each do |f|
+      next unless f.is_a?(Moxml::Element)
+
+      record.fields << Field.new(f["name"], f["unit"], f.text)
+    end
+    catalog.records << record
+  end
+  raise "shape" unless catalog.records.size == 150
+
+  raise "content" unless catalog.records[7].fields[3].value.include?("7.3")
+
+  catalog
+end
+
+def measure(adapter_name)
+  walk_document(adapter_name) # warm: autoloads off the books
+  times = []
+  allocs = nil
+  REPS.times do
+    GC.start
+    a0 = GC.stat(:total_allocated_objects)
+    t0 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    walk_document(adapter_name)
+    t1 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    a1 = GC.stat(:total_allocated_objects)
+    times << ((t1 - t0) * 1e6)
+    allocs = a1 - a0
+  end
+  median = times.sort[times.size / 2]
+  [median, allocs]
+end
+
+noko_med, noko_alloc = measure(:nokogiri)
+puts format("pipeline nokogiri: median %<med>7.0fµs  %<allocs>6d allocs", med: noko_med, allocs: noko_alloc)
+target_med, target_alloc = measure(ADAPTER)
+puts format("pipeline %<adapter>-8s: median %<med>7.0fµs  %<allocs>6d allocs  (%<ratio>.2fx, allocs %<aratio>.2fx)",
+            adapter: ADAPTER, med: target_med, allocs: target_alloc,
+            ratio: noko_med / target_med, aratio: noko_alloc.to_f / target_alloc)
+puts format("(one-shot shape: parse + typed walk + content asserts; YJIT=%<yjit>s; load %<load>.1f)",
+            yjit: ENV["RUBY_YJIT_ENABLE"] ? "on" : "off",
+            load: `sysctl -n vm.loadavg`.split[1].to_f)

data/docs/_pages/adapter-protocol.adoc

@@ -91,6 +91,11 @@ the context's wrapper identity map opts out.
 Whether the subtree can contain entity markers; gates the
 post-serialize restore scan.
 
+`digest(node, drop_ws_text:)`::
+The backend's content-defined subtree Merkle hash where one exists
+(leptris >= 1.9.99, engine #869); nil everywhere else. `Node#digest`
+gates on nil — consumers fall back to walking.
+
 `bulk_materialize?`::
 Whether the adapter offers a bulk path for `Moxml::Materializer`;
 `materialize_fields` fills the reused flat buffers and yields the

data/docs/_pages/node-api-reference.adoc

@@ -114,6 +114,32 @@ node.namespace?        # Is it a namespace?
 node.document          # Get owning document
 ----
 
+== Subtree digest
+
+`Node#digest` exposes the backend's content-defined Merkle hash of a
+subtree when one exists — currently only the leptris adapter
+(libleptris >= 1.9.99, leptris#869):
+
+[source,ruby]
+----
+node.digest                       # => Integer (u64) or nil
+node.digest(drop_ws_text: true)   # skip whitespace-only text nodes
+----
+
+Contract:
+
+* `nil` means "no digest support" (every other adapter) — consumers
+  gate on nil and fall back to walking.
+* Equal digests imply subtree equivalence under the flag set;
+  unequal digests imply nothing (descend and compare).
+* The hash covers element prefix + resolved namespace URI + local
+  name, attributes sorted by (URI, local) and first-wins
+  deduplicated, and children in document order. No addresses
+  participate, so identical trees hash equal across parses and
+  processes.
+* Nodes without a backing engine node (documents, attributes,
+  synthetic declarations) answer nil.
+
 
 See also:
 

data/docs/_pages/performance.adoc

@@ -106,6 +106,26 @@ load-immune — use them when the machine is busy:*
 hundreds of iterations — spot checks of 30 have missed 5-30% races
 on this codebase.
 
+*More traps, paid for in this codebase:*
+
+- Optional keyword arguments do NOT allocate on Ruby 3.4 (measured
+  0.000 allocs/call with one and two optional kwargs) — do not
+  "optimize" them into positional arguments expecting an allocation
+  win. An earlier version of this page claimed otherwise: a +601
+  allocation delta attributed to kwargs was actually the write-path
+  cache clears allocating a fresh Hash per write (+500), bundled
+  into the same change as a kwargs edit. The general lesson:
+  attribute allocation deltas per-change, never per-bundle.
+- Engines free attribute natives on removal — reading any native
+  property after `remove_attribute_native` is a use-after-free.
+  The crash only surfaced mid-suite under GC churn (standalone
+  repros passed); read names BEFORE the removal call.
+- Scope invalidation to what the mutation can affect: a
+  non-xmlns attribute write cannot change namespace scope, so it
+  must not bump the document-wide scope generation (which evicts
+  every wrapper's caches). +5-8% on write-heavy mixed workloads,
+  and bulk builds stop thrashing every reader's cache.
+
 === leptris 1.9.105 numbers (reference table)
 
 XML parse 2.4-2.8x, document serialize 2.4x, element queries 32x,
@@ -198,6 +218,29 @@ first access, not at construction — `.size`/`.empty?`/`.first` on a
 (that path also skips the binding's per-node wrapper materialization
 entirely; see `LazyNodeSet` under the leptris adapter).
 
+=== Mint priming and scoped invalidation
+
+`Node.wrap` resolves the adapter and node type once and primes both
+onto the wrapper (positional constructor arguments) — a fresh
+wrapper previously re-paid the context hop and the type probe on
+its first access. Attribute writes that cannot change namespace
+scope (bare and non-`xmlns` prefixed names) invalidate the
+element's caches locally instead of bumping the document-wide scope
+generation; `xmlns` writes keep the global bump.
+
+| path | before | after |
+| Attribute write (`[]=`) | 822ns | 758ns (-8%) |
+| Cold walk (parse + wrapper mint, 752 nodes) | 811µs | 699µs (-14%) |
+| Mixed build+read (nokogiri) | 1355µs / 5267 allocs | 1283µs / 5267 allocs |
+| `Element#text` read | 422ns | 346ns (-18%) |
+| `create_text` allocations | 6/node | 5/node |
+| Bare attribute read `[]` | 714ns | 513ns (-28%) |
+
+Allocations unchanged (the invalidation clears are nil-writes; the
+read cache materializes lazily). The remaining cold-walk gap is
+binding-side (its per-node Ruby wrapper construction) — tracked
+upstream as the TypedData work.
+
 === Prefer bulk paths for per-node conversion
 
 Per-node Ruby iteration pays the wrapper tax per element. When the

data/lib/moxml/adapter/base.rb

@@ -28,6 +28,24 @@ module Moxml
           )
         end
 
+        # Uniform fragment parsing: returns the fragment's top-level
+        # nodes as native objects. Engines without a fragment node
+        # type (everything but Nokogiri) get the wrapper-parse
+        # shape — the same trick Element#append_xml and #inner_xml=
+        # use — with a synthetic root whose children are the
+        # fragment's top-level nodes.
+        def root(_document)
+          raise Moxml::NotImplementedError.new(
+            "root not implemented", feature: "root", adapter: name
+          )
+        end
+
+        def parse_fragment(xml, _context = nil)
+          doc = parse("<m>#{xml}</m>")
+          root = root(doc)
+          root ? children(root) : []
+        end
+
         # Streaming incremental parse (leptris engine): yields each
         # completed element while the parse runs, releasing prior
         # subtrees — memory bounded by the largest subtree, not the
@@ -98,14 +116,19 @@ module Moxml
           )
         end
 
+        # Backends without a native subtree digest answer nil —
+        # the wrapper contract Node#digest gates on (issue #173).
+        def digest(*)
+          nil
+        end
+
         def create_element(name, owner_doc: nil)
           validate_element_name(name)
           create_native_element(name, owner_doc)
         end
 
         def create_text(content, owner_doc: nil)
-          # Ox freezes the content, so we need to dup it
-          create_native_text(normalize_xml_value(content).dup, owner_doc)
+          create_native_text(normalize_xml_value(content), owner_doc)
         end
 
         def create_cdata(content, owner_doc: nil)

data/lib/moxml/adapter/leptris.rb

@@ -34,6 +34,12 @@ module Moxml
       ATTR_RESULT_NATIVE =
         Gem::Version.new(::Leptris::VERSION) >= Gem::Version.new("1.9.105")
 
+      # leptris_node_digest shipped in bindings 1.9.99 (libleptris
+      # 1.9.99, engine #869): on-demand Merkle subtree hash, zero
+      # cost when unused. Below it, Node#digest answers nil.
+      DIGEST_SUPPORTED =
+        Gem::Version.new(::Leptris::VERSION) >= Gem::Version.new("1.9.99")
+
       # Native C14N delegation probe: the engine's C14N must
       # byte-match the Ruby reference (ported from canon) on a
       # namespace-sorting + attributes + comments shape before
@@ -180,13 +186,12 @@ module Moxml
         # restoration when the document carries them (entity-free
         # documents — the common case — skip the scan; parentless
         # iterparse elements are never bearing).
+        # Raw qualified-name read; the entity-restore decision is
+        # the wrapper's (Element#[] rides its generation memo — the
+        # document-plus-attachment probe here cost more than the
+        # read itself).
         def bare_attr_value(element, name)
-          value = element[name.to_s]
-          if value.is_a?(String) && entity_bearing?(element)
-            restore_entities(value)
-          else
-            value
-          end
+          element[name.to_s]
         end
 
         def native_identity_stable?
@@ -254,6 +259,15 @@ module Moxml
         # elements as the parse runs; each prior subtree is released.
         # Yielded elements are parentless (document nil) and valid
         # only inside the block — the wrapper mirrors that lifetime.
+        # Wrapper-parse: the synthetic root's children are the
+        # fragment's top-level nodes (the append_xml / inner_xml=
+        # trick). Children come through the normal children path so
+        # entity-marker splitting applies.
+        def parse_fragment(xml, _context = nil)
+          doc = parse("<m>#{xml}</m>")
+          children(doc.native.root)
+        end
+
         def iterparse(xml, mode = :top_level, _context = nil, &block)
           raise ArgumentError, "iterparse requires a block" unless block
 
@@ -442,8 +456,25 @@ module Moxml
             # never applies to a prefixed name.
             element.name = element.name.split(":", 2)[-1] if element.name.include?(":")
           else
-            element.add_namespace_definition(prefix, uri.to_s)
-            element.name = "#{prefix}:#{element.name.split(':', 2)[-1]}"
+            # Name is the local part re-prefixed (a qname create leaves
+            # "p:c"; re-joining without the split would double —
+            # issue #208). Declare only when the prefix is not already
+            # in scope: under a parent that binds p, a bare name set
+            # is enough (leptris resolves through ancestors). Detached
+            # elements still get the declaration so a standalone
+            # serialize stays well-formed.
+            local = element.name.split(":", 2)[-1]
+            element.name = "#{prefix}:#{local}"
+            already = resolve_prefix_ns(element, prefix)
+            needs_decl = already.nil? || already.href.to_s != uri.to_s
+            # Detached elements that will be attached under a declaring
+            # parent must not carry their own declaration — that is
+            # the create_element(qname) + namespace= + attach order
+            # (issue #208). Standalone serialize of a still-detached
+            # namespaced element is the add_namespace caller's job.
+            if needs_decl && !element.parent.nil?
+              element.add_namespace_definition(prefix, uri.to_s)
+            end
           end
           element
         end
@@ -537,6 +568,18 @@ module Moxml
           end
         end
 
+        # Subtree digest over the binding node (issue #173). Only
+        # binding Nodes carry a C node handle: the synthetic
+        # wrappers (declarations, doctypes, entity markers) and the
+        # lightweight Attr triples answer nil.
+        def digest(node, drop_ws_text: false)
+          return nil unless DIGEST_SUPPORTED
+          return nil unless node.is_a?(::Leptris::XML::Node) &&
+            !node.is_a?(::Leptris::XML::ResultAttr)
+
+          node.digest(drop_ws: drop_ws_text)
+        end
+
         def node_name(node)
           return node.root_name if node.is_a?(::Leptris::XML::DocType)
           return node.target if node.is_a?(CustomizedLeptris::DocumentPI)
@@ -567,19 +610,10 @@ module Moxml
         end
 
         def children(node)
+          # Frequency-ordered: elements dominate every walk and paid
+          # ten failed compares to reach the else arm.
           case node
-          when ::Leptris::XML::Document
-            assemble_document_children(node)
-          when CustomizedLeptris::Declaration, CustomizedLeptris::Doctype,
-               CustomizedLeptris::EntityReference, CustomizedLeptris::TextSegment,
-               CustomizedLeptris::DocumentPI,
-               # Terminal node kinds pay an FFI round trip for an empty
-               # list; unfiltered recursions visit every text node.
-               ::Leptris::XML::Text, ::Leptris::XML::Comment,
-               ::Leptris::XML::CDATA, ::Leptris::XML::ProcessingInstruction,
-               ::Leptris::XML::Attr
-            []
-          else
+          when ::Leptris::XML::Element
             natives = node.children.to_a
             # Parse records whether the preprocessed source held any
             # entity markers, and the ER builder path flips the flag
@@ -592,22 +626,43 @@ module Moxml
               attachments.get(node.document, :entity_markers) == false
 
             split_entity_markers(natives, node)
+          when ::Leptris::XML::Document
+            assemble_document_children(node)
+          when CustomizedLeptris::Declaration, CustomizedLeptris::Doctype,
+               CustomizedLeptris::EntityReference, CustomizedLeptris::TextSegment,
+               CustomizedLeptris::DocumentPI,
+               # Terminal node kinds pay an FFI round trip for an empty
+               # list; unfiltered recursions visit every text node.
+               ::Leptris::XML::Text, ::Leptris::XML::Comment,
+               ::Leptris::XML::CDATA, ::Leptris::XML::ProcessingInstruction,
+               ::Leptris::XML::Attr
+            []
+          else
+            node.children.to_a
           end
         end
 
         def parent(node)
+          # Frequency-ordered: elements dominate navigation and paid
+          # three failed compares to reach the else arm.
           case node
+          when ::Leptris::XML::Element then root_parent(node)
           when ::Leptris::XML::Document then nil
           when CustomizedLeptris::Declaration, CustomizedLeptris::Doctype,
                CustomizedLeptris::DocumentPI then node.parent_doc
           when CustomizedLeptris::TextSegment, CustomizedLeptris::EntityReference then node.parent
-          else
-            # The binding reports the root element as parentless; the
-            # moxml contract roots at the document.
-            node.parent || (node.document&.root == node ? node.document : nil)
+          # Same body as the Element arm by design (frequency
+          # ordering); the generic kinds are cold.
+          else root_parent(node) # rubocop:disable Lint/DuplicateBranch
           end
         end
 
+        # The binding reports the root element as parentless; the
+        # moxml contract roots at the document.
+        def root_parent(node)
+          node.parent || (node.document&.root == node ? node.document : nil)
+        end
+
         def next_sibling(node)
           node.next_sibling if node.is_a?(::Leptris::XML::Node)
         end
@@ -766,13 +821,18 @@ module Moxml
         end
 
         def text_content(node)
+          # Frequency-ordered: elements dominate reads; they paid
+          # three failed compares to reach the else arm. The
+          # duplicated branch bodies are the point.
           case node
+          when ::Leptris::XML::Element, ::Leptris::XML::Text
+            node.content.to_s
           when ::Leptris::XML::Document then node.root ? node.root.content : ""
           when CustomizedLeptris::Declaration, CustomizedLeptris::Doctype,
                CustomizedLeptris::EntityReference
             ""
           when CustomizedLeptris::TextSegment then node.content
-          else node.content.to_s
+          else node.content.to_s # rubocop:disable Lint/DuplicateBranch
           end
         end
 

data/lib/moxml/adapter/nokogiri.rb

@@ -23,27 +23,26 @@ module Moxml
           true
         end
 
+        # Nokogiri has a real fragment node type — its children ARE
+        # the fragment's top-level nodes.
+        def parse_fragment(xml, _context = nil)
+          processed = Entity.preprocess_entities(xml)
+          ::Nokogiri::XML::DocumentFragment.parse(processed) do |config|
+            config.strict.nonet
+            config.recover
+          end.children.to_a
+        end
+
         # Fast bare-name read for Element#[]: the native call plus,
         # only when the parse recorded entity markers, their
         # restoration (the resolver path's other real semantic).
         # The marker flag is constant per document — a WeakMap on
         # the adapter beats the per-read document fetch + attachment
         # hash chain.
-        def doc_entity_markers?(doc)
-          cache = (@doc_markers ||= ObjectSpace::WeakMap.new)
-          cached = cache[doc]
-          return cached unless cached.nil?
-
-          cache[doc] = attachments.get(doc, :entity_markers) == true
-        end
-
+        # Raw qualified-name read; the entity-restore decision is
+        # the wrapper's (Element#[] rides its generation memo).
         def bare_attr_value(element, name)
-          value = element[name.to_s]
-          if value.is_a?(String) && doc_entity_markers?(element.document)
-            restore_entities(value)
-          else
-            value
-          end
+          element[name.to_s]
         end
 
         def native_identity_stable?
@@ -201,6 +200,14 @@ module Moxml
         end
 
         def set_namespace(element, ns)
+          # Strip any existing name prefix before binding: create_element
+          # with a qname ("p:c") leaves name="p:c", and Nokogiri's
+          # bare namespace= then serializes p: + p:c → p:p:c (issue
+          # #208). Local-name-only + namespace= is the correct shape;
+          # consumers that pass the qname get the same result.
+          if ns && element.respond_to?(:name=) && element.name.to_s.include?(":")
+            element.name = element.name.split(":", 2)[-1]
+          end
           element.namespace = ns
           element
         end

data/lib/moxml/adapter/oga.rb

@@ -172,10 +172,19 @@ module Moxml
         def set_namespace(element, ns_or_string)
           if ns_or_string.nil?
             element.namespace_name = nil
+            # Drop any name prefix so the element is truly unqualified
+            if element.respond_to?(:name=) && element.name.to_s.include?(":")
+              element.name = element.name.split(":", 2)[-1]
+            end
             set_attribute(element, "xmlns", "")
             return element
           end
 
+          # Local part only before binding — qname create + namespace=
+          # would otherwise serialize p:p:c (issue #208).
+          if element.respond_to?(:name=) && element.name.to_s.include?(":")
+            element.name = element.name.split(":", 2)[-1]
+          end
           element.namespace_name = ns_or_string.to_s
           element
         end
@@ -307,6 +316,11 @@ module Moxml
           current
         end
 
+        def parse_fragment(xml, _context = nil)
+          doc = parse("<m>#{xml}</m>").native
+          children(root(doc))
+        end
+
         def root(document)
           document.children.find { |node| node.is_a?(::Oga::XML::Element) }
         end

data/lib/moxml/adapter/ox.rb

@@ -94,8 +94,11 @@ module Moxml
           ::Ox::Element.new(name)
         end
 
+        # Ox stores the Ruby string object itself as the node value —
+        # without the copy, later caller mutations would write through
+        # into the document (ownership shield; see set_text_content).
         def create_native_text(content, _owner_doc = nil)
-          content
+          content.dup
         end
 
         def create_native_entity_reference(name)
@@ -164,13 +167,16 @@ module Moxml
           end
 
           prefix = ns.prefix
-          # attributes don't have attributes but can have a namespace prefix
-          if element.is_a?(::Ox::Element)
-            set_attribute(element, ns.expanded_prefix,
-                          ns.uri)
+          # Local part only — a qname create_element leaves
+          # "p:c" and re-joining would double the prefix (#208).
+          local = element.name.to_s.split(":", 2)[-1]
+          element.name = prefix.nil? || prefix.empty? ? local : "#{prefix}:#{local}"
+          # Declare only when the element is already in a tree and the
+          # prefix is not already bound — detached create+namespace=
+          # + attach under a declaring parent must not re-emit xmlns:p.
+          if element.is_a?(::Ox::Element) && element.parent
+            set_attribute(element, ns.expanded_prefix, ns.uri)
           end
-          element.name = [prefix,
-                          element.name.delete_prefix("xmlns:")].compact.join(":")
           element
         end
 
@@ -297,9 +303,13 @@ module Moxml
 
           result = node.nodes || []
           # Ox doesn't set parent references during parsing.
-          # Set them here so parent/sibling navigation works.
+          # Set them here so parent/sibling navigation works. The
+          # != node guard skips the write for already-linked (or
+          # stale-parented) children — steady-state access pays one
+          # comparison instead of a mutation per child.
           result.each do |child|
-            child.parent = node if child.is_a?(::Ox::Element)
+            child.parent = node if child.is_a?(::Ox::Element) &&
+              child.parent != node
           end
           result
         end
@@ -330,6 +340,12 @@ module Moxml
           current
         end
 
+        def parse_fragment(xml, _context = nil)
+          doc = parse("<m>#{xml}</m>").native
+          synthetic = doc.nodes.find { |node| node.is_a?(::Ox::Element) }
+          children(synthetic)
+        end
+
         def root(document)
           document.nodes&.find { |node| node.is_a?(::Ox::Element) }
         end
@@ -357,7 +373,14 @@ module Moxml
             # Ox converts all values to strings
             remove_attribute(element, name)
           else
-            element.attributes[name.to_s] = value
+            key = name.to_s
+            attrs = element.attributes
+            # Ox parses attributes under Symbol keys; a naive
+            # string-keyed write would ADD a second entry instead
+            # of replacing (the parity suite caught reads returning
+            # the stale symbol-keyed value after a write).
+            attrs.delete(key.to_sym)
+            attrs[key] = value
           end
 
           ::Moxml::Adapter::CustomizedOx::Attribute.new(
@@ -569,9 +592,11 @@ module Moxml
         end
 
         def set_text_content(node, content)
+          # Copy on the same ownership contract as create_native_text
+          content = content.to_s.dup
           case node
-          when String then node.replace(content.to_s)
-          when ::Ox::Element then node.replace_text(content.to_s)
+          when String then node.replace(content)
+          when ::Ox::Element then node.replace_text(content)
           else
             node.value = content.to_s
           end
@@ -602,7 +627,11 @@ module Moxml
         end
 
         def namespace_prefix(namespace)
-          namespace.prefix
+          # Ox spells the default namespace's prefix "xmlns"; the
+          # wrapper contract is nil there (parity with the other
+          # adapters' in-scope maps).
+          prefix = namespace.prefix
+          prefix == "xmlns" ? nil : prefix
         end
 
         def namespace_uri(namespace)

data/lib/moxml/adapter/rexml.rb

@@ -258,6 +258,11 @@ module Moxml
           node.document
         end
 
+        def parse_fragment(xml, _context = nil)
+          doc = parse("<m>#{xml}</m>").native
+          children(root(doc))
+        end
+
         def root(document)
           document.root
         end
@@ -509,7 +514,10 @@ module Moxml
           # Renames the node in place (works for elements and
           # attributes alike); the caller keeps tracking the same
           # native.
-          element.name = "#{prefix}:#{element.name}"
+          # Local part only — a qname create_element leaves "p:c"
+          # and prefixing it again would double (issue #208).
+          local = element.name.to_s.split(":", 2)[-1]
+          element.name = "#{prefix}:#{local}"
           element
         end