canon 0.2.8 → 0.2.9

data/lib/canon/comparison/xml_comparator/node_parser.rb

@@ -77,21 +77,22 @@ module Canon
         # @return [Canon::Xml::Node] Converted node
         def self.convert_from_node(node, preserve_whitespace: false,
 parser: nil)
-          # FAST PATH: Convert Nokogiri/Moxml nodes directly without string round-trip
-          if defined?(Nokogiri::XML::Node) && node.is_a?(Nokogiri::XML::Node)
-            return Canon::Xml::DataModel.build_from_nokogiri(
+          if Canon::XmlBackend.nokogiri?
+            if node.is_a?(Nokogiri::XML::Node)
+              return Canon::Xml::DataModel.build_from_nokogiri(
+                node, preserve_whitespace: preserve_whitespace
+              )
+            end
+          elsif node.is_a?(Moxml::Node)
+            return Canon::Xml::DataModel.build_from_moxml(
               node, preserve_whitespace: preserve_whitespace
             )
           end
 
-          # SLOW PATH: Fallback to string serialization for unknown node types
-          xml_str = if node.respond_to?(:to_xml)
-                      node.to_xml
-                    elsif node.respond_to?(:to_s)
-                      node.to_s
+          xml_str = if node.is_a?(String)
+                      node
                     else
-                      raise Canon::Error,
-                            "Unable to convert node to string: #{node.class}"
+                      node.to_xml
                     end
 
           resolved_parser = parser || resolve_parser_config
@@ -112,7 +113,7 @@ parser: nil)
         def self.resolve_parser_config
           Canon::Config.instance.xml.diff.parser
         rescue StandardError
-          :sax
+          Canon::XmlBackend.nokogiri? ? :sax : :dom
         end
       end
     end

data/lib/canon/comparison/xml_comparator/node_type_comparator.rb

@@ -7,90 +7,62 @@ module Canon
       #
       # Handles dispatching comparison logic based on node type.
       # Supports both Canon::Xml::Node (with symbolic node_type) and
-      # Moxml/Nokogiri nodes (with predicate methods like element?, text?, etc.)
-      #
-      # This module encapsulates the complex node type detection and dispatch
-      # logic, making the main XmlComparator cleaner and more maintainable.
+      # backend nodes (Nokogiri/Moxml) via XmlParsing type checks.
       module NodeTypeComparator
         class << self
-          # Compare two nodes by dispatching to appropriate comparison method
-          #
-          # @param node1 [Object] First node
-          # @param node2 [Object] Second node
-          # @param comparator [XmlComparator] The comparator instance for method delegation
-          # @param opts [Hash] Comparison options
-          # @param child_opts [Hash] Options for child comparison
-          # @param diff_children [Boolean] Whether to diff children
-          # @param differences [Array] Array to collect differences
-          # @return [Integer] Comparison result code
           def compare(node1, node2, comparator, opts, child_opts,
 diff_children, differences)
-            # Dispatch based on node type
-            # Canon::Xml::Node types use .node_type method that returns symbols
-            # Nokogiri also has .node_type but returns integers, so check for Symbol
-            if node1.respond_to?(:node_type) && node2.respond_to?(:node_type) &&
-                node1.node_type.is_a?(Symbol) && node2.node_type.is_a?(Symbol)
+            if node1.is_a?(Canon::Xml::Node) && node2.is_a?(Canon::Xml::Node)
               compare_by_symbolic_type(node1, node2, comparator, opts, child_opts,
                                        diff_children, differences)
-            # Moxml/Nokogiri types use .element?, .text?, etc. methods
             else
-              compare_by_predicate_methods(node1, node2, comparator, opts, child_opts,
-                                           diff_children, differences)
+              compare_by_backend_type(node1, node2, comparator, opts, child_opts,
+                                      diff_children, differences)
             end
           end
 
           private
 
-          # Compare nodes using symbolic node_type (Canon::Xml::Node)
           def compare_by_symbolic_type(node1, node2, comparator, opts, child_opts,
                                        diff_children, differences)
             case node1.node_type
             when :root
-              comparator.send(:compare_children, node1, node2, opts, child_opts,
-                              diff_children, differences)
+              comparator.compare_children(node1, node2, opts, child_opts,
+                                          diff_children, differences)
             when :element
-              comparator.send(:compare_element_nodes, node1, node2, opts, child_opts,
-                              diff_children, differences)
+              comparator.compare_element_nodes(node1, node2, opts, child_opts,
+                                               diff_children, differences)
             when :text
-              comparator.send(:compare_text_nodes, node1, node2, opts,
-                              differences)
+              comparator.compare_text_nodes(node1, node2, opts, differences)
             when :comment
-              comparator.send(:compare_comment_nodes, node1, node2, opts,
-                              differences)
+              comparator.compare_comment_nodes(node1, node2, opts, differences)
             when :cdata
-              comparator.send(:compare_text_nodes, node1, node2, opts,
-                              differences)
+              comparator.compare_text_nodes(node1, node2, opts, differences)
             when :processing_instruction
-              comparator.send(:compare_processing_instruction_nodes, node1, node2, opts,
-                              differences)
+              comparator.compare_processing_instruction_nodes(node1, node2, opts,
+                                                              differences)
             else
               Comparison::EQUIVALENT
             end
           end
 
-          # Compare nodes using predicate methods (Moxml/Nokogiri)
-          def compare_by_predicate_methods(node1, node2, comparator, opts, child_opts,
-                                           diff_children, differences)
-            if node1.respond_to?(:element?) && node1.element?
-              comparator.send(:compare_element_nodes, node1, node2, opts, child_opts,
-                              diff_children, differences)
-            elsif node1.respond_to?(:text?) && node1.text?
-              comparator.send(:compare_text_nodes, node1, node2, opts,
-                              differences)
-            elsif node1.respond_to?(:comment?) && node1.comment?
-              comparator.send(:compare_comment_nodes, node1, node2, opts,
-                              differences)
-            elsif node1.respond_to?(:cdata?) && node1.cdata?
-              comparator.send(:compare_text_nodes, node1, node2, opts,
-                              differences)
-            elsif node1.respond_to?(:processing_instruction?) &&
-                node1.processing_instruction?
-              comparator.send(:compare_processing_instruction_nodes, node1, node2, opts,
-                              differences)
-            elsif node1.respond_to?(:root)
-              # Document node (Moxml/Nokogiri - legacy path)
-              comparator.send(:compare_document_nodes, node1, node2, opts, child_opts,
-                              diff_children, differences)
+          def compare_by_backend_type(node1, node2, comparator, opts, child_opts,
+                                      diff_children, differences)
+            if Canon::XmlParsing.element?(node1)
+              comparator.compare_element_nodes(node1, node2, opts, child_opts,
+                                               diff_children, differences)
+            elsif Canon::XmlParsing.text_node?(node1)
+              comparator.compare_text_nodes(node1, node2, opts, differences)
+            elsif Canon::XmlParsing.comment?(node1)
+              comparator.compare_comment_nodes(node1, node2, opts, differences)
+            elsif Canon::XmlParsing.cdata?(node1)
+              comparator.compare_text_nodes(node1, node2, opts, differences)
+            elsif Canon::XmlParsing.processing_instruction?(node1)
+              comparator.compare_processing_instruction_nodes(node1, node2, opts,
+                                                              differences)
+            elsif Canon::XmlParsing.document?(node1)
+              comparator.compare_document_nodes(node1, node2, opts, child_opts,
+                                                diff_children, differences)
             else
               Comparison::EQUIVALENT
             end

data/lib/canon/comparison/xml_comparator.rb

@@ -122,16 +122,8 @@ module Canon
                              preserve_whitespace: preserve_whitespace)
 
           # Store original strings for line diff display (before preprocessing)
-          original1 = if n1.is_a?(String)
-                        n1
-                      else
-                        (n1.respond_to?(:to_xml) ? n1.to_xml : n1.to_s)
-                      end
-          original2 = if n2.is_a?(String)
-                        n2
-                      else
-                        (n2.respond_to?(:to_xml) ? n2.to_xml : n2.to_s)
-                      end
+          original1 = n1.is_a?(String) ? n1 : serialize_node(n1)
+          original2 = n2.is_a?(String) ? n2 : serialize_node(n2)
 
           differences = []
           diff_children = opts[:diff_children] || false
@@ -187,16 +179,9 @@ module Canon
         # @return [Boolean, ComparisonResult] Result of tree diff comparison
         def perform_semantic_tree_diff(n1, n2, opts, match_opts_hash)
           # Store original strings for line diff display (before preprocessing)
-          original1 = if n1.is_a?(String)
-                        n1
-                      else
-                        (n1.respond_to?(:to_xml) ? n1.to_xml : n1.to_s)
-                      end
-          original2 = if n2.is_a?(String)
-                        n2
-                      else
-                        (n2.respond_to?(:to_xml) ? n2.to_xml : n2.to_s)
-                      end
+          # Store original strings for line diff display (before preprocessing)
+          original1 = n1.is_a?(String) ? n1 : serialize_node(n1)
+          original2 = n2.is_a?(String) ? n2 : serialize_node(n2)
 
           # Parse to Canon::Xml::Node (preserves preprocessing)
           node1 = parse_node(n1, match_opts_hash[:preprocessing])
@@ -262,20 +247,8 @@ module Canon
             serialize_node(node1).gsub("><", ">\n<"),
             serialize_node(node2).gsub("><", ">\n<"),
           ]
-          original1 = if n1.is_a?(String)
-                        n1
-                      elsif n1.respond_to?(:to_xml)
-                        n1.to_xml
-                      else
-                        n1.to_s
-                      end
-          original2 = if n2.is_a?(String)
-                        n2
-                      elsif n2.respond_to?(:to_xml)
-                        n2.to_xml
-                      else
-                        n2.to_s
-                      end
+          original1 = n1.is_a?(String) ? n1 : serialize_node(n1)
+          original2 = n2.is_a?(String) ? n2 : serialize_node(n2)
 
           ComparisonResult.new(
             differences: [],
@@ -289,14 +262,20 @@ module Canon
 
         public
 
+        # Public parsing API for external callers
+        def parse(node, preprocessing = :none, preserve_whitespace: false)
+          parse_node(node, preprocessing,
+                     preserve_whitespace: preserve_whitespace)
+        end
+
         # Main comparison dispatcher
         def compare_nodes(n1, n2, opts, child_opts, diff_children, differences)
           # FAST PATH: Object identity - same object is always equivalent
           return Comparison::EQUIVALENT if n1.equal?(n2)
 
           # Handle DocumentFragment nodes - compare their children instead
-          if n1.is_a?(Nokogiri::XML::DocumentFragment) &&
-              n2.is_a?(Nokogiri::XML::DocumentFragment)
+          if Canon::XmlParsing.document_fragment?(n1) &&
+              Canon::XmlParsing.document_fragment?(n2)
             children1 = n1.children.to_a
             children2 = n2.children.to_a
 
@@ -392,8 +371,8 @@ module Canon
           end
 
           # Compare namespace URIs - elements with different namespaces are different elements
-          ns1 = n1.respond_to?(:namespace_uri) ? n1.namespace_uri : nil
-          ns2 = n2.respond_to?(:namespace_uri) ? n2.namespace_uri : nil
+          ns1 = Canon::XmlParsing.namespace_uri(n1)
+          ns2 = Canon::XmlParsing.namespace_uri(n2)
 
           unless ns1 == ns2
             # Create descriptive reason showing the actual namespace URIs
@@ -410,18 +389,30 @@ module Canon
             return Comparison::UNEQUAL_ELEMENTS
           end
 
+          # Track the worst result across namespace, attribute, and children
+          # comparisons. Do NOT return early on attribute/namespace mismatches —
+          # children must still be compared so structural differences in the
+          # subtree are reported. Early returns caused the comparator to skip
+          # entire subtrees when a root or intermediate element had different
+          # attributes, missing all nested structural changes.
+          worst_result = Comparison::EQUIVALENT
+
           # Compare namespace declarations (xmlns and xmlns:* attributes)
           ns_result = compare_namespace_declarations(n1, n2, opts, differences)
-          return ns_result unless ns_result == Comparison::EQUIVALENT
+          worst_result = ns_result unless ns_result == Comparison::EQUIVALENT
 
           # Compare attributes
           attr_result = compare_attribute_sets(n1, n2, opts, differences)
-          return attr_result unless attr_result == Comparison::EQUIVALENT
+          worst_result = attr_result unless attr_result == Comparison::EQUIVALENT
 
           # Compare children if not ignored
-          return Comparison::EQUIVALENT if opts[:ignore_children]
+          unless opts[:ignore_children]
+            child_result = compare_children(n1, n2, opts, child_opts,
+                                            diff_children, differences)
+            worst_result = child_result unless child_result == Comparison::EQUIVALENT
+          end
 
-          compare_children(n1, n2, opts, child_opts, diff_children, differences)
+          worst_result
         end
 
         # Compare attribute sets
@@ -500,7 +491,7 @@ module Canon
         def should_preserve_whitespace_strictly?(n1, n2, opts)
           # Check both n1 and n2 - if either is in a preserve whitespace element, preserve strictly
           [n1, n2].each do |node|
-            next unless node.respond_to?(:parent)
+            next unless Canon::XmlParsing.xml_node?(node) || node.is_a?(Canon::Xml::Node)
 
             parent = node.parent
             next unless parent
@@ -516,15 +507,12 @@ module Canon
         # Check if a node is inside a whitespace-preserving element
         def in_preserve_element?(node, preserve_list)
           current = node.parent
-          while current.respond_to?(:name)
+          while Canon::XmlParsing.xml_node?(current) || current.is_a?(Canon::Xml::Node)
             return true if preserve_list.include?(current.name.downcase)
 
-            # Stop at document root
-            break if current.is_a?(Nokogiri::XML::Document) ||
-              current.is_a?(Nokogiri::HTML4::Document) ||
-              current.is_a?(Nokogiri::HTML5::Document)
+            break if Canon::XmlParsing.document?(current)
 
-            current = current.parent if current.respond_to?(:parent)
+            current = current.parent
             break unless current
           end
           false
@@ -567,8 +555,8 @@ module Canon
             return Comparison::UNEQUAL_NODES_TYPES
           end
 
-          content1 = n1.respond_to?(:content) ? n1.content.to_s.strip : ""
-          content2 = n2.respond_to?(:content) ? n2.content.to_s.strip : ""
+          content1 = Canon::XmlParsing.xml_node?(n1) ? n1.content.to_s.strip : ""
+          content2 = Canon::XmlParsing.xml_node?(n2) ? n2.content.to_s.strip : ""
 
           if content1 == content2
             Comparison::EQUIVALENT
@@ -618,17 +606,19 @@ differences)
           depth = 0
 
           while current && depth < max_depth
-            if current.respond_to?(:name) && current.name
-              path.unshift(current.name)
-            end
+            n = if current.is_a?(Canon::Xml::Node)
+                  current.name
+                elsif Canon::XmlParsing.xml_node?(current)
+                  current.name
+                end
+            path.unshift(n) if n
 
-            break unless current.respond_to?(:parent)
+            break unless Canon::XmlParsing.xml_node?(current) || current.is_a?(Canon::Xml::Node)
 
             current = current.parent
             depth += 1
 
-            # Stop at document root
-            break if current.respond_to?(:root)
+            break if Canon::XmlParsing.document?(current)
           end
 
           path
@@ -665,8 +655,8 @@ differences)
           # For deleted/inserted nodes, include namespace information if available
           if dimension == :text_content && (node1.nil? || node2.nil?)
             node = node1 || node2
-            if node.respond_to?(:name) && node.respond_to?(:namespace_uri)
-              ns = node.namespace_uri
+            if Canon::XmlParsing.xml_node?(node)
+              ns = Canon::XmlParsing.namespace_uri(node)
               ns_info = if ns.nil? || ns.empty?
                           ""
                         else
@@ -674,9 +664,8 @@ differences)
                         end
               label = Canon::Comparison.code_pair_label(diff1, diff2)
               return "element '#{node.name}'#{ns_info}: #{label}"
-            elsif node.respond_to?(:name) && !node.respond_to?(:namespace_uri)
-              # TextNode and other nodes without namespace_uri
-              display = if node.respond_to?(:value) && node.node_type == :text
+            elsif node.is_a?(Canon::Xml::Node)
+              display = if node.is_a?(Canon::Xml::Nodes::TextNode)
                           "\"#{truncate_text(node.value)}\""
                         else
                           node.name.to_s
@@ -726,8 +715,8 @@ differences)
           elsif dimension == :element_structure &&
               diff1 == Canon::Comparison::UNEQUAL_ELEMENTS &&
               diff2 == Canon::Comparison::UNEQUAL_ELEMENTS &&
-              (node1.is_a?(Canon::Xml::Node) || node1.is_a?(Nokogiri::XML::Node)) &&
-              (node2.is_a?(Canon::Xml::Node) || node2.is_a?(Nokogiri::XML::Node)) &&
+              (node1.is_a?(Canon::Xml::Node) || Canon::XmlParsing.xml_node?(node1)) &&
+              (node2.is_a?(Canon::Xml::Node) || Canon::XmlParsing.xml_node?(node2)) &&
               node1.name && node2.name && node1.name != node2.name
             # Most common case: differing element names.  Surface the
             # actual names rather than a generic "elements differ".
@@ -798,27 +787,16 @@ differences)
         # @return [String, nil] Text content or nil
         def extract_text_from_node(node)
           return nil if node.nil?
-
-          # For Canon::Xml::Nodes::TextNode
-          return node.value if node.respond_to?(:value) && node.is_a?(Canon::Xml::Nodes::TextNode)
-
-          # For XML/HTML nodes with text_content method
-          return node.text_content if node.respond_to?(:text_content)
-
-          # For nodes with text method
-          return node.text if node.respond_to?(:text)
-
-          # For nodes with content method (Moxml::Text)
-          return node.content if node.respond_to?(:content)
-
-          # For nodes with value method (other types)
-          return node.value if node.respond_to?(:value)
-
-          # For simple text nodes or strings
           return node.to_s if node.is_a?(String)
 
-          # For other node types, try to_s
-          node.to_s
+          case node
+          when Canon::Xml::Nodes::TextNode
+            node.value
+          when Canon::Xml::Node
+            node.text_content
+          else
+            Canon::XmlParsing.xml_node?(node) ? Canon::XmlParsing.text_content(node).to_s : node.to_s
+          end
         rescue StandardError
           nil
         end

data/lib/canon/comparison/xml_node_comparison.rb

@@ -27,8 +27,8 @@ module Canon
       def self.compare_nodes(node1, node2, opts, child_opts, diff_children,
 differences)
         # Handle DocumentFragment nodes - compare their children instead
-        if node1.is_a?(Nokogiri::XML::DocumentFragment) &&
-            node2.is_a?(Nokogiri::XML::DocumentFragment)
+        if Canon::XmlParsing.document_fragment?(node1) &&
+            Canon::XmlParsing.document_fragment?(node2)
           return compare_document_fragments(node1, node2, opts, child_opts,
                                             diff_children, differences)
         end
@@ -285,10 +285,14 @@ diff_children, differences)
         return false if node1.class != node2.class
 
         case node1
-        when Canon::Xml::Node, Nokogiri::XML::Node
+        when Canon::Xml::Node
           node1.node_type == node2.node_type
         else
-          true
+          if Canon::XmlBackend.nokogiri?
+            node1.is_a?(Nokogiri::XML::Node) && node1.node_type == node2.node_type
+          else
+            Canon::XmlParsing.xml_node?(node1) && Canon::XmlParsing.node_type(node1) == Canon::XmlParsing.node_type(node2)
+          end
         end
       end
 
@@ -305,7 +309,7 @@ diff_children, differences)
       def self.comment_node?(node, check_children: false)
         return true if NodeInspector.comment_node?(node)
 
-        if check_children && node.is_a?(Nokogiri::XML::Element) && !node.children.empty?
+        if check_children && Canon::XmlParsing.element?(node) && !Canon::XmlParsing.children(node).empty?
           node.children.any? { |child| NodeInspector.comment_node?(child) }
         else
           false
@@ -360,24 +364,20 @@ diff_children, differences)
       # Dispatch by legacy Nokogiri/Moxml node type
       def self.dispatch_legacy_node_type(node1, node2, opts, child_opts,
 diff_children, differences)
-        # Import XmlComparator to use its comparison methods
         require_relative "xml_comparator"
 
-        case node1
-        when Nokogiri::XML::Document
+        if Canon::XmlParsing.document?(node1)
           XmlComparator.compare_document_nodes(node1, node2, opts, child_opts,
                                                diff_children, differences)
-        when Nokogiri::XML::Node
-          if node1.element?
+        elsif Canon::XmlParsing.xml_node?(node1)
+          if Canon::XmlParsing.element?(node1)
             XmlComparator.compare_element_nodes(node1, node2, opts, child_opts,
                                                 diff_children, differences)
-          elsif node1.text?
+          elsif Canon::XmlParsing.text_node?(node1) || Canon::XmlParsing.cdata?(node1)
             XmlComparator.compare_text_nodes(node1, node2, opts, differences)
-          elsif node1.comment?
+          elsif Canon::XmlParsing.comment?(node1)
             XmlComparator.compare_comment_nodes(node1, node2, opts, differences)
-          elsif node1.cdata?
-            XmlComparator.compare_text_nodes(node1, node2, opts, differences)
-          elsif node1.processing_instruction?
+          elsif Canon::XmlParsing.processing_instruction?(node1)
             XmlComparator.compare_processing_instruction_nodes(node1, node2,
                                                                opts, differences)
           else

data/lib/canon/comparison/yaml_comparator.rb

@@ -27,6 +27,14 @@ module Canon
       }.freeze
 
       class << self
+        # Parse YAML from string or return as-is
+        #
+        # @param obj [String, Hash, Array] YAML string or parsed object
+        # @return [Object] Parsed YAML object
+        def parse(obj)
+          parse_yaml(obj)
+        end
+
         # Compare two YAML objects for equivalence
         #
         # @param yaml1 [String, Hash, Array] First YAML

data/lib/canon/comparison.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require "moxml"
-require "nokogiri"
+require "nokogiri" if Canon::XmlBackend.nokogiri?
 require_relative "xml/whitespace_normalizer"
 require_relative "comparison/xml_comparator"
 require_relative "comparison/html_comparator"
@@ -316,7 +316,8 @@ module Canon
 
         # Get global config options if not defined in opts
         # This is needed because semantic_diff doesn't go through dom_diff's config handling
-        if !(opts[:match_profile] || opts[:global_options]) && Canon::Config.instance.respond_to?(format1)
+        if !(opts[:match_profile] || opts[:global_options]) && %i[xml html json
+                                                                  yaml string].include?(format1)
           format_config = Canon::Config.instance.public_send(format1)
           if format_config.match.profile
             opts[:match_profile] =
@@ -333,7 +334,8 @@ module Canon
 
         # Also read diff options from config (e.g., max_node_count for large documents)
         # This is independent of match options and needs to be passed to TreeDiffIntegrator
-        if !match_opts_hash[:max_node_count] && Canon::Config.instance.respond_to?(format1)
+        if !match_opts_hash[:max_node_count] && %i[xml html json yaml
+                                                   string].include?(format1)
           diff_max_node = Canon::Config.instance.public_send(format1).diff.max_node_count
           if diff_max_node > 10_000
             match_opts_hash[:max_node_count] =
@@ -564,43 +566,39 @@ module Canon
 
         case format
         when :xml
-          # Delegate to XmlComparator's parse_node - returns Canon::Xml::Node
-          # Adapter now handles Canon::Xml::Node directly
+          # Delegate to XmlComparator's parse - returns Canon::Xml::Node
           doc1 = parse_with_cache(obj1, format, preprocessing) do |doc|
-            XmlComparator.send(:parse_node, doc, preprocessing)
+            XmlComparator.parse(doc, preprocessing)
           end
           doc2 = parse_with_cache(obj2, format, preprocessing) do |doc|
-            XmlComparator.send(:parse_node, doc, preprocessing)
+            XmlComparator.parse(doc, preprocessing)
           end
           [doc1, doc2]
         when :html, :html4, :html5
-          # Delegate to HtmlComparator's parse_node_for_semantic for Canon::Xml::Node
           [
             parse_with_cache(obj1, format, preprocessing) do |doc|
-              HtmlComparator.send(:parse_node_for_semantic, doc, preprocessing)
+              HtmlComparator.parse(doc, preprocessing)
             end,
             parse_with_cache(obj2, format, preprocessing) do |doc|
-              HtmlComparator.send(:parse_node_for_semantic, doc, preprocessing)
+              HtmlComparator.parse(doc, preprocessing)
             end,
           ]
         when :json
-          # Delegate to JsonComparator's parse_json
           [
             parse_with_cache(obj1, format, :none) do |doc|
-              JsonComparator.send(:parse_json, doc)
+              JsonComparator.parse(doc)
             end,
             parse_with_cache(obj2, format, :none) do |doc|
-              JsonComparator.send(:parse_json, doc)
+              JsonComparator.parse(doc)
             end,
           ]
         when :yaml
-          # Delegate to YamlComparator's parse_yaml
           [
             parse_with_cache(obj1, format, :none) do |doc|
-              YamlComparator.send(:parse_yaml, doc)
+              YamlComparator.parse(doc)
             end,
             parse_with_cache(obj2, format, :none) do |doc|
-              YamlComparator.send(:parse_yaml, doc)
+              YamlComparator.parse(doc)
             end,
           ]
         else
@@ -651,12 +649,10 @@ module Canon
           obj
         when Nokogiri::XML::Document, Nokogiri::HTML::Document,
              Nokogiri::XML::DocumentFragment, Nokogiri::HTML::DocumentFragment
-          obj.respond_to?(:to_html) ? obj.to_html : obj.to_xml
+          obj.to_html
         else
-          if obj.respond_to?(:to_html)
-            obj.to_html
-          elsif obj.respond_to?(:to_xml)
-            obj.to_xml
+          if Canon::XmlParsing.xml_node?(obj) || obj.is_a?(Canon::Xml::Node)
+            Canon::XmlParsing.serialize(obj)
           else
             obj.to_s
           end
@@ -667,7 +663,11 @@ module Canon
       def serialize_document(doc, format)
         case format
         when :xml, :html, :html4, :html5
-          doc.respond_to?(:to_html) ? doc.to_html : doc.to_xml
+          if Canon::XmlParsing.xml_node?(doc) || doc.is_a?(Canon::Xml::Node)
+            Canon::XmlParsing.serialize(doc)
+          else
+            doc.to_s
+          end
         when :json
           require "json"
           JSON.pretty_generate(doc)
@@ -750,7 +750,7 @@ module Canon
 
         # get match_profile if it is not defined in options
         # but defined in config
-        if Canon::Config.instance.respond_to?(comparison_format)
+        if %i[xml html json yaml string].include?(comparison_format)
           format_config = Canon::Config.instance.public_send(comparison_format)
           if opts[:global_profile].nil? && format_config.match.profile
             # Config-sourced profile has *global* priority (applied before