moxml 0.5.33 → 0.5.34

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6fcb33efd8969194833ce7ee6b7e3e3bfa6517ec7d216028407d28fbc95b1641
-  data.tar.gz: ec2239b9b5501b208331ce5874764ad99cad357bacec08af6cc47d1f3aa69aff
+  metadata.gz: d43dcd89303022c12889585b26d38ab3bf199046d869b6412d45c6f3f9249347
+  data.tar.gz: e09d8585d90c5a2765040aaf4060bedaececca5228fe7808c11841088415d2e0
 SHA512:
-  metadata.gz: 18526fb6430f0231b187e888104c4f2fef7e38999d1015d8324ea53b90339de4c0d5d58cb4b591380b5d6cca704014fcb30ca5429f5abeff2a027217e1d47e54
-  data.tar.gz: 206cfe96f4bcac080a134092dac6f305d931d9d589c0dd544cf47e6bceb39d77d023f3b6e6c80deaeba94d10997840c90b583770d8c9d35e81dca65706354c0c
+  metadata.gz: ff23fcc8eaa05cefd83e236a387b707803d8fd06968e9bc84aefd450ff3f2eeca6445fe5a16e3ddd65bcf315b78e140bf27de3f45c30125a34eb6723cee26768
+  data.tar.gz: af7d2a75a27d30be26dc4daf750a77661235cf9c203b7e5c0638fde4fe58bed062499f4fa0b1f6648cb6aabc5b45768dfcfa101f095e1037143be67366ad8d94

data/lib/moxml/adapter/leptris.rb

@@ -456,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
@@ -626,18 +643,26 @@ module Moxml
         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

data/lib/moxml/adapter/nokogiri.rb

@@ -200,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

data/lib/moxml/adapter/ox.rb

@@ -167,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
 
@@ -300,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

data/lib/moxml/adapter/rexml.rb

@@ -514,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
 

data/lib/moxml/attribute.rb

@@ -77,6 +77,14 @@ module Moxml
       native_elem && Moxml::Node.wrap(native_elem, context)
     end
 
+    # The wrapper's parent tracking is authoritative for attributes
+    # (set at materialization by Element#attributes): the generic
+    # adapter read raises on engines whose Attr natives expose no
+    # #parent (leptris), and the tracked value needs no wrap.
+    def parent
+      @parent_node
+    end
+
     def remove
       # The name must be read before the removal — engines free the
       # attribute native, and post-removal reads are use-after-free.

data/lib/moxml/attribute_resolver.rb

@@ -106,7 +106,11 @@ module Moxml
     def assign(element, name, value)
       name = name.to_s
       adapter = element.adapter
-      if name == "xmlns" || name.start_with?("xmlns:")
+      # One probe covers both spellings ("xmlns" and "xmlns:*"); a
+      # plain attribute literally starting with "xmlns" would only
+      # over-invalidate (global bump instead of local) — a no-op
+      # for correctness.
+      if name.start_with?("xmlns")
         adapter.set_attribute(element.native, name, value)
         element.invalidate_attribute_cache!
         return value
@@ -144,7 +148,7 @@ module Moxml
     def remove(element, name)
       name = name.to_s
       adapter = element.adapter
-      if name == "xmlns" || name.start_with?("xmlns:")
+      if name.start_with?("xmlns")
         adapter.remove_attribute(element.native, name)
         element.invalidate_attribute_cache!
         return nil

data/lib/moxml/context.rb

@@ -24,6 +24,13 @@ module Moxml
       # up to the old 65,536 wholesale-clear valve which also
       # destroyed identity for live wrappers when it fired.
       @wrappers = WEAK_WRAPPERS ? ObjectSpace::WeakMap.new : {}.compare_by_identity
+      # Static per context (the registry flavor never changes).
+      @wrappers_strong = !WEAK_WRAPPERS
+      # Resolved on first registration — the adapter-resolution
+      # chain ran per mint and the decision never changes for a
+      # context's adapter (re-configuring an adapter mid-context is
+      # unsupported: minted wrappers already carry the old one).
+      @register_wrappers = nil
     end
 
     def wrapper_for(native)
@@ -31,15 +38,19 @@ module Moxml
     end
 
     def register_wrapper(native, wrapper)
-      # Adapter opt-in. Adapters whose natives are recreated per
-      # access (libxml mints fresh Ruby objects for the same C node)
-      # opt out so the map does not accumulate dead entries; the
-      # default is opt-in.
-      return if @config&.adapter&.wrappers_recyclable? == false
+      # Adapter opt-in, resolved once (see initialize): adapters
+      # whose natives are recreated per access (libxml mints fresh
+      # Ruby objects for the same C node) opt out so the map does
+      # not accumulate dead entries; the default is opt-in.
+      if @register_wrappers.nil?
+        @register_wrappers =
+          @config&.adapter&.wrappers_recyclable? != false
+      end
+      return unless @register_wrappers
 
       # The strong fallback (Opal) needs the wholesale-clear valve;
       # the WeakMap registry is self-cleaning.
-      @wrappers.clear if @wrappers.is_a?(Hash) && @wrappers.size >= 65_536
+      @wrappers.clear if @wrappers_strong && @wrappers.size >= 65_536
       @wrappers[native] = wrapper
     end
 

data/lib/moxml/element.rb

@@ -112,8 +112,11 @@ module Moxml
     end
 
     def attributes
+      # Primed like Node.wrap: the adapter and type are known at
+      # mint, so the first name/value/attribute? access skips the
+      # context hop and the adapter's type probe.
       @attributes ||= adapter.attributes(@native).map do |attr|
-        a = Attribute.new(attr, context)
+        a = Attribute.new(attr, context, adapter, :attribute)
         a.parent_node = self
         a
       end

data/lib/moxml/version.rb

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

data/spec/integration/contract_parity_spec.rb

@@ -63,6 +63,19 @@
       end
     end
 
+    describe "qname create + namespace assignment (issue #208)" do
+      it "does not double the prefix when the name is already qualified" do
+        doc = ctx.parse(%(<r xmlns:p="urn:p"/>))
+        el = doc.create_element("p:c")
+        ns = doc.root.in_scope_namespaces.find { |n| n.prefix == "p" }
+        el.namespace = ns
+        doc.root.add_child(el)
+        out = doc.to_xml
+        expect(out).to include("p:c")
+        expect(out).not_to include("p:p:c")
+      end
+    end
+
     describe "namespaces contract (issue #198 comment)" do
       it "returns the in-scope map including ancestor declarations" do
         doc = ctx.parse(%(<root xmlns:p="urn:p" xmlns="urn:d"><p:c plain="1"/></root>))

metadata

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