moxml 0.1.14 → 0.1.16

data/lib/moxml/adapter/libxml.rb

@@ -2,13 +2,7 @@
 
 require_relative "base"
 require "libxml"
-require_relative "customized_libxml/node"
-require_relative "customized_libxml/element"
-require_relative "customized_libxml/text"
-require_relative "customized_libxml/comment"
-require_relative "customized_libxml/cdata"
-require_relative "customized_libxml/processing_instruction"
-require_relative "customized_libxml/declaration"
+require_relative "customized_libxml"
 
 module Moxml
   module Adapter
@@ -44,6 +38,10 @@ module Moxml
       end
 
       class << self
+        def attachments
+          @attachments ||= Moxml::NativeAttachment.new
+        end
+
         def set_root(doc, element)
           doc.root = element
         end
@@ -52,7 +50,7 @@ module Moxml
           # LibXML doesn't preserve DOCTYPE during parsing, so we need to extract it manually
           xml_string = if xml.is_a?(String)
                          xml
-                       elsif xml.respond_to?(:read)
+                       elsif xml.is_a?(IO) || xml.is_a?(StringIO)
                          xml.read
                        else
                          xml.to_s
@@ -67,7 +65,7 @@ module Moxml
             parser.parse
           rescue ::LibXML::XML::Error => e
             if options[:strict]
-              line = e.respond_to?(:line) ? e.line : nil
+              line = e.line
               raise Moxml::ParseError.new(
                 e.message,
                 line: line,
@@ -91,7 +89,7 @@ module Moxml
               external_id,
               system_id,
             )
-            native_doc.instance_variable_set(:@moxml_doctype, doctype_wrapper)
+            attachments.set(native_doc, :doctype, doctype_wrapper)
           end
 
           ctx = _context || Context.new(:libxml)
@@ -116,8 +114,12 @@ module Moxml
           # Parse
           parser.parse
         rescue ::LibXML::XML::Error => e
-          line = e.respond_to?(:line) ? e.line : nil
-          column = e.respond_to?(:column) ? e.column : nil
+          line = e.line
+          column = begin
+            e.column
+          rescue StandardError
+            nil
+          end
           error = Moxml::ParseError.new(e.message, line: line, column: column)
           handler.on_error(error)
         end
@@ -135,6 +137,14 @@ module Moxml
           CustomizedLibxml::Text.new(native)
         end
 
+        def create_native_entity_reference(name)
+          CustomizedLibxml::EntityReference.new(name)
+        end
+
+        def entity_reference_name(node)
+          node.name if node.is_a?(CustomizedLibxml::EntityReference)
+        end
+
         def create_native_cdata(content, _owner_doc = nil)
           native = ::LibXML::XML::Node.new_cdata(content.to_s)
           CustomizedLibxml::Cdata.new(native)
@@ -174,10 +184,11 @@ module Moxml
           if node.is_a?(CustomizedLibxml::ProcessingInstruction)
             return :processing_instruction
           end
+          return :entity_reference if node.is_a?(CustomizedLibxml::EntityReference)
           return :doctype if node.is_a?(DoctypeWrapper)
 
           # Unwrap if needed
-          native_node = node.respond_to?(:native) ? node.native : node
+          native_node = unpatch_node(node)
 
           case native_node.node_type
           when ::LibXML::XML::Node::DOCUMENT_NODE
@@ -266,22 +277,8 @@ module Moxml
             result = []
 
             # Include DOCTYPE if present
-            # First check if we stored it as instance variable (from parse)
-            if native_node.instance_variable_defined?(:@moxml_doctype)
-              doctype_wrapper = native_node.instance_variable_get(:@moxml_doctype)
-              result << doctype_wrapper if doctype_wrapper
-            elsif native_node.respond_to?(:dtd) && native_node.dtd
-              # Otherwise check dtd property directly
-              dtd = native_node.dtd
-              # Wrap in DoctypeWrapper for consistency
-              doctype_wrapper = DoctypeWrapper.new(
-                native_node,
-                dtd.name,
-                dtd.external_id,
-                dtd.system_id,
-              )
-              result << doctype_wrapper
-            end
+            doctype_wrapper = attachments.get(native_node, :doctype)
+            result << doctype_wrapper if doctype_wrapper
 
             return result unless native_node.root
 
@@ -289,15 +286,21 @@ module Moxml
             return result
           end
 
-          return [] unless native_node.children?
-
           result = []
-          native_node.each_child do |child|
-            # Skip whitespace-only text nodes
-            next if child.text? && child.content.to_s.strip.empty?
+          if native_node.children?
+            native_node.each_child do |child|
+              # Skip whitespace-only text nodes
+              next if child.text? && child.content.to_s.strip.empty?
 
-            result << patch_node(child)
+              result << patch_node(child)
+            end
           end
+
+          # Include any EntityReference wrappers stored on the document
+          doc = native_node.doc
+          entity_refs = doc ? lookup_entity_refs(doc, native_node) : nil
+          result.concat(entity_refs) if entity_refs
+
           result
         end
 
@@ -350,7 +353,7 @@ module Moxml
         def attributes(element)
           native_elem = unpatch_node(element)
           return [] unless native_elem
-          unless native_elem.respond_to?(:element?) && native_elem.element?
+          unless native_elem.is_a?(::LibXML::XML::Node) && native_elem.element?
             return []
           end
           return [] unless native_elem.attributes?
@@ -368,7 +371,7 @@ module Moxml
 
         def attribute_namespace(attr)
           return nil unless attr
-          return nil unless attr.respond_to?(:ns)
+          return nil unless attr.is_a?(::LibXML::XML::Attr)
 
           attr.ns
         end
@@ -498,11 +501,22 @@ module Moxml
           native_elem = unpatch_node(element)
           native_child = unpatch_node(child)
 
+          # EntityReference wrappers can't go in LibXML's native tree.
+          # Store on the document (stable identity) keyed by element.
+          # LibXML creates new Ruby wrappers on each access, so element
+          # object_id is unstable — we look up via == comparison.
+          if child.is_a?(CustomizedLibxml::EntityReference)
+            doc = native_elem.is_a?(::LibXML::XML::Document) ? native_elem : native_elem.doc
+            store_entity_ref_on_doc(doc, native_elem, child)
+            append_child_sequence_on_doc(doc, native_elem, :eref)
+            return
+          end
+
           # For LibXML: if parent has a DEFAULT namespace (nil/empty prefix) and child is an element without a namespace,
           # explicitly set the child's namespace to match the parent's for XPath compatibility
           # NOTE: Prefixed namespaces are NOT inherited, only default namespaces
-          if native_elem.respond_to?(:namespaces) && native_elem.namespaces&.namespace &&
-              native_child.respond_to?(:namespaces) && native_child.element? &&
+          if native_elem.is_a?(::LibXML::XML::Node) && native_elem.namespaces&.namespace &&
+              native_child.is_a?(::LibXML::XML::Node) && native_child.element? &&
               (!native_child.namespaces.namespace || native_child.namespaces.namespace.href.to_s.empty?)
 
             parent_ns = native_elem.namespaces.namespace
@@ -515,32 +529,32 @@ module Moxml
           if native_elem.is_a?(::LibXML::XML::Document)
             # For Declaration wrappers, store them for serialization
             if child.is_a?(CustomizedLibxml::Declaration)
-              native_elem.instance_variable_set(:@moxml_declaration, child)
+              attachments.set(native_elem, :declaration, child)
               # Also store reference to parent document in the declaration
-              child.instance_variable_set(:@parent_doc, native_elem)
+              child.parent_doc = native_elem
               return
             end
 
             # For DOCTYPE wrappers, store them for serialization
             if child.is_a?(DoctypeWrapper)
-              native_elem.instance_variable_set(:@moxml_doctype, child)
+              attachments.set(native_elem, :doctype, child)
               return
             end
 
             # For document-level PIs, store them for serialization
             if child.is_a?(CustomizedLibxml::ProcessingInstruction)
-              pis = native_elem.instance_variable_get(:@moxml_pis) || []
+              pis = attachments.get(native_elem, :pis) || []
               pis << child
-              native_elem.instance_variable_set(:@moxml_pis, pis)
+              attachments.set(native_elem, :pis, pis)
               return
             end
 
             # For text nodes added to document, store them for serialization
             # Documents can't have text children in LibXML
             if child.is_a?(CustomizedLibxml::Text)
-              texts = native_elem.instance_variable_get(:@moxml_texts) || []
+              texts = attachments.get(native_elem, :texts) || []
               texts << child
-              native_elem.instance_variable_set(:@moxml_texts, texts)
+              attachments.set(native_elem, :texts, texts)
               return
             end
 
@@ -548,15 +562,66 @@ module Moxml
             if native_elem.root.nil? && node_type(native_child) == :element
               # Set as root element
               native_elem.root = native_child
+              # Flag for actual_native to refresh the wrapper's native reference
+              attachments.set(native_elem, :_pending_root_refresh, native_child.object_id)
             elsif native_elem.root
               # Document has root, add to it instead
               import_and_add(native_elem.doc, native_elem.root, native_child)
             end
           else
             import_and_add(native_elem.doc, native_elem, native_child)
+            doc = native_elem.doc || native_elem
+            append_child_sequence_on_doc(doc, native_elem, :native)
           end
         end
 
+        # Store entity ref on the document (stable identity).
+        # LibXML element wrappers are ephemeral, so we use == to find matching elements.
+        def store_entity_ref_on_doc(doc, element, ref)
+          pairs = attachments.get(doc, :_entity_ref_pairs) || []
+          pair = pairs.find { |elem, _| elem == element }
+          if pair
+            pair[1] << ref
+          else
+            pairs << [element, [ref]]
+          end
+          attachments.set(doc, :_entity_ref_pairs, pairs)
+        end
+
+        # Look up entity refs for an element from the document
+        def lookup_entity_refs(doc, element)
+          pairs = attachments.get(doc, :_entity_ref_pairs)
+          return nil unless pairs
+          pair = pairs.find { |elem, _| elem == element }
+          pair&.last
+        end
+
+        # Track child order on the document (stable identity)
+        def append_child_sequence_on_doc(doc, element, type)
+          pairs = attachments.get(doc, :_child_seq_pairs) || []
+          pair = pairs.find { |elem, _| elem == element }
+          if pair
+            pair[1] << type
+          else
+            pairs << [element, [type]]
+          end
+          attachments.set(doc, :_child_seq_pairs, pairs)
+        end
+
+        # Look up child sequence for an element from the document
+        def lookup_child_sequence(doc, element)
+          pairs = attachments.get(doc, :_child_seq_pairs)
+          return nil unless pairs
+          pair = pairs.find { |elem, _| elem == element }
+          pair&.last
+        end
+
+        def append_child_sequence(element, type)
+          seq = attachments.get(element, :child_sequence) || []
+          seq << type
+          attachments.set(element, :child_sequence, seq)
+        end
+
         def add_previous_sibling(node, sibling)
           return unless node && sibling
 
@@ -566,11 +631,11 @@ module Moxml
           # Special handling for document-level processing instructions
           # When adding a PI as sibling to root element, store it on document
           if sibling.is_a?(CustomizedLibxml::ProcessingInstruction) &&
-              native_node.respond_to?(:doc) && native_node.doc
+              native_node.is_a?(::LibXML::XML::Node) && native_node.doc
             doc = native_node.doc
-            pis = doc.instance_variable_get(:@moxml_pis) || []
+            pis = attachments.get(doc, :pis) || []
             pis << sibling
-            doc.instance_variable_set(:@moxml_pis, pis)
+            attachments.set(doc, :pis, pis)
             return
           end
 
@@ -588,16 +653,7 @@ module Moxml
         def remove(node)
           # Handle Declaration wrapper - mark as removed on document
           if node.is_a?(CustomizedLibxml::Declaration)
-            # The Declaration wrapper is stored on the actual document
-            # We need to find which document it's stored on and mark it as removed
-            # This is a bit tricky since the Declaration's native is its own internal doc
-            # We rely on the fact that when a declaration is added to a document,
-            # the document stores a reference to it in @moxml_declaration
-            # So we need to clear that reference and mark it as removed
-
-            # Since we can't easily find the parent document from the Declaration,
-            # we'll set a flag on the Declaration itself
-            node.instance_variable_set(:@removed, true)
+            node.removed = true
             return
           end
 
@@ -624,7 +680,7 @@ module Moxml
           next_sibling = native_node.next
 
           # Import if needed for cross-document operations
-          parent_doc = parent.respond_to?(:doc) ? parent.doc : nil
+          parent_doc = parent.is_a?(::LibXML::XML::Node) ? parent.doc : nil
 
           # Use import_and_add to properly handle document adoption
           import_and_add(parent_doc, parent, native_new)
@@ -651,7 +707,7 @@ module Moxml
           native_elem.each_child(&:remove!)
 
           # Get the element's document for importing
-          doc = native_elem.respond_to?(:doc) ? native_elem.doc : nil
+          doc = native_elem.is_a?(::LibXML::XML::Node) ? native_elem.doc : nil
 
           children.each do |c|
             native_c = unpatch_node(c)
@@ -662,6 +718,8 @@ module Moxml
         end
 
         def text_content(node)
+          return "" if node.is_a?(CustomizedLibxml::EntityReference)
+
           native_node = unpatch_node(node)
           return nil unless native_node
 
@@ -782,7 +840,7 @@ module Moxml
         def namespace_definitions(node)
           native_node = unpatch_node(node)
           return [] unless native_node
-          return [] unless native_node.respond_to?(:namespaces)
+          return [] unless native_node.is_a?(::LibXML::XML::Node)
 
           native_node.namespaces.map do |ns|
             ns
@@ -835,15 +893,8 @@ module Moxml
 
         def serialize(node, options = {})
           # FIRST: Check if node is any kind of wrapper with custom to_xml
-          if node.respond_to?(:to_xml)
-            # Declaration wrapper
-            return node.to_xml if node.is_a?(CustomizedLibxml::Declaration)
-
-            # Other wrappers - check they're not native LibXML nodes
-            unless node.is_a?(::LibXML::XML::Node) ||
-                node.is_a?(::LibXML::XML::Document)
-              return node.to_xml
-            end
+          if node.is_a?(CustomizedLibxml::Node) || node.is_a?(DoctypeWrapper)
+            return node.to_xml
           end
 
           native_node = unpatch_node(node)
@@ -863,12 +914,10 @@ module Moxml
 
             if should_include_decl
               # Check if declaration was explicitly managed
-              if native_node.instance_variable_defined?(:@moxml_declaration)
-                decl = native_node.instance_variable_get(:@moxml_declaration)
+              decl = attachments.get(native_node, :declaration)
+              if decl
                 # Only output declaration if it exists and wasn't removed
-                if decl && !decl.instance_variable_get(:@removed)
-                  output << decl.to_xml
-                end
+                output << decl.to_xml unless decl.removed
               else
                 # No declaration stored - create default
                 version = native_node.version || "1.0"
@@ -883,39 +932,33 @@ module Moxml
                   encoding_val,
                   nil, # No standalone by default
                 )
-                native_node.instance_variable_set(:@moxml_declaration, decl)
+                attachments.set(native_node, :declaration, decl)
                 output << decl.to_xml
               end
             end
 
             # Add DOCTYPE if stored on document
-            if native_node.instance_variable_defined?(:@moxml_doctype)
-              doctype_wrapper = native_node.instance_variable_get(:@moxml_doctype)
-              if doctype_wrapper
-                output << "\n" unless output.empty?
-                output << doctype_wrapper.to_xml
-              end
+            doctype_wrapper = attachments.get(native_node, :doctype)
+            if doctype_wrapper
+              output << "\n" unless output.empty?
+              output << doctype_wrapper.to_xml
             end
 
             # Add document-level processing instructions if stored
-            if native_node.instance_variable_defined?(:@moxml_pis)
-              pis = native_node.instance_variable_get(:@moxml_pis)
-              if pis && !pis.empty?
-                pis.each do |pi|
-                  output << "\n" unless output.empty?
-                  output << pi.to_xml
-                end
+            pis = attachments.get(native_node, :pis)
+            if pis && !pis.empty?
+              pis.each do |pi|
+                output << "\n" unless output.empty?
+                output << pi.to_xml
               end
             end
 
             # Add text nodes if stored (for documents without root)
-            if native_node.instance_variable_defined?(:@moxml_texts)
-              texts = native_node.instance_variable_get(:@moxml_texts)
-              if texts && !texts.empty?
-                texts.each do |text|
-                  output << "\n" unless output.empty?
-                  output << text.to_xml
-                end
+            texts = attachments.get(native_node, :texts)
+            if texts && !texts.empty?
+              texts.each do |text|
+                output << "\n" unless output.empty?
+                output << text.to_xml
               end
             end
 
@@ -1033,7 +1076,7 @@ module Moxml
           return nil unless node
 
           # Unwrap if wrapped
-          native_node = node.respond_to?(:native) ? node.native : node
+          native_node = unpatch_node(node)
 
           # LibXML is strict about document ownership
           # Create brand new NATIVE nodes that are document-independent
@@ -1057,7 +1100,7 @@ module Moxml
             # new_node.line = node.line
 
             # Copy and set namespace definitions FIRST
-            if native_node.respond_to?(:namespaces)
+            if native_node.is_a?(::LibXML::XML::Node)
               # First, copy all namespace definitions
               native_node.namespaces.each do |ns|
                 ::LibXML::XML::Namespace.new(
@@ -1144,7 +1187,12 @@ module Moxml
 
         def unpatch_node(node)
           # Unwrap to get native LibXML node
-          node.respond_to?(:native) ? node.native : node
+          case node
+          when CustomizedLibxml::Node, CustomizedLibxml::Declaration, DoctypeWrapper
+            node.native
+          else
+            node
+          end
         end
 
         def prepare_for_new_document(node, target_doc)
@@ -1156,13 +1204,35 @@ module Moxml
           duplicate_node(node)
         end
 
+        def has_declaration?(native_doc, wrapper)
+          decl = attachments.get(native_doc, :declaration)
+          if decl
+            !decl.removed
+          else
+            wrapper.has_xml_declaration
+          end
+        end
+
+        # LibXML's doc.root= creates a new Ruby wrapper with different object_id.
+        # Return the actual root node so attachments are stored on the correct object.
+        def actual_native(child_native, parent_native)
+          if parent_native.is_a?(::LibXML::XML::Document)
+            pending = attachments.get(parent_native, :_pending_root_refresh)
+            if pending && pending == child_native.object_id
+              attachments.delete(parent_native, :_pending_root_refresh)
+              return parent_native.root
+            end
+          end
+          child_native
+        end
+
         private
 
         def serialize_element(elem)
           output = "<#{elem.name}"
 
           # Add namespace definitions (only on this element, not ancestors)
-          if elem.respond_to?(:namespaces)
+          if elem.is_a?(::LibXML::XML::Node)
             seen_ns = {}
             elem.namespaces.each do |ns|
               prefix = ns.prefix
@@ -1203,6 +1273,12 @@ module Moxml
               output << serialize_node(child)
             end
           end
+
+          # Append any EntityReference wrappers stored on the document
+          doc = elem.doc
+          entity_refs = doc ? lookup_entity_refs(doc, elem) : nil
+          entity_refs&.each { |ref| output << ref.to_xml }
+
           output << "</#{elem.name}>"
 
           output
@@ -1210,11 +1286,12 @@ module Moxml
 
         def serialize_node(node)
           # Check if node is a wrapper with to_xml method
-          if node.respond_to?(:to_xml) &&
-              (node.is_a?(CustomizedLibxml::ProcessingInstruction) ||
-               node.is_a?(CustomizedLibxml::Comment) ||
-               node.is_a?(CustomizedLibxml::Cdata) ||
-               node.is_a?(CustomizedLibxml::Text))
+          case node
+          when CustomizedLibxml::ProcessingInstruction,
+               CustomizedLibxml::Comment,
+               CustomizedLibxml::Cdata,
+               CustomizedLibxml::Text,
+               CustomizedLibxml::EntityReference
             return node.to_xml
           end
 
@@ -1269,7 +1346,7 @@ module Moxml
             raise unless e.message.include?("different documents")
 
             # Get the target document - either from parameter or element
-            target_doc = doc || (element.respond_to?(:doc) ? element.doc : nil)
+            target_doc = doc || (element.is_a?(::LibXML::XML::Node) ? element.doc : nil)
 
             if target_doc
               # Use deep import to ensure all descendants are included
@@ -1329,11 +1406,11 @@ module Moxml
           # Include namespace definitions:
           # - On root element (include_ns = true), output ALL namespace definitions
           # - On child elements, output namespace definitions that override parent namespaces
-          if elem.respond_to?(:namespaces) && elem.namespaces.respond_to?(:definitions)
+          if elem.is_a?(::LibXML::XML::Node) && elem.namespaces.respond_to?(:definitions)
             # Get parent's namespace definitions to detect overrides
-            parent_ns_defs = if !include_ns && elem.respond_to?(:parent) && elem.parent && !elem.parent.is_a?(::LibXML::XML::Document)
+            parent_ns_defs = if !include_ns && elem.parent && !elem.parent.is_a?(::LibXML::XML::Document)
                                parent_namespaces = {}
-                               if elem.parent.respond_to?(:namespaces)
+                               if elem.parent.is_a?(::LibXML::XML::Node)
                                  elem.parent.namespaces.each do |ns|
                                    parent_namespaces[ns.prefix] = ns.href
                                  end
@@ -1381,17 +1458,54 @@ module Moxml
             end
           end
 
+          # Check for entity refs stored on the document
+          # LibXML element wrappers are ephemeral, so look up via == comparison
+          doc = elem.doc
+          entity_refs = doc ? lookup_entity_refs(doc, elem) : nil
+          child_sequence = doc ? lookup_child_sequence(doc, elem) : nil
+
           # Always use verbose format <tag></tag> for consistency with other adapters
           output << ">"
-          if elem.children?
+
+          if entity_refs && !entity_refs.empty? && child_sequence
+            # Interleave native children with entity refs using tracked sequence
+            native_children = []
+            if elem.children?
+              elem.each_child { |c| native_children << c unless c.text? && c.content.to_s.strip.empty? }
+            end
+
+            eref_idx = 0
+            native_idx = 0
+            child_sequence.each do |type|
+              case type
+              when :native
+                if native_idx < native_children.size
+                  child = native_children[native_idx]
+                  native_idx += 1
+                  wrapped_child = patch_node(child)
+                  output << if wrapped_child.is_a?(CustomizedLibxml::Node) && !wrapped_child.is_a?(CustomizedLibxml::Element)
+                              wrapped_child.to_xml
+                            elsif child.element?
+                              serialize_element_with_namespaces(child, false)
+                            else
+                              serialize_node(child)
+                            end
+                end
+              when :eref
+                if eref_idx < entity_refs.size
+                  output << entity_refs[eref_idx].to_xml
+                  eref_idx += 1
+                end
+              end
+            end
+          elsif elem.children?
             elem.each_child do |child|
               # Skip whitespace-only text nodes
               next if child.text? && child.content.to_s.strip.empty?
 
               # Wrap the child and serialize
               wrapped_child = patch_node(child)
-              output << if wrapped_child.respond_to?(:to_xml) &&
-                  !wrapped_child.is_a?(::LibXML::XML::Node)
+              output << if wrapped_child.is_a?(CustomizedLibxml::Node) && !wrapped_child.is_a?(CustomizedLibxml::Element)
                           # Use wrapper's to_xml for proper serialization
                           wrapped_child.to_xml
                         elsif child.element?
@@ -1421,7 +1535,7 @@ module Moxml
                  else
                    # Walk up to root first
                    current = node
-                   current = current.parent while current.respond_to?(:parent) && current.parent && !current.parent.is_a?(::LibXML::XML::Document)
+                   current = current.parent while current.is_a?(::LibXML::XML::Node) && current.parent && !current.parent.is_a?(::LibXML::XML::Document)
                    current
                  end
 
@@ -1435,7 +1549,7 @@ module Moxml
 
         def collect_ns_from_subtree(node, ns_defs)
           # Collect namespaces defined on this node
-          if node.respond_to?(:namespaces)
+          if node.is_a?(::LibXML::XML::Node)
             node.namespaces.each do |ns|
               prefix = ns.prefix
               uri = ns.href
@@ -1453,7 +1567,7 @@ module Moxml
 
           # Also check if this element has an active namespace (inherited or own)
           # This catches cases where elements inherit namespaces from parents
-          if node.respond_to?(:namespaces) && node.namespaces.respond_to?(:namespace)
+          if node.is_a?(::LibXML::XML::Node) && node.namespaces.respond_to?(:namespace)
             active_ns = node.namespaces.namespace
             if active_ns
               prefix = active_ns.prefix
@@ -1469,7 +1583,7 @@ module Moxml
           end
 
           # Recursively collect from children
-          return unless node.respond_to?(:children?) && node.children?
+          return unless node.is_a?(::LibXML::XML::Node) && node.children?
 
           node.each_child do |child|
             collect_ns_from_subtree(child, ns_defs) if child.element?
@@ -1493,12 +1607,12 @@ module Moxml
           # Search element and ancestors for namespace with given prefix
           current = element
           while current
-            if current.respond_to?(:namespaces)
+            if current.is_a?(::LibXML::XML::Node)
               current.namespaces.each do |ns|
                 return ns if ns.prefix == prefix
               end
             end
-            current = current.respond_to?(:parent) ? current.parent : nil
+            current = current.is_a?(::LibXML::XML::Node) ? current.parent : nil
           end
           nil
         end