moxml 0.1.13 → 0.1.15

data/lib/moxml/adapter/customized_rexml/entity_reference.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Moxml
+  module Adapter
+    module CustomizedRexml
+      class EntityReference
+        attr_reader :name
+
+        def initialize(name)
+          @name = name
+        end
+
+        def ==(other)
+          other.is_a?(self.class) && @name == other.name
+        end
+      end
+    end
+  end
+end

data/lib/moxml/adapter/customized_rexml/formatter.rb

@@ -19,6 +19,8 @@ module Moxml
           case node
           when ::REXML::XMLDecl
             write_declaration(node, output)
+          when ::Moxml::Adapter::CustomizedRexml::EntityReference
+            output << "&#{node.name};"
           else
             super
           end

data/lib/moxml/adapter/customized_rexml.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Moxml
+  module Adapter
+    module CustomizedRexml
+      autoload :EntityReference,
+               "moxml/adapter/customized_rexml/entity_reference"
+      autoload :Formatter, "moxml/adapter/customized_rexml/formatter"
+    end
+  end
+end

data/lib/moxml/adapter/headed_ox.rb

@@ -25,17 +25,23 @@ module Moxml
     #
     class HeadedOx < Ox
       class << self
-        # Override parse to use HeadedOx context instead of Ox context
-        def parse(xml, _options = {}, _context = nil)
+        # Override parse to use lazy wrapping like the Ox adapter.
+        # Previously used DocumentBuilder (eager tree construction causing
+        # ~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)
           native_doc = begin
             result = ::Ox.parse(xml)
 
             # result can be either Document or Element
             if result.is_a?(::Ox::Document)
+              assign_parents(result)
+              validate_single_root(result) if options[:strict]
               result
             else
               doc = ::Ox::Document.new
               doc << result
+              assign_parents(doc)
               doc
             end
           rescue ::Ox::ParseError => e
@@ -47,7 +53,7 @@ module Moxml
 
           # Use provided context if available, otherwise create new one
           ctx = _context || Context.new(:headed_ox)
-          DocumentBuilder.new(ctx).build(native_doc)
+          Document.new(native_doc, ctx)
         end
 
         # Execute XPath query using Moxml's XPath engine

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
@@ -52,7 +46,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 +61,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,
@@ -116,8 +110,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 +133,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 +180,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,21 +273,9 @@ 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
 
             return result unless native_node.root
@@ -298,6 +293,11 @@ module Moxml
 
             result << patch_node(child)
           end
+
+          # Include any EntityReference wrappers stored alongside native children
+          entity_refs = native_node.instance_variable_get(:@moxml_entity_refs)
+          result.concat(entity_refs) if entity_refs
+
           result
         end
 
@@ -350,7 +350,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 +368,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 +498,20 @@ module Moxml
           native_elem = unpatch_node(element)
           native_child = unpatch_node(child)
 
+          # EntityReference wrappers can't go in LibXML's native tree.
+          # Store alongside native children via instance variable.
+          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)
+            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
@@ -566,7 +575,7 @@ 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 << sibling
@@ -624,7 +633,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 +660,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 +671,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 +793,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 +846,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)
@@ -1033,7 +1037,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 +1061,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 +1148,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)
@@ -1162,7 +1171,7 @@ module Moxml
           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 +1212,11 @@ module Moxml
               output << serialize_node(child)
             end
           end
+
+          # Append any EntityReference wrappers stored on this element
+          entity_refs = elem.instance_variable_get(:@moxml_entity_refs)
+          entity_refs&.each { |ref| output << ref.to_xml }
+
           output << "</#{elem.name}>"
 
           output
@@ -1210,11 +1224,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 +1284,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 +1344,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
@@ -1390,8 +1405,7 @@ module Moxml
 
               # 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 +1435,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 +1449,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 +1467,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 +1483,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 +1507,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

data/lib/moxml/adapter/nokogiri.rb

@@ -31,7 +31,7 @@ module Moxml
 
           # Use provided context if available, otherwise create new one
           ctx = _context || Context.new(:nokogiri)
-          DocumentBuilder.new(ctx).build(native_doc)
+          Document.new(native_doc, ctx)
         end
 
         # SAX parsing implementation for Nokogiri
@@ -47,7 +47,7 @@ module Moxml
           parser = ::Nokogiri::XML::SAX::Parser.new(bridge)
 
           # Parse
-          if xml.respond_to?(:read)
+          if xml.is_a?(IO) || xml.is_a?(StringIO)
             parser.parse(xml)
           else
             parser.parse(xml.to_s)
@@ -202,7 +202,7 @@ module Moxml
         end
 
         def root(document)
-          document.respond_to?(:root) ? document.root : document.children.first
+          document.is_a?(::Nokogiri::XML::Document) ? document.root : document.children.first
         end
 
         def attribute_element(attr)
@@ -390,8 +390,7 @@ module Moxml
           # 2. Check Nokogiri's internal @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.respond_to?(:instance_variable_get) &&
-              node.instance_variable_defined?(:@xml_decl)
+          elsif node.instance_variable_defined?(:@xml_decl)
             # Nokogiri's internal state - if nil, declaration was removed
             xml_decl = node.instance_variable_get(:@xml_decl)
             save_options |= ::Nokogiri::XML::Node::SaveOptions::NO_DECLARATION if xml_decl.nil?

data/lib/moxml/adapter/oga.rb

@@ -1,8 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "base"
-require_relative "customized_oga/xml_generator"
-require_relative "customized_oga/xml_declaration"
+require_relative "customized_oga"
 require "oga"
 
 module Moxml
@@ -46,7 +45,7 @@ module Moxml
         def sax_parse(xml, handler)
           bridge = OgaSAXBridge.new(handler)
 
-          xml_string = xml.respond_to?(:read) ? xml.read : xml.to_s
+          xml_string = xml.is_a?(IO) || xml.is_a?(StringIO) ? xml.read : xml.to_s
 
           # Manually call start_document (Oga doesn't)
           handler.on_start_document
@@ -72,6 +71,17 @@ module Moxml
           ::Oga::XML::Text.new(text: encode_entity_markers(content))
         end
 
+        def create_native_entity_reference(name)
+          text = ::Oga::XML::Text.new
+          text.text = "#{ENTITY_MARKER}#{name};"
+          text.instance_variable_set(:@moxml_entity_name, name)
+          text
+        end
+
+        def entity_reference_name(node)
+          node.instance_variable_get(:@moxml_entity_name)
+        end
+
         def create_native_cdata(content, _owner_doc = nil)
           ::Oga::XML::Cdata.new(text: content)
         end
@@ -132,10 +142,9 @@ module Moxml
         end
 
         def namespace(element)
-          if element.respond_to?(:namespace)
+          case element
+          when ::Oga::XML::Element, ::Oga::XML::Attribute
             element.namespace
-          elsif element.respond_to?(:namespaces)
-            element.namespaces.values.last
           end
         rescue NoMethodError
           # Oga attributes fail with NoMethodError:
@@ -150,7 +159,12 @@ module Moxml
         def node_type(node)
           case node
           when ::Oga::XML::Element then :element
-          when ::Oga::XML::Text then :text
+          when ::Oga::XML::Text
+            if node.instance_variable_get(:@moxml_entity_name)
+              :entity_reference
+            else
+              :text
+            end
           when ::Oga::XML::Cdata then :cdata
           when ::Oga::XML::Comment then :comment
           when ::Oga::XML::Attribute then :attribute
@@ -178,7 +192,7 @@ module Moxml
                              node.doctype].compact
           end
 
-          return all_children unless node.respond_to?(:children)
+          return all_children unless node.is_a?(::Oga::XML::Node) || node.is_a?(::Oga::XML::Document)
 
           all_children + node.children.reject do |child|
             child.is_a?(::Oga::XML::Text) &&
@@ -188,7 +202,7 @@ module Moxml
         end
 
         def parent(node)
-          node.parent if node.respond_to?(:parent)
+          node.parent if node.is_a?(::Oga::XML::Node)
         end
 
         def next_sibling(node)
@@ -215,7 +229,7 @@ module Moxml
         end
 
         def attributes(element)
-          return [] unless element.respond_to?(:attributes)
+          return [] unless element.is_a?(::Oga::XML::Element)
 
           # remove attributes-namespaces
           element.attributes.reject do |attr|
@@ -316,10 +330,9 @@ module Moxml
         end
 
         def inner_text(node)
-          text = if node.respond_to?(:inner_text)
+          text = if node.is_a?(::Oga::XML::Element)
                    node.inner_text
                  else
-                   # Oga::XML::Text node for example
                    node.text
                  end
           restore_entity_markers(text)
@@ -327,7 +340,7 @@ module Moxml
 
         def set_text_content(node, content)
           encoded = encode_entity_markers(content)
-          if node.respond_to?(:inner_text=)
+          if node.is_a?(::Oga::XML::Element)
             node.inner_text = encoded
           else
             node.text = encoded
@@ -370,22 +383,32 @@ module Moxml
         end
 
         def namespace_definitions(node)
-          return [] unless node.respond_to?(:namespaces)
+          return [] unless node.is_a?(::Oga::XML::Element)
 
           node.namespaces.values
         end
 
         # Doctype accessor methods
+        # Note: Oga stores SYSTEM identifier in public_id for SYSTEM doctypes.
+        # See: Oga::XML::Doctype puts SYSTEM dtd in public_id, system_id is nil.
         def doctype_name(native)
           native.name
         end
 
         def doctype_external_id(native)
-          native.public_id
+          if native.type == "SYSTEM"
+            nil
+          else
+            native.public_id
+          end
         end
 
         def doctype_system_id(native)
-          native.system_id
+          if native.type == "SYSTEM"
+            native.public_id
+          else
+            native.system_id
+          end
         end
 
         def xpath(node, expression, namespaces = nil)
@@ -479,7 +502,7 @@ module Moxml
 
             if should_include_decl && !node.xml_declaration && !has_existing_declaration
               # Need to add declaration - create default one
-              output = +""
+              output = []
               output << '<?xml version="1.0" encoding="UTF-8"?>'
               output << "\n"
 
@@ -491,10 +514,10 @@ module Moxml
                 output << ::Moxml::Adapter::CustomizedOga::XmlGenerator.new(child).to_xml
               end
 
-              return output
+              return output.join
             elsif !should_include_decl
               # Skip xml_declaration
-              output = +""
+              output = []
 
               # Serialize doctype if present
               output << node.doctype.to_xml << "\n" if node.doctype
@@ -506,7 +529,7 @@ module Moxml
                 output << ::Moxml::Adapter::CustomizedOga::XmlGenerator.new(child).to_xml
               end
 
-              return output
+              return output.join
             end
           end
 
@@ -514,19 +537,20 @@ module Moxml
           # But first check if we need to handle declaration specially
           if node.is_a?(::Oga::XML::Document) && node.xml_declaration
             # Document has declaration - use custom handling to avoid duplicates
-            output = +""
+            output = []
+            xml_declaration_serialized = false
 
             # Serialize children, but skip XmlDeclaration if it would cause duplication
             node.children.each do |child|
-              # Check if this would cause duplication by seeing if we already have one in output
-              if child.is_a?(::Oga::XML::XmlDeclaration) && output.include?("<?xml")
-                next # Skip duplicate declaration
-              end
+              xml_declaration = child.is_a?(::Oga::XML::XmlDeclaration)
+              next if xml_declaration && xml_declaration_serialized
+
+              xml_declaration_serialized = true if xml_declaration
 
               output << ::Moxml::Adapter::CustomizedOga::XmlGenerator.new(child).to_xml
             end
 
-            output
+            output.join
           else
             # Normal case - use XmlGenerator directly
             ::Moxml::Adapter::CustomizedOga::XmlGenerator.new(node).to_xml