moxml 0.1.15 → 0.1.17

data/lib/moxml/adapter/headed_ox.rb

@@ -30,8 +30,9 @@ module Moxml
         # ~176K allocations per 100-element parse). Lazy parse defers wrapper
         # creation until nodes are accessed, matching Ox adapter behavior.
         def parse(xml, options = {}, _context = nil)
+          processed_xml = preprocess_entities(xml)
           native_doc = begin
-            result = ::Ox.parse(xml)
+            result = ::Ox.parse(processed_xml)
 
             # result can be either Document or Element
             if result.is_a?(::Ox::Document)
@@ -60,10 +61,10 @@ module Moxml
         #
         # This overrides the Ox adapter's xpath method which uses locate().
         #
-        # @param [Moxml::Node] node Starting node (wrapped Moxml node)
+        # @param node Starting node (native or wrapped)
         # @param [String] expression XPath expression
         # @param [Hash] namespaces Namespace prefix mappings
-        # @return [Moxml::NodeSet, Object] Query results
+        # @return [Array, Object] Native node array or scalar value
         def xpath(node, expression, namespaces = {})
           # If we receive a native node, wrap it first
           # Document#xpath passes @native, but our compiled XPath needs Moxml nodes
@@ -85,16 +86,33 @@ module Moxml
           # Execute on the node (now guaranteed to be wrapped Moxml node)
           result = proc.call(node)
 
-          # Wrap Array results in NodeSet, return other types directly
+          # Return native arrays for Node#xpath to wrap, scalars directly.
+          # The adapter contract: xpath() returns Array<native> | scalar.
           case result
           when Array
-            # Deduplicate by native object identity to handle descendant-or-self
-            # which may yield the same native node multiple times
-            nodeset = NodeSet.new(result, node.context)
-            nodeset.uniq_by_native
+            # XPath engine returns wrapped Moxml::Node objects.
+            # Extract native nodes and deduplicate by object identity.
+            native_nodes = result.map { |n| n.is_a?(Moxml::Node) ? n.native : n }
+            seen = {}
+            native_nodes.select do |native|
+              id = native.object_id
+              if seen[id]
+                false
+              else
+                seen[id] = true
+              end
+            end
           when NodeSet
-            # Deduplicate NodeSet results as well
-            result.uniq_by_native
+            # NodeSet from intermediate evaluation - extract natives and deduplicate
+            seen = {}
+            result.to_a.map(&:native).select do |native|
+              id = native.object_id
+              if seen[id]
+                false
+              else
+                seen[id] = true
+              end
+            end
           else
             # Scalar values (string, number, boolean) - return as-is
             result
@@ -113,10 +131,10 @@ module Moxml
         # @param [Moxml::Node] node Starting node
         # @param [String] expression XPath expression
         # @param [Hash] namespaces Namespace prefix mappings
-        # @return [Moxml::Node, Object, nil] First result or nil
+        # @return [Object, nil] First native node or scalar value
         def at_xpath(node, expression, namespaces = {})
           result = xpath(node, expression, namespaces)
-          result.is_a?(NodeSet) ? result.first : result
+          result.is_a?(Array) ? result.first : result
         end
 
         # Check if XPath is supported

data/lib/moxml/adapter/libxml.rb

@@ -38,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,6 +56,11 @@ module Moxml
                          xml.to_s
                        end
 
+          # Preprocess entities before parsing.
+          # This converts the string to UTF-8; LibXML will use the encoding
+          # parameter or XML declaration for byte interpretation.
+          xml_string = preprocess_entities(xml_string)
+
           # Extract DOCTYPE before parsing
           doctype_match = xml_string.match(/<!DOCTYPE\s+(\S+)(?:\s+PUBLIC\s+"([^"]+)"\s+"([^"]+)"|  \s+SYSTEM\s+"([^"]+)")?\s*>/i)
 
@@ -85,7 +94,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)
@@ -273,10 +282,8 @@ module Moxml
             result = []
 
             # Include DOCTYPE if present
-            if native_node.instance_variable_defined?(:@moxml_doctype)
-              doctype_wrapper = native_node.instance_variable_get(:@moxml_doctype)
-              result << doctype_wrapper if doctype_wrapper
-            end
+            doctype_wrapper = attachments.get(native_node, :doctype)
+            result << doctype_wrapper if doctype_wrapper
 
             return result unless native_node.root
 
@@ -284,18 +291,19 @@ 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 alongside native children
-          entity_refs = native_node.instance_variable_get(:@moxml_entity_refs)
+          # 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
@@ -499,11 +507,13 @@ module Moxml
           native_child = unpatch_node(child)
 
           # EntityReference wrappers can't go in LibXML's native tree.
-          # Store alongside native children via instance variable.
+          # 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)
-            refs = native_elem.instance_variable_get(:@moxml_entity_refs) || []
-            refs << child
-            native_elem.instance_variable_set(:@moxml_entity_refs, refs)
+            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
 
@@ -524,32 +534,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
 
@@ -557,13 +567,64 @@ 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)
@@ -577,9 +638,9 @@ module Moxml
           if sibling.is_a?(CustomizedLibxml::ProcessingInstruction) &&
               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
 
@@ -597,16 +658,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
 
@@ -795,9 +847,17 @@ module Moxml
           return [] unless native_node
           return [] unless native_node.is_a?(::LibXML::XML::Node)
 
-          native_node.namespaces.map do |ns|
-            ns
-          end
+          namespaces = native_node.namespaces
+          return [] unless namespaces
+
+          namespace_list =
+            if namespaces.respond_to?(:definitions)
+              namespaces.definitions
+            else
+              namespaces
+            end
+
+          namespace_list.to_a
         end
 
         # Doctype accessor methods
@@ -867,12 +927,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"
@@ -887,39 +945,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
 
@@ -1165,6 +1217,28 @@ 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)
@@ -1213,8 +1287,9 @@ module Moxml
             end
           end
 
-          # Append any EntityReference wrappers stored on this element
-          entity_refs = elem.instance_variable_get(:@moxml_entity_refs)
+          # 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}>"
@@ -1396,9 +1471,47 @@ 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?

data/lib/moxml/adapter/nokogiri.rb

@@ -7,19 +7,27 @@ module Moxml
   module Adapter
     class Nokogiri < Base
       class << self
+        def attachments
+          @attachments ||= Moxml::NativeAttachment.new
+        end
+
         def set_root(doc, element)
           doc.root = element
         end
 
         def parse(xml, options = {}, _context = nil)
+          processed_xml = preprocess_entities(xml)
+
+          # preprocess_entities always returns UTF-8, so tell Nokogiri to
+          # parse as UTF-8 regardless of any original encoding option.
           native_doc = begin
             if options[:fragment]
-              ::Nokogiri::XML::DocumentFragment.parse(xml) do |config|
+              ::Nokogiri::XML::DocumentFragment.parse(processed_xml) do |config|
                 config.strict.nonet
                 config.recover unless options[:strict]
               end
             else
-              ::Nokogiri::XML(xml, nil, options[:encoding]) do |config|
+              ::Nokogiri::XML(processed_xml, nil, "UTF-8") do |config|
                 config.strict.nonet
                 config.recover unless options[:strict]
               end
@@ -176,10 +184,16 @@ module Moxml
         def children(node)
           node.children.reject do |child|
             child.text? && child.content.strip.empty? &&
-              !(child.previous_sibling.nil? && child.next_sibling.nil?)
+              !(child.previous_sibling.nil? && child.next_sibling.nil?) &&
+              !adjacent_to_entity_reference?(child)
           end
         end
 
+        def adjacent_to_entity_reference?(node)
+          node.previous_sibling.is_a?(::Nokogiri::XML::EntityReference) ||
+            node.next_sibling.is_a?(::Nokogiri::XML::EntityReference)
+        end
+
         def replace_children(node, new_children)
           node.children.unlink
           new_children.each { |child| add_child(node, child) }
@@ -241,8 +255,8 @@ module Moxml
             encoding = declaration_attribute(child, "encoding")
             standalone = declaration_attribute(child, "standalone")
 
-            # Nokogiri's xml_decl can only be set via instance variable
-            element.instance_variable_set(:@xml_decl, {
+            # Store declaration state in attachment map
+            attachments.set(element, :xml_decl, {
               version: version,
               encoding: encoding,
               standalone: standalone,
@@ -273,7 +287,7 @@ module Moxml
               node.name == "xml" &&
               node.parent.is_a?(::Nokogiri::XML::Document)
             # Clear document's xml_decl when removing declaration
-            node.parent.instance_variable_set(:@xml_decl, nil)
+            attachments.set(node.parent, :xml_decl, nil)
           end
 
           node.remove
@@ -284,7 +298,7 @@ module Moxml
         end
 
         def text_content(node)
-          node.text
+          node.text.to_s
         end
 
         def inner_text(node)
@@ -387,12 +401,12 @@ module Moxml
           # Handle declaration option
           # Priority:
           # 1. Explicit no_declaration option
-          # 2. Check Nokogiri's internal @xml_decl (when remove is called, this becomes nil)
+          # 2. Check attachment-stored xml_decl (when remove is called, this becomes nil)
           if options.key?(:no_declaration)
             save_options |= ::Nokogiri::XML::Node::SaveOptions::NO_DECLARATION if options[:no_declaration]
-          elsif node.instance_variable_defined?(:@xml_decl)
-            # Nokogiri's internal state - if nil, declaration was removed
-            xml_decl = node.instance_variable_get(:@xml_decl)
+          elsif attachments.key?(node, :xml_decl)
+            # State stored in attachment - if nil, declaration was removed
+            xml_decl = attachments.get(node, :xml_decl)
             save_options |= ::Nokogiri::XML::Node::SaveOptions::NO_DECLARATION if xml_decl.nil?
           end
 
@@ -403,6 +417,14 @@ module Moxml
           )
         end
 
+        def has_declaration?(native_doc, wrapper)
+          if attachments.key?(native_doc, :xml_decl)
+            !attachments.get(native_doc, :xml_decl).nil?
+          else
+            wrapper.has_xml_declaration
+          end
+        end
+
         private
 
         def build_declaration_attrs(version, encoding, standalone)