moxml 0.1.22 → 0.1.24

data/lib/moxml/adapter/base.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "../xml_utils"
-require_relative "../document_builder"
-
 module Moxml
   module Adapter
     class Base
@@ -104,8 +101,7 @@ module Moxml
         #
         # @return [Boolean] true if SAX parsing is supported
         def sax_supported?
-          respond_to?(:sax_parse) &&
-            method(:sax_parse).owner != Moxml::Adapter::Base.singleton_class
+          method(:sax_parse).owner != Moxml::Adapter::Base.singleton_class
         end
 
         def create_document(_native_doc = nil)
@@ -212,6 +208,10 @@ namespace_validation_mode: :strict)
           wrapper.has_xml_declaration
         end
 
+        # Clear the declaration state from the native document.
+        # Called when a Declaration node is removed from a document.
+        def remove_declaration(_native_doc); end
+
         # Return the actual native node after an add_child operation.
         # Override for adapters where node identity may change (e.g., LibXML doc.root=).
         def actual_native(child_native, _parent_native)

data/lib/moxml/adapter/customized_libxml/cdata.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "node"
-
 module Moxml
   module Adapter
     module CustomizedLibxml

data/lib/moxml/adapter/customized_libxml/comment.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "node"
-
 module Moxml
   module Adapter
     module CustomizedLibxml

data/lib/moxml/adapter/customized_libxml/element.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "node"
-
 module Moxml
   module Adapter
     module CustomizedLibxml
@@ -12,7 +10,7 @@ module Moxml
       class Element < Node
         # Add a child to this element, handling document import automatically
         def add_child(child)
-          child_native = child.respond_to?(:native) ? child.native : child
+          child_native = child.is_a?(Node) ? child.native : child
 
           # Check if child needs to be imported
           if needs_import?(child_native)
@@ -26,9 +24,9 @@ module Moxml
         private
 
         def needs_import?(child_node)
-          return false unless @native.respond_to?(:doc)
+          return false unless @native.is_a?(::LibXML::XML::Node)
           return false unless @native.doc
-          return false unless child_node.respond_to?(:doc)
+          return false unless child_node.is_a?(::LibXML::XML::Node)
           return false unless child_node.doc
 
           child_node.doc != @native.doc

data/lib/moxml/adapter/customized_libxml/node.rb

@@ -22,7 +22,7 @@ module Moxml
         def ==(other)
           return false unless other
 
-          other_native = other.respond_to?(:native) ? other.native : other
+          other_native = other.is_a?(self.class) ? other.native : other
           @native == other_native
         end
 
@@ -34,7 +34,7 @@ module Moxml
 
         # Check if node has a document
         def document_present?
-          @native.respond_to?(:doc) && !@native.doc.nil?
+          @native.is_a?(::LibXML::XML::Node) && !@native.doc.nil?
         end
 
         # Get the document this node belongs to

data/lib/moxml/adapter/customized_libxml/processing_instruction.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "node"
-
 module Moxml
   module Adapter
     module CustomizedLibxml

data/lib/moxml/adapter/customized_libxml/text.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "node"
-
 module Moxml
   module Adapter
     module CustomizedLibxml

data/lib/moxml/adapter/customized_oga/xml_declaration.rb

@@ -8,10 +8,17 @@ module Moxml
       class XmlDeclaration < ::Oga::XML::XmlDeclaration
         def initialize(options = {})
           @version    = options[:version] || "1.0"
-          # encoding is optional, but Oga sets it to UTF-8 by default
           @encoding   = options[:encoding]
           @standalone = options[:standalone]
         end
+
+        def to_xml
+          parts = ["<?xml"]
+          parts << %( version="#{version}") if version
+          parts << %( encoding="#{encoding}") if encoding
+          parts << %( standalone="#{standalone}") if standalone
+          "#{parts.join}?>"
+        end
       end
     end
   end

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

@@ -70,12 +70,12 @@ module Moxml
                       child.to_s.strip.empty? &&
                       !(child.next_sibling.nil? && child.previous_sibling.nil?)
 
-                    output << "\n" << (' ' * @level) if indent_children
+                    output << "\n" << (" " * @level) if indent_children
                     write(child, output)
                   end
                 when :eref
                   if eref_idx < entity_refs.size
-                    output << "\n" << (' ' * @level) if indent_children
+                    output << "\n" << (" " * @level) if indent_children
                     write(entity_refs[eref_idx], output)
                     eref_idx += 1
                   end
@@ -87,14 +87,14 @@ module Moxml
                   child.to_s.strip.empty? &&
                   !(child.next_sibling.nil? && child.previous_sibling.nil?)
 
-                output << "\n" << (' ' * @level) if indent_children
+                output << "\n" << (" " * @level) if indent_children
                 write(child, output)
               end
             end
 
             if indent_children
               @level -= @indentation.length
-              output << "\n" << (' ' * @level)
+              output << "\n" << (" " * @level)
             end
           end
 
@@ -185,9 +185,8 @@ module Moxml
           node.attributes.each do |name, attr|
             next unless name.to_s.start_with?("xmlns:") || name.to_s == "xmlns"
 
-            # convert the default namespace
             name = "xmlns" if name.to_s == "xmlns:"
-            value = attr.respond_to?(:value) ? attr.value : attr
+            value = attr.is_a?(::REXML::Attribute) ? attr.value : attr
             output << " #{name}=\"#{value}\""
           end
 
@@ -196,14 +195,14 @@ module Moxml
             next if name.to_s.start_with?("xmlns:") || name.to_s == "xmlns"
 
             output << " "
-            output << if attr.respond_to?(:prefix) && attr.prefix
+            output << if attr.is_a?(::REXML::Attribute) && attr.prefix
                         "#{attr.prefix}:#{attr.name}"
                       else
                         name.to_s
                       end
 
             output << "=\""
-            value = attr.respond_to?(:value) ? attr.value : attr
+            value = attr.is_a?(::REXML::Attribute) ? attr.value : attr
             output << escape_attribute_value(value.to_s)
             output << "\""
           end # rubocop:enable Style/CombinableLoops

data/lib/moxml/adapter/headed_ox.rb

@@ -2,11 +2,7 @@
 
 return if RUBY_ENGINE == "opal"
 
-require_relative "ox"
-require_relative "../xpath"
-# Force load XPath modules (autoload doesn't work well with relative requires in examples)
-require_relative "../xpath/parser"
-require_relative "../xpath/compiler"
+require "moxml/adapter/ox"
 
 module Moxml
   module Adapter

data/lib/moxml/adapter/libxml/entity_ref_registry.rb

@@ -9,7 +9,8 @@ module Moxml
         ENTITY_REFS_KEY = :_entity_ref_pairs
         CHILD_SEQUENCE_KEY = :_child_seq_pairs
         NON_WHITESPACE_RE = /\S/
-        private_constant :ENTITY_REFS_KEY, :CHILD_SEQUENCE_KEY, :NON_WHITESPACE_RE
+        private_constant :ENTITY_REFS_KEY, :CHILD_SEQUENCE_KEY,
+                         :NON_WHITESPACE_RE
 
         def initialize(attachments, doc)
           @attachments = attachments
@@ -34,7 +35,8 @@ module Moxml
           if existing
             existing << :eref
           else
-            seq_by_path[path] = Array.new(count_native_children(element), :native)
+            seq_by_path[path] =
+              Array.new(count_native_children(element), :native)
             seq_by_path[path] << :eref
             @attachments.set(@doc, CHILD_SEQUENCE_KEY, seq_by_path)
           end

data/lib/moxml/adapter/libxml/entity_restorer.rb

@@ -76,7 +76,9 @@ module Moxml
         def append_chunk(parent, type, payload)
           case type
           when :text
-            parent.add_child(::Moxml::Text.new(@adapter.create_native_text(payload), @ctx))
+            parent.add_child(::Moxml::Text.new(
+                               @adapter.create_native_text(payload), @ctx
+                             ))
           when :eref
             parent.add_child(
               ::Moxml::EntityReference.new(

data/lib/moxml/adapter/libxml.rb

@@ -2,14 +2,14 @@
 
 return if RUBY_ENGINE == "opal"
 
-require_relative "base"
 require "libxml"
-require_relative "customized_libxml"
-require_relative "../sax/namespace_splitter"
 
 module Moxml
   module Adapter
     class Libxml < Base
+      autoload :EntityRefRegistry, "moxml/adapter/libxml/entity_ref_registry"
+      autoload :EntityRestorer, "moxml/adapter/libxml/entity_restorer"
+
       # Wrapper class to store DOCTYPE information
       class DoctypeWrapper
         attr_reader :native_doc
@@ -239,7 +239,7 @@ module Moxml
           # Duck-typed fallback for libxml types that aren't ::Node
           # subclasses but still expose node_type (e.g. ::Attr).
           native = unpatch_node(node)
-          return :unknown unless native.respond_to?(:node_type)
+          return :unknown unless native.is_a?(::LibXML::XML::Node)
 
           NATIVE_NODE_TYPE_MAP[native.node_type] || :unknown
         end
@@ -836,7 +836,7 @@ module Moxml
           return [] unless namespaces
 
           namespace_list =
-            if namespaces.respond_to?(:definitions)
+            if namespaces.is_a?(::LibXML::XML::Namespaces)
               namespaces.definitions
             else
               namespaces
@@ -1076,6 +1076,11 @@ module Moxml
           end
         end
 
+        def remove_declaration(native_doc)
+          decl = attachments.get(native_doc, :declaration)
+          decl&.removed = true
+        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)
@@ -1182,7 +1187,8 @@ module Moxml
         end
 
         ESCAPE_XML_RE = /[&<>"]/
-        ESCAPE_XML_MAP = { "&" => "&amp;", "<" => "&lt;", ">" => "&gt;", '"' => "&quot;" }.freeze
+        ESCAPE_XML_MAP = { "&" => "&amp;", "<" => "&lt;", ">" => "&gt;",
+                           '"' => "&quot;" }.freeze
         private_constant :ESCAPE_XML_RE, :ESCAPE_XML_MAP
 
         def escape_xml(text)
@@ -1278,7 +1284,13 @@ module Moxml
           # attachment query that otherwise fires for every element under
           # Monitor#synchronize.
           eref_active = doc_eref_active?(elem.doc) if eref_active.nil?
-          entity_refs, child_sequence = eref_active ? lookup_entity_ref_serialization(elem) : [nil, nil]
+          entity_refs, child_sequence = if eref_active
+                                          lookup_entity_ref_serialization(elem)
+                                        else
+                                          [
+                                            nil, nil
+                                          ]
+                                        end
 
           # Always use verbose format <tag></tag> for consistency with other adapters
           output << ">"
@@ -1312,7 +1324,7 @@ module Moxml
           return unless elem.is_a?(::LibXML::XML::Node)
 
           ns_list = elem.namespaces
-          return unless ns_list.respond_to?(:definitions)
+          return unless ns_list.is_a?(::LibXML::XML::Namespaces)
 
           definitions = ns_list.definitions
           return if definitions.empty?
@@ -1544,7 +1556,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.is_a?(::LibXML::XML::Node) && node.namespaces.respond_to?(:namespace)
+          if node.is_a?(::LibXML::XML::Node) && node.namespaces.is_a?(::LibXML::XML::Namespaces)
             active_ns = node.namespaces.namespace
             if active_ns
               prefix = active_ns.prefix
@@ -1622,8 +1634,14 @@ module Moxml
         # duplicated — callers that need the subtree use deep_duplicate_node.
         def shallow_duplicate_element(native_node)
           new_node = ::LibXML::XML::Node.new(native_node.name)
-          copy_element_namespaces(native_node, new_node) if native_node.is_a?(::LibXML::XML::Node)
-          copy_element_attributes(native_node, new_node) if native_node.attributes?
+          if native_node.is_a?(::LibXML::XML::Node)
+            copy_element_namespaces(native_node,
+                                    new_node)
+          end
+          if native_node.attributes?
+            copy_element_attributes(native_node,
+                                    new_node)
+          end
           new_node
         end
 
@@ -1707,6 +1725,3 @@ module Moxml
     end
   end
 end
-
-require_relative "libxml/entity_ref_registry"
-require_relative "libxml/entity_restorer"

data/lib/moxml/adapter/nokogiri.rb

@@ -2,9 +2,7 @@
 
 return if RUBY_ENGINE == "opal"
 
-require_relative "base"
 require "nokogiri"
-require_relative "../sax/namespace_splitter"
 
 module Moxml
   module Adapter
@@ -245,25 +243,22 @@ module Moxml
         end
 
         def add_child(element, child)
-          # Special handling for declarations on Nokogiri documents
           if element.is_a?(::Nokogiri::XML::Document) &&
               child.is_a?(::Nokogiri::XML::ProcessingInstruction) &&
               child.name == "xml"
-            # Set document's xml_decl property
             version = declaration_attribute(child, "version") || "1.0"
             encoding = declaration_attribute(child, "encoding")
             standalone = declaration_attribute(child, "standalone")
 
-            # Store declaration state in attachment map
             attachments.set(element, :xml_decl, {
               version: version,
               encoding: encoding,
               standalone: standalone,
             }.compact)
+            return
           end
 
           if node_type(child) == :doctype
-            # avoid exceptions: cannot reparent Nokogiri::XML::DTD there
             element.create_internal_subset(
               child.name, child.external_id, child.system_id
             )
@@ -397,23 +392,28 @@ module Moxml
             save_options |= ::Nokogiri::XML::Node::SaveOptions::FORMAT
           end
 
-          # Handle declaration option
-          # Priority:
-          # 1. Explicit no_declaration option
-          # 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 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?
+          custom_decl = nil
+          if options[:no_declaration]
+            save_options |= ::Nokogiri::XML::Node::SaveOptions::NO_DECLARATION
+          elsif attachments.key?(node, :xml_decl) && (xml_decl = attachments.get(node, :xml_decl))
+            save_options |= ::Nokogiri::XML::Node::SaveOptions::NO_DECLARATION
+            attrs = ["version=\"#{xml_decl[:version]}\""]
+            attrs << "encoding=\"#{xml_decl[:encoding]}\"" if xml_decl[:encoding]
+            attrs << "standalone=\"#{xml_decl[:standalone]}\"" if xml_decl[:standalone]
+            custom_decl = "<?xml #{attrs.join(' ')}?>"
           end
 
-          node.to_xml(
+          result = node.to_xml(
             indent: options[:indent],
             encoding: options[:encoding],
             save_with: save_options,
           )
+
+          if custom_decl
+            result = "#{custom_decl}\n#{result}"
+          end
+
+          result
         end
 
         def has_declaration?(native_doc, wrapper)
@@ -424,6 +424,10 @@ module Moxml
           end
         end
 
+        def remove_declaration(native_doc)
+          attachments.set(native_doc, :xml_decl, nil)
+        end
+
         private
 
         def build_declaration_attrs(version, encoding, standalone)

data/lib/moxml/adapter/oga.rb

@@ -1,9 +1,6 @@
 # frozen_string_literal: true
 
-require_relative "base"
-require_relative "customized_oga"
 require "oga"
-require_relative "../sax/namespace_splitter"
 
 module Moxml
   module Adapter
@@ -289,11 +286,25 @@ module Moxml
               child_or_text
             end
 
-          # Special handling for declarations on Oga documents
           if element.is_a?(::Oga::XML::Document) &&
               child.is_a?(::Oga::XML::XmlDeclaration)
-            # Track declaration state in attachment map
             attachments.set(element, :xml_declaration, child)
+            return
+          end
+
+          # Insert doctype before root element in document
+          if element.is_a?(::Oga::XML::Document) && child.is_a?(::Oga::XML::Doctype)
+            root_idx = nil
+            element.children.each_with_index do |n, i|
+              if n.is_a?(::Oga::XML::Element)
+                root_idx = i
+                break
+              end
+            end
+            if root_idx
+              element.children.insert(root_idx, child)
+              return
+            end
           end
 
           element.children << child
@@ -456,95 +467,65 @@ module Moxml
         def has_declaration?(native_doc, _wrapper)
           decl = attachments.get(native_doc, :xml_declaration)
           if decl.nil? && !attachments.key?(native_doc, :xml_declaration)
-            # No attachment entry - check native doc (for parsed documents)
-            native_doc.respond_to?(:xml_declaration) && !native_doc.xml_declaration.nil?
+            native_doc.is_a?(::Oga::XML::Document) && !native_doc.xml_declaration.nil?
           else
             !decl.nil?
           end
         end
 
+        def remove_declaration(native_doc)
+          attachments.set(native_doc, :xml_declaration, nil)
+        end
+
         private
 
+        def declaration_to_xml(decl)
+          parts = ["<?xml"]
+          parts << %( version="#{decl.version}") if decl.version
+          parts << %( encoding="#{decl.encoding}") if decl.encoding
+          parts << %( standalone="#{decl.standalone}") if decl.standalone
+          "#{parts.join}?>"
+        end
+
         def serialize_without_entity_processing(node, options = {})
-          # Oga's XmlGenerator doesn't support options directly
-          # We need to handle declaration options ourselves for Document nodes
           if node.is_a?(::Oga::XML::Document)
-            # Check if we should include declaration
-            # Priority: explicit option > existence of xml_declaration (native or attachment)
-            effective_xml_declaration = node.xml_declaration || attachments.get(
-              node, :xml_declaration
-            )
+            effective_xml_declaration = attachments.get(node, :xml_declaration)
+
             should_include_decl = if options.key?(:no_declaration)
                                     !options[:no_declaration]
                                   elsif options.key?(:declaration)
                                     options[:declaration]
                                   else
-                                    # Default: include if document has xml_declaration
-                                    effective_xml_declaration ? true : false
+                                    effective_xml_declaration || node.xml_declaration ? true : false
                                   end
 
-            # Fix: Check if declaration already exists in children
-            # This prevents duplicate declarations when document already has one
-            has_existing_declaration = node.children.any?(::Oga::XML::XmlDeclaration)
+            output = []
 
-            if should_include_decl && !effective_xml_declaration && !has_existing_declaration
-              # Need to add declaration - create default one
-              output = []
-              output << '<?xml version="1.0" encoding="UTF-8"?>'
+            if should_include_decl
+              decl = effective_xml_declaration || node.xml_declaration
+              output << if decl
+                          declaration_to_xml(decl)
+                        else
+                          '<?xml version="1.0" encoding="UTF-8"?>'
+                        end
               output << "\n"
-
-              # Serialize doctype if present
-              output << node.doctype.to_xml << "\n" if node.doctype
-
-              # Serialize children
-              node.children.each do |child|
-                output << ::Moxml::Adapter::CustomizedOga::XmlGenerator.new(child).to_xml
-              end
-
-              return output.join
-            elsif !should_include_decl
-              # Skip xml_declaration
-              output = []
-
-              # Serialize doctype if present
-              output << node.doctype.to_xml << "\n" if node.doctype
-
-              # Serialize root and other children
-              node.children.each do |child|
-                next if child.is_a?(::Oga::XML::XmlDeclaration)
-
-                output << ::Moxml::Adapter::CustomizedOga::XmlGenerator.new(child).to_xml
-              end
-
-              return output.join
             end
-          end
 
-          # Default: use XmlGenerator
-          # But first check if we need to handle declaration specially
-          effective_xml_declaration = node.is_a?(::Oga::XML::Document) && (node.xml_declaration || attachments.get(
-            node, :xml_declaration
-          ))
-          if node.is_a?(::Oga::XML::Document) && effective_xml_declaration
-            # Document has declaration - use custom handling to avoid duplicates
-            output = []
-            xml_declaration_serialized = false
+            if node.doctype
+              output << node.doctype.to_xml
+              output << "\n"
+            end
 
-            # Serialize children, but skip XmlDeclaration if it would cause duplication
             node.children.each do |child|
-              xml_declaration = child.is_a?(::Oga::XML::XmlDeclaration)
-              next if xml_declaration && xml_declaration_serialized
-
-              xml_declaration_serialized = true if xml_declaration
+              next if child.is_a?(::Oga::XML::XmlDeclaration)
 
               output << ::Moxml::Adapter::CustomizedOga::XmlGenerator.new(child).to_xml
             end
 
-            output.join
-          else
-            # Normal case - use XmlGenerator directly
-            ::Moxml::Adapter::CustomizedOga::XmlGenerator.new(node).to_xml
+            return output.join
           end
+
+          ::Moxml::Adapter::CustomizedOga::XmlGenerator.new(node).to_xml
         end
       end
     end