canon 0.1.7 → 0.1.9

data/lib/canon/comparison/xml_comparator.rb

@@ -1,18 +1,33 @@
 # frozen_string_literal: true
 
 require_relative "../xml/c14n"
+require_relative "markup_comparator"
 require_relative "match_options"
 require_relative "../diff/diff_node"
 require_relative "../diff/diff_classifier"
+require_relative "../diff/path_builder"
+require_relative "../diff/node_serializer"
 require_relative "comparison_result"
 require_relative "../tree_diff"
 require_relative "strategies/match_strategy_factory"
+# XmlComparator modules
+require_relative "xml_comparator/node_parser"
+require_relative "xml_comparator/attribute_filter"
+require_relative "xml_comparator/attribute_comparator"
+require_relative "xml_comparator/namespace_comparator"
+require_relative "xml_comparator/node_type_comparator"
+require_relative "xml_comparator/child_comparison"
+require_relative "xml_comparator/diff_node_builder"
+# Whitespace sensitivity module
+require_relative "whitespace_sensitivity"
 
 module Canon
   module Comparison
     # XML comparison class
     # Handles comparison of XML nodes with various options
-    class XmlComparator
+    #
+    # Inherits shared comparison functionality from MarkupComparator.
+    class XmlComparator < MarkupComparator
       # Default comparison options for XML
       DEFAULT_OPTS = {
         # Structural filtering options
@@ -77,9 +92,15 @@ module Canon
           # Create child_opts with resolved options
           child_opts = opts.merge(child_opts)
 
+          # Determine if we should preserve whitespace during parsing
+          # When structural_whitespace is :strict, preserve all whitespace-only text nodes
+          preserve_whitespace = match_opts_hash[:structural_whitespace] == :strict
+
           # Parse nodes if they are strings, applying preprocessing if needed
-          node1 = parse_node(n1, match_opts_hash[:preprocessing])
-          node2 = parse_node(n2, match_opts_hash[:preprocessing])
+          node1 = parse_node(n1, match_opts_hash[:preprocessing],
+                             preserve_whitespace: preserve_whitespace)
+          node2 = parse_node(n2, match_opts_hash[:preprocessing],
+                             preserve_whitespace: preserve_whitespace)
 
           # Store original strings for line diff display (before preprocessing)
           original1 = if n1.is_a?(String)
@@ -111,8 +132,8 @@ module Canon
             # Serialize parsed nodes for consistent formatting
             # This ensures both sides formatted identically, showing only real differences
             preprocessed = [
-              serialize_node_to_xml(node1).gsub(/></, ">\n<"),
-              serialize_node_to_xml(node2).gsub(/></, ">\n<"),
+              serialize_node(node1).gsub(/></, ">\n<"),
+              serialize_node(node2).gsub(/></, ">\n<"),
             ]
 
             ComparisonResult.new(
@@ -195,43 +216,10 @@ module Canon
 
         # Parse a node from string or return as-is
         # Applies preprocessing transformation before parsing if specified
-        def parse_node(node, preprocessing = :none)
-          # If already a Canon::Xml::Node, return as-is
-          return node if node.is_a?(Canon::Xml::Node)
-
-          # If it's a Nokogiri or Moxml node, convert to DataModel
-          unless node.is_a?(String)
-            # Convert to XML string then parse through DataModel
-            xml_str = if node.respond_to?(:to_xml)
-                        node.to_xml
-                      elsif node.respond_to?(:to_s)
-                        node.to_s
-                      else
-                        raise Canon::Error,
-                              "Unable to convert node to string: #{node.class}"
-                      end
-            return Canon::Xml::DataModel.from_xml(xml_str)
-          end
-
-          # Apply preprocessing to XML string before parsing
-          xml_string = case preprocessing
-                       when :normalize
-                         # Normalize whitespace: collapse runs, trim lines
-                         node.lines.map(&:strip).reject(&:empty?).join("\n")
-                       when :c14n
-                         # Canonicalize the XML
-                         Canon::Xml::C14n.canonicalize(node,
-                                                       with_comments: false)
-                       when :format
-                         # Pretty format the XML
-                         Canon.format(node, :xml)
-                       else
-                         # :none or unrecognized - use as-is
-                         node
-                       end
-
-          # Use Canon::Xml::DataModel for parsing to get Canon::Xml::Node instances
-          Canon::Xml::DataModel.from_xml(xml_string)
+        # Delegates to NodeParser module
+        def parse_node(node, preprocessing = :none, preserve_whitespace: false)
+          XmlComparatorHelpers::NodeParser.parse(node, preprocessing,
+                                                 preserve_whitespace: preserve_whitespace)
         end
 
         # Main comparison dispatcher
@@ -279,51 +267,15 @@ module Canon
             return Comparison::UNEQUAL_NODES_TYPES
           end
 
-          # 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 n1.respond_to?(:node_type) && n2.respond_to?(:node_type) &&
-              n1.node_type.is_a?(Symbol) && n2.node_type.is_a?(Symbol)
-            case n1.node_type
-            when :root
-              compare_children(n1, n2, opts, child_opts, diff_children,
-                               differences)
-            when :element
-              compare_element_nodes(n1, n2, opts, child_opts, diff_children,
-                                    differences)
-            when :text
-              compare_text_nodes(n1, n2, opts, differences)
-            when :comment
-              compare_comment_nodes(n1, n2, opts, differences)
-            when :cdata
-              compare_text_nodes(n1, n2, opts, differences)
-            when :processing_instruction
-              compare_processing_instruction_nodes(n1, n2, opts, differences)
-            else
-              Comparison::EQUIVALENT
-            end
-          # Moxml/Nokogiri types use .element?, .text?, etc. methods
-          elsif n1.respond_to?(:element?) && n1.element?
-            compare_element_nodes(n1, n2, opts, child_opts, diff_children,
-                                  differences)
-          elsif n1.respond_to?(:text?) && n1.text?
-            compare_text_nodes(n1, n2, opts, differences)
-          elsif n1.respond_to?(:comment?) && n1.comment?
-            compare_comment_nodes(n1, n2, opts, differences)
-          elsif n1.respond_to?(:cdata?) && n1.cdata?
-            compare_text_nodes(n1, n2, opts, differences)
-          elsif n1.respond_to?(:processing_instruction?) &&
-              n1.processing_instruction?
-            compare_processing_instruction_nodes(n1, n2, opts, differences)
-          elsif n1.respond_to?(:root)
-            # Document node (Moxml/Nokogiri - legacy path)
-            compare_document_nodes(n1, n2, opts, child_opts, diff_children,
-                                   differences)
-          else
-            Comparison::EQUIVALENT
-          end
+          # Dispatch based on node type using NodeTypeComparator strategy
+          XmlComparatorHelpers::NodeTypeComparator.compare(
+            n1, n2, self, opts, child_opts, diff_children, differences
+          )
         end
 
+        # Public comparison methods - exposed for XmlNodeComparison module
+        public
+
         # Compare two element nodes
         def compare_element_nodes(n1, n2, opts, child_opts, diff_children,
                                   differences)
@@ -369,153 +321,10 @@ module Canon
         end
 
         # Compare attribute sets
+        # Delegates to XmlComparatorHelpers::AttributeComparator
         def compare_attribute_sets(n1, n2, opts, differences)
-          # Get attributes using the appropriate method for each node type
-          raw_attrs1 = n1.respond_to?(:attribute_nodes) ? n1.attribute_nodes : n1.attributes
-          raw_attrs2 = n2.respond_to?(:attribute_nodes) ? n2.attribute_nodes : n2.attributes
-
-          attrs1 = filter_attributes(raw_attrs1, opts)
-          attrs2 = filter_attributes(raw_attrs2, opts)
-
-          match_opts = opts[:match_opts]
-          attribute_order_behavior = match_opts[:attribute_order] || :strict
-
-          # Check attribute order if not ignored
-          keys1 = attrs1.keys.map(&:to_s)
-          keys2 = attrs2.keys.map(&:to_s)
-          if attribute_order_behavior == :strict
-            # Strict mode: attribute order matters
-            # Check if keys are in same order
-
-            if keys1 != keys2
-              # Keys are different or in different order
-              # First check if it's just ordering (same keys, different order)
-              if keys1.sort == keys2.sort
-                # Same keys, different order - this is an attribute_order difference
-                add_difference(n1, n2, Comparison::UNEQUAL_ATTRIBUTES,
-                               Comparison::UNEQUAL_ATTRIBUTES,
-                               :attribute_order, opts, differences)
-                return Comparison::UNEQUAL_ATTRIBUTES
-              else
-                # Different keys - this is attribute_presence difference
-                add_difference(n1, n2, Comparison::MISSING_ATTRIBUTE,
-                               Comparison::MISSING_ATTRIBUTE,
-                               :attribute_presence, opts, differences)
-                return Comparison::MISSING_ATTRIBUTE
-              end
-            end
-
-          # Order matches, now check values in order
-          else
-            # Ignore/normalize mode: attribute order doesn't affect equivalence
-            # But in verbose mode, we should still track order differences as informative
-
-            # Check if order differs (but keys are the same)
-            if keys1 != keys2 && keys1.sort == keys2.sort && opts[:verbose]
-              # Same keys, different order - create informative DiffNode
-              # This allows line diffs to be properly classified as informative
-              add_difference(n1, n2, Comparison::UNEQUAL_ATTRIBUTES,
-                             Comparison::UNEQUAL_ATTRIBUTES,
-                             :attribute_order, opts, differences)
-            end
-
-            # Sort attributes so order doesn't matter for comparison
-            attrs1 = attrs1.sort_by { |k, _v| k.to_s }.to_h
-            attrs2 = attrs2.sort_by { |k, _v| k.to_s }.to_h
-
-            unless attrs1.keys.map(&:to_s).sort == attrs2.keys.map(&:to_s).sort
-              add_difference(n1, n2, Comparison::MISSING_ATTRIBUTE,
-                             Comparison::MISSING_ATTRIBUTE,
-                             :attribute_presence, opts, differences)
-              return Comparison::MISSING_ATTRIBUTE
-            end
-
-          end
-          attrs1.each do |name, value|
-            unless attrs2[name] == value
-              add_difference(n1, n2, Comparison::UNEQUAL_ATTRIBUTES,
-                             Comparison::UNEQUAL_ATTRIBUTES,
-                             :attribute_values, opts, differences)
-              return Comparison::UNEQUAL_ATTRIBUTES
-            end
-          end
-
-          Comparison::EQUIVALENT
-        end
-
-        # Filter attributes based on options
-        def filter_attributes(attributes, opts)
-          filtered = {}
-          match_opts = opts[:match_opts]
-
-          # Handle Canon::Xml::Node attribute format (array of AttributeNode)
-          if attributes.is_a?(Array)
-            attributes.each do |attr|
-              name = attr.name
-              value = attr.value
-
-              # Skip namespace declarations - they're handled separately
-              next if is_namespace_declaration?(name)
-
-              # Skip if attribute name should be ignored
-              next if should_ignore_attr_by_name?(name, opts)
-
-              # Skip if attribute content should be ignored
-              next if should_ignore_attr_content?(value, opts)
-
-              # Apply match options for attribute values
-              behavior = match_opts[:attribute_values] || :strict
-              value = MatchOptions.process_attribute_value(value, behavior)
-
-              filtered[name] = value
-            end
-          else
-            # Handle Nokogiri and Moxml attribute formats (Hash-like):
-            # - Nokogiri: key is String name, val is Nokogiri::XML::Attr object
-            # - Moxml: key is Moxml::Attribute object, val is nil
-            attributes.each do |key, val|
-              if key.is_a?(String)
-                # Nokogiri format: key=name (String), val=attr object
-                name = key
-                value = val.respond_to?(:value) ? val.value : val.to_s
-              else
-                # Moxml format: key=attr object, val=nil
-                name = key.respond_to?(:name) ? key.name : key.to_s
-                value = key.respond_to?(:value) ? key.value : key.to_s
-              end
-
-              # Skip namespace declarations - they're handled separately
-              next if is_namespace_declaration?(name)
-
-              # Skip if attribute name should be ignored
-              next if should_ignore_attr_by_name?(name, opts)
-
-              # Skip if attribute content should be ignored
-              next if should_ignore_attr_content?(value, opts)
-
-              # Apply match options for attribute values
-              behavior = match_opts[:attribute_values] || :strict
-              value = MatchOptions.process_attribute_value(value, behavior)
-
-              filtered[name] = value
-            end
-          end
-
-          filtered
-        end
-
-        # Check if attribute should be ignored by name
-        def should_ignore_attr_by_name?(name, opts)
-          opts[:ignore_attrs_by_name].any? do |pattern|
-            name.include?(pattern)
-          end
-        end
-
-        # Check if attribute should be ignored by content
-        def should_ignore_attr_content?(value, opts)
-          opts[:ignore_attr_content].any? do |pattern|
-            value.to_s.include?(pattern)
-          end
+          XmlComparatorHelpers::AttributeComparator.compare(n1, n2, opts,
+                                                            differences)
         end
 
         # Compare text nodes
@@ -531,7 +340,8 @@ module Canon
 
           # For HTML, check if text node is inside whitespace-preserving element
           # If so, always use strict comparison regardless of text_content setting
-          if should_preserve_whitespace_strictly?(n1, n2)
+          sensitive_element = should_preserve_whitespace_strictly?(n1, n2, opts)
+          if sensitive_element
             behavior = :strict
           end
 
@@ -544,15 +354,23 @@ module Canon
 
           # Determine the correct dimension for this difference
           # - If text_content is :strict, ALL differences use :text_content dimension
-          # - If text_content is :normalize, whitespace-only diffs use :structural_whitespace
+          # - If text_content is :normalize, whitespace-only diffs could use :structural_whitespace
+          #   but we keep :text_content to ensure correct classification behavior
           # - Otherwise use :text_content
-          dimension = if behavior == :normalize && whitespace_only_difference?(
-            text1, text2
-          )
-                        :structural_whitespace
-                      else
-                        :text_content
-                      end
+          # However, if element is whitespace-sensitive (like <pre> in HTML),
+          # always use :text_content dimension regardless of behavior
+          #
+          # NOTE: We keep the dimension as :text_content even for whitespace-only diffs
+          # when text_content: :normalize. This ensures that the classification uses
+          # the text_content behavior (:normalize) instead of structural_whitespace
+          # behavior (:strict for XML), which would incorrectly mark the diff as normative.
+          if sensitive_element
+          # Whitespace-sensitive element: always use :text_content dimension
+          else
+            # Always use :text_content for text differences
+            # This ensures correct classification based on text_content behavior
+          end
+          dimension = :text_content
 
           # Create DiffNode in verbose mode when raw content differs
           # This ensures informative diffs are created even for :ignore/:normalize
@@ -566,32 +384,25 @@ module Canon
           matches_per_behavior ? Comparison::EQUIVALENT : Comparison::UNEQUAL_TEXT_CONTENTS
         end
 
-        # Check if the difference between two texts is only whitespace-related
-        # @param text1 [String] First text
-        # @param text2 [String] Second text
-        # @return [Boolean] true if difference is only in whitespace
-        def whitespace_only_difference?(text1, text2)
-          # Normalize both texts (collapse/trim whitespace)
-          norm1 = MatchOptions.normalize_text(text1)
-          norm2 = MatchOptions.normalize_text(text2)
-
-          # If normalized texts are the same, the difference was only whitespace
-          norm1 == norm2
-        end
-
         # Check if whitespace should be preserved strictly for these text nodes
         # This applies to HTML elements like pre, code, textarea, script, style
-        def should_preserve_whitespace_strictly?(n1, n2)
-          # Only applies to Nokogiri nodes (HTML)
-          return false unless n1.respond_to?(:parent) && n2.respond_to?(:parent)
-          return false unless n1.parent.respond_to?(:name) && n2.parent.respond_to?(:name)
+        # and elements with xml:space="preserve" or in user-configured whitelist
+        def should_preserve_whitespace_strictly?(n1, n2, opts)
+          # Use WhitespaceSensitivity module to check if element is sensitive
+          # Check both n1 and n2 - if either is in a sensitive element, preserve strictly
+          if n1.respond_to?(:parent)
+            sensitivity_opts = { match_opts: opts[:match_opts] }
+            return true if WhitespaceSensitivity.element_sensitive?(n1,
+                                                                    sensitivity_opts)
+          end
 
-          # Elements where whitespace must be preserved in HTML
-          preserve_elements = %w[pre code textarea script style]
+          if n2.respond_to?(:parent)
+            sensitivity_opts = { match_opts: opts[:match_opts] }
+            return true if WhitespaceSensitivity.element_sensitive?(n2,
+                                                                    sensitivity_opts)
+          end
 
-          # Check if either node is inside a whitespace-preserving element
-          in_preserve_element?(n1, preserve_elements) ||
-            in_preserve_element?(n2, preserve_elements)
+          false
         end
 
         # Check if a node is inside a whitespace-preserving element
@@ -680,258 +491,13 @@ module Canon
 
         # Compare children of two nodes using semantic matching
         #
-        # Uses ElementMatcher to pair children semantically (by identity attributes
-        # or position), then compares matched pairs and detects position changes.
+        # Delegates to ChildComparison module which handles both ElementMatcher
+        # (semantic matching) and simple positional comparison.
         def compare_children(n1, n2, opts, child_opts, diff_children,
-                             differences)
-          children1 = filter_children(n1.children, opts)
-          children2 = filter_children(n2.children, opts)
-
-          # Quick check: if both have no children, they're equivalent
-          return Comparison::EQUIVALENT if children1.empty? && children2.empty?
-
-          # Check if we can use ElementMatcher (requires Canon::Xml::DataModel nodes)
-          # ElementMatcher expects nodes with .node_type method that returns symbols
-          # and only works with element nodes (filters out text, comment, etc.)
-          can_use_matcher = children1.all? do |c|
-            c.is_a?(Canon::Xml::Node) && c.node_type == :element
-          end &&
-            children2.all? { |c| c.is_a?(Canon::Xml::Node) && c.node_type == :element }
-
-          if can_use_matcher && !children1.empty? && !children2.empty?
-            # Use ElementMatcher for semantic matching with position tracking
-            use_element_matcher_comparison(children1, children2, n1, opts,
-                                           child_opts, diff_children, differences)
-          else
-            # Fall back to simple positional comparison for Moxml/Nokogiri nodes
-            # Length check
-            unless children1.length == children2.length
-              # Determine dimension based on type of first differing child
-              # When lengths differ, find which child is missing/extra
-              dimension = :text_content # default
-
-              # Compare position by position to find first difference
-              max_len = [children1.length, children2.length].max
-              (0...max_len).each do |i|
-                if i >= children1.length
-                  # Extra child in children2
-                  dimension = determine_node_dimension(children2[i])
-                  break
-                elsif i >= children2.length
-                  # Extra child in children1
-                  dimension = determine_node_dimension(children1[i])
-                  break
-                elsif !same_node_type?(children1[i], children2[i])
-                  # Different node types at same position
-                  dimension = determine_node_dimension(children1[i])
-                  break
-                end
-              end
-
-              add_difference(n1, n2, Comparison::MISSING_NODE,
-                             Comparison::MISSING_NODE, dimension, opts,
-                             differences)
-              return Comparison::MISSING_NODE
-            end
-
-            # Compare children pairwise by position
-            result = Comparison::EQUIVALENT
-            children1.zip(children2).each do |child1, child2|
-              child_result = compare_nodes(child1, child2, child_opts, child_opts,
-                                           diff_children, differences)
-              result = child_result unless child_result == Comparison::EQUIVALENT
-            end
-
-            result
-          end
-        end
-
-        # Use ElementMatcher for semantic comparison (Canon::Xml::DataModel nodes)
-        def use_element_matcher_comparison(children1, children2, parent_node,
-                                          opts, child_opts, diff_children,
-                                          differences)
-          require_relative "../xml/element_matcher"
-
-          # Create temporary RootNode wrappers to use ElementMatcher
-          # Don't modify parent pointers - just set @children directly
-          require_relative "../xml/nodes/root_node"
-
-          temp_root1 = Canon::Xml::Nodes::RootNode.new
-          temp_root1.instance_variable_set(:@children, children1.dup)
-
-          temp_root2 = Canon::Xml::Nodes::RootNode.new
-          temp_root2.instance_variable_set(:@children, children2.dup)
-
-          matcher = Canon::Xml::ElementMatcher.new
-          matches = matcher.match_trees(temp_root1, temp_root2)
-
-          # Filter matches to only include direct children
-          # match_trees returns ALL descendants, but we only want direct children
-          matches = matches.select do |m|
-            (m.elem1.nil? || children1.include?(m.elem1)) &&
-              (m.elem2.nil? || children2.include?(m.elem2))
-          end
-
-          # If no matches and children exist, they're all different
-          if matches.empty? && (!children1.empty? || !children2.empty?)
-            add_difference(parent_node, parent_node, Comparison::MISSING_NODE,
-                           Comparison::MISSING_NODE, :text_content, opts,
-                           differences)
-            return Comparison::UNEQUAL_ELEMENTS
-          end
-
-          all_equivalent = true
-
-          matches.each do |match|
-            case match.status
-            when :matched
-              # Check if element position changed
-              if match.position_changed?
-                match_opts = opts[:match_opts]
-                position_behavior = match_opts[:element_position] || :strict
-
-                # Only create DiffNode if element_position is not :ignore
-                if position_behavior != :ignore
-                  add_difference(
-                    match.elem1,
-                    match.elem2,
-                    "position #{match.pos1}",
-                    "position #{match.pos2}",
-                    :element_position,
-                    opts,
-                    differences,
-                  )
-                  all_equivalent = false if position_behavior == :strict
-                end
-              end
-
-              # Compare the matched elements for content/attribute differences
-              result = compare_nodes(match.elem1, match.elem2, child_opts,
-                                     child_opts, diff_children, differences)
-              all_equivalent = false unless result == Comparison::EQUIVALENT
-
-            when :deleted
-              # Element present in first tree but not second
-              add_difference(match.elem1, nil, Comparison::MISSING_NODE,
-                             Comparison::MISSING_NODE, :element_structure, opts,
-                             differences)
-              all_equivalent = false
-
-            when :inserted
-              # Element present in second tree but not first
-              add_difference(nil, match.elem2, Comparison::MISSING_NODE,
-                             Comparison::MISSING_NODE, :element_structure, opts,
-                             differences)
-              all_equivalent = false
-            end
-          end
-
-          all_equivalent ? Comparison::EQUIVALENT : Comparison::UNEQUAL_ELEMENTS
-        end
-
-        # Filter children based on options
-        def filter_children(children, opts)
-          children.reject do |child|
-            node_excluded?(child, opts)
-          end
-        end
-
-        # Check if node should be excluded
-        def node_excluded?(node, opts)
-          match_opts = opts[:match_opts]
-
-          # Determine node type
-          # Canon::Xml::Node uses node_type that returns Symbol
-          # Nokogiri uses node_type that returns Integer, so check for Symbol first
-          if node.respond_to?(:node_type) && node.node_type.is_a?(Symbol)
-            node.node_type == :comment
-          else
-            node.respond_to?(:comment?) && node.comment?
-          end
-
-          is_text = if node.respond_to?(:node_type) && node.node_type.is_a?(Symbol)
-                      node.node_type == :text
-                    else
-                      node.respond_to?(:text?) && node.text?
-                    end
-
-          # Ignore text nodes if specified
-          return true if opts[:ignore_text_nodes] && is_text
-
-          # Ignore whitespace-only text nodes based on structural_whitespace
-          # Both :ignore and :normalize should filter out whitespace-only nodes
-          if %i[ignore
-                normalize].include?(match_opts[:structural_whitespace]) && is_text
-            text = node_text(node)
-            return true if MatchOptions.normalize_text(text).empty?
-          end
-
-          false
-        end
-
-        # Determine the appropriate dimension for a node type
-        # @param node [Object] The node to check
-        # @return [Symbol] The dimension symbol
-        def determine_node_dimension(node)
-          # Canon::Xml::Node types
-          if node.respond_to?(:node_type) && node.node_type.is_a?(Symbol)
-            case node.node_type
-            when :comment then :comments
-            when :text, :cdata then :text_content
-            when :processing_instruction then :processing_instructions
-            else :text_content
-            end
-          # Moxml/Nokogiri types
-          elsif node.respond_to?(:comment?) && node.comment?
-            :comments
-          elsif node.respond_to?(:text?) && node.text?
-            :text_content
-          elsif node.respond_to?(:cdata?) && node.cdata?
-            :text_content
-          elsif node.respond_to?(:processing_instruction?) && node.processing_instruction?
-            :processing_instructions
-          else
-            :text_content
-          end
-        end
-
-        # Check if two nodes are the same type
-        def same_node_type?(n1, n2)
-          # Canon::Xml::Node types - check node_type method
-          if n1.respond_to?(:node_type) && n2.respond_to?(:node_type)
-            return n1.node_type == n2.node_type
-          end
-
-          # Moxml/Nokogiri types - check individual type methods
-          return true if n1.respond_to?(:element?) && n1.element? &&
-            n2.respond_to?(:element?) && n2.element?
-          return true if n1.respond_to?(:text?) && n1.text? &&
-            n2.respond_to?(:text?) && n2.text?
-          return true if n1.respond_to?(:comment?) && n1.comment? &&
-            n2.respond_to?(:comment?) && n2.comment?
-          return true if n1.respond_to?(:cdata?) && n1.cdata? &&
-            n2.respond_to?(:cdata?) && n2.cdata?
-          return true if n1.respond_to?(:processing_instruction?) &&
-            n1.processing_instruction? &&
-            n2.respond_to?(:processing_instruction?) &&
-            n2.processing_instruction?
-          return true if n1.respond_to?(:root) && n2.respond_to?(:root)
-
-          false
-        end
-
-        # Get text content from a node
-        def node_text(node)
-          # Canon::Xml::Node TextNode uses .value
-          if node.respond_to?(:value)
-            node.value.to_s
-          elsif node.respond_to?(:content)
-            node.content.to_s
-          elsif node.respond_to?(:text)
-            node.text.to_s
-          else
-            ""
-          end
+differences)
+          XmlComparatorHelpers::ChildComparison.compare(
+            n1, n2, self, opts, child_opts, diff_children, differences
+          )
         end
 
         # Extract element path for context (best effort)
@@ -960,67 +526,24 @@ module Canon
           path
         end
 
-        # Serialize a node to XML string
-        # @param node [Canon::Xml::Node, Object] Node to serialize
-        # @return [String] XML string representation
-        def serialize_node_to_xml(node)
-          if node.is_a?(Canon::Xml::Nodes::RootNode)
-            # Serialize all children of root
-            node.children.map { |child| serialize_node_to_xml(child) }.join
-          elsif node.is_a?(Canon::Xml::Nodes::ElementNode)
-            # Serialize element with attributes and children
-            attrs = node.attribute_nodes.map do |a|
-              " #{a.name}=\"#{a.value}\""
-            end.join
-            children_xml = node.children.map do |c|
-              serialize_node_to_xml(c)
-            end.join
-
-            if children_xml.empty?
-              "<#{node.name}#{attrs}/>"
-            else
-              "<#{node.name}#{attrs}>#{children_xml}</#{node.name}>"
-            end
-          elsif node.is_a?(Canon::Xml::Nodes::TextNode)
-            node.value
-          elsif node.is_a?(Canon::Xml::Nodes::CommentNode)
-            "<!--#{node.value}-->"
-          elsif node.is_a?(Canon::Xml::Nodes::ProcessingInstructionNode)
-            "<?#{node.target} #{node.data}?>"
-          elsif node.respond_to?(:to_xml)
-            node.to_xml
-          else
-            node.to_s
-          end
-        end
+        # Serialize a node to string for display
+        #
+        # @param node [Object, nil] Node to serialize
+        # @return [String, nil] Serialized content
+        def serialize_node(node)
+          return nil if node.nil?
 
-        # Add a difference to the differences array
-        # @param node1 [Object] First node
-        # @param node2 [Object] Second node
-        # @param diff1 [String] Difference type for node1
-        # @param diff2 [String] Difference type for node2
-        # @param dimension [Symbol] The match dimension causing this difference
-        # @param opts [Hash] Options
-        # @param differences [Array] Array to append difference to
-        def add_difference(node1, node2, diff1, diff2, dimension, _opts,
-                           differences)
-          # All differences must be DiffNode objects (OO architecture)
-          if dimension.nil?
-            raise ArgumentError,
-                  "dimension required for DiffNode"
-          end
+          Canon::Diff::NodeSerializer.serialize(node)
+        end
 
-          # Build informative reason message
-          reason = build_difference_reason(node1, node2, diff1, diff2,
-                                           dimension)
+        # Extract attributes from a node as a normalized hash
+        #
+        # @param node [Object, nil] Node to extract attributes from
+        # @return [Hash, nil] Normalized attributes hash
+        def extract_attributes(node)
+          return nil if node.nil?
 
-          diff_node = Canon::Diff::DiffNode.new(
-            node1: node1,
-            node2: node2,
-            dimension: dimension,
-            reason: reason,
-          )
-          differences << diff_node
+          Canon::Diff::NodeSerializer.extract_attributes(node)
         end
 
         # Build a human-readable reason for a difference
@@ -1049,120 +572,10 @@ module Canon
         end
 
         # Compare namespace declarations (xmlns and xmlns:* attributes)
-        # @param n1 [Object] First node
-        # @param n2 [Object] Second node
-        # @param opts [Hash] Options
-        # @param differences [Array] Array to append differences to
-        # @return [Symbol] Comparison result
+        # Delegates to XmlComparatorHelpers::NamespaceComparator
         def compare_namespace_declarations(n1, n2, opts, differences)
-          ns_decls1 = extract_namespace_declarations(n1)
-          ns_decls2 = extract_namespace_declarations(n2)
-
-          # Find missing, extra, and changed namespace declarations
-          missing = ns_decls1.keys - ns_decls2.keys  # In n1 but not n2
-          extra = ns_decls2.keys - ns_decls1.keys    # In n2 but not n1
-          changed = ns_decls1.select do |prefix, uri|
-            ns_decls2[prefix] && ns_decls2[prefix] != uri
-          end.keys
-
-          # If there are any differences, create a DiffNode
-          if missing.any? || extra.any? || changed.any?
-            # Build a descriptive reason
-            reasons = []
-            if missing.any?
-              reasons << "removed: #{missing.map do |p|
-                p.empty? ? 'xmlns' : "xmlns:#{p}"
-              end.join(', ')}"
-            end
-            if extra.any?
-              reasons << "added: #{extra.map do |p|
-                p.empty? ? 'xmlns' : "xmlns:#{p}"
-              end.join(', ')}"
-            end
-            if changed.any?
-              reasons << "changed: #{changed.map do |p|
-                p.empty? ? 'xmlns' : "xmlns:#{p}"
-              end.join(', ')}"
-            end
-
-            add_difference(
-              n1,
-              n2,
-              Comparison::UNEQUAL_ATTRIBUTES,
-              Comparison::UNEQUAL_ATTRIBUTES,
-              :namespace_declarations,
-              opts,
-              differences,
-            )
-            return Comparison::UNEQUAL_ATTRIBUTES
-          end
-
-          Comparison::EQUIVALENT
-        end
-
-        # Extract namespace declarations from a node
-        # @param node [Object] Node to extract namespace declarations from
-        # @return [Hash] Hash of prefix => URI mappings
-        def extract_namespace_declarations(node)
-          declarations = {}
-
-          # Handle Canon::Xml::Node (uses namespace_nodes)
-          if node.respond_to?(:namespace_nodes)
-            node.namespace_nodes.each do |ns|
-              # Skip the implicit xml namespace (always present)
-              next if ns.prefix == "xml" && ns.uri == "http://www.w3.org/XML/1998/namespace"
-
-              prefix = ns.prefix || ""
-              declarations[prefix] = ns.uri
-            end
-            return declarations
-          end
-
-          # Handle Nokogiri/Moxml nodes (use attributes)
-          # Get raw attributes
-          raw_attrs = node.respond_to?(:attribute_nodes) ? node.attribute_nodes : node.attributes
-
-          # Handle Canon::Xml::Node attribute format (array of AttributeNode)
-          if raw_attrs.is_a?(Array)
-            raw_attrs.each do |attr|
-              name = attr.name
-              value = attr.value
-
-              if is_namespace_declaration?(name)
-                # Extract prefix: "xmlns" -> "", "xmlns:xmi" -> "xmi"
-                prefix = name == "xmlns" ? "" : name.split(":", 2)[1]
-                declarations[prefix] = value
-              end
-            end
-          else
-            # Handle Nokogiri and Moxml attribute formats (Hash-like)
-            raw_attrs.each do |key, val|
-              if key.is_a?(String)
-                # Nokogiri format: key=name (String), val=attr object
-                name = key
-                value = val.respond_to?(:value) ? val.value : val.to_s
-              else
-                # Moxml format: key=attr object, val=nil
-                name = key.respond_to?(:name) ? key.name : key.to_s
-                value = key.respond_to?(:value) ? key.value : key.to_s
-              end
-
-              if is_namespace_declaration?(name)
-                # Extract prefix: "xmlns" -> "", "xmlns:xmi" -> "xmi"
-                prefix = name == "xmlns" ? "" : name.split(":", 2)[1]
-                declarations[prefix] = value
-              end
-            end
-          end
-
-          declarations
-        end
-
-        # Check if an attribute name is a namespace declaration
-        # @param attr_name [String] Attribute name
-        # @return [Boolean] true if it's a namespace declaration
-        def is_namespace_declaration?(attr_name)
-          attr_name == "xmlns" || attr_name.start_with?("xmlns:")
+          XmlComparatorHelpers::NamespaceComparator.compare(n1, n2, opts,
+                                                            differences)
         end
       end
     end