canon 0.1.7 → 0.1.8

data/lib/canon/comparison/profile_definition.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require_relative "match_options"
+
+module Canon
+  module Comparison
+    # Profile definition DSL with full validation
+    #
+    # Provides a clean, validated way to define custom comparison profiles.
+    # Catches errors at definition time with clear, actionable messages.
+    #
+    # @example Define a custom profile
+    #   Canon::Comparison.define_profile(:my_custom) do
+    #     text_content :normalize
+    #     comments :ignore
+    #     preprocessing :rendered
+    #   end
+    class ProfileDefinition
+      # All valid dimensions for XML/HTML comparison
+      # These must match MatchOptions::Xml::MATCH_DIMENSIONS
+      VALID_DIMENSIONS = %i[
+        text_content
+        structural_whitespace
+        attribute_presence
+        attribute_order
+        attribute_values
+        element_position
+        comments
+      ].freeze
+
+      # Behaviors valid for each dimension
+      # Maps dimension name to array of valid behavior symbols
+      DIMENSION_BEHAVIORS = {
+        text_content: %i[strict normalize ignore],
+        structural_whitespace: %i[strict normalize ignore],
+        attribute_presence: %i[strict ignore],
+        attribute_order: %i[strict ignore],
+        attribute_values: %i[strict strip compact normalize ignore],
+        element_position: %i[strict ignore],
+        comments: %i[strict ignore],
+      }.freeze
+
+      attr_reader :name, :settings
+
+      # Initialize a new profile definition
+      #
+      # @param name [Symbol] Profile name
+      def initialize(name)
+        @name = name
+        @settings = {}
+      end
+
+      # Define a profile using DSL syntax
+      #
+      # @param name [Symbol] Profile name
+      # @yield [ProfileDefinition] DSL block for defining profile
+      # @return [Hash] Profile settings hash
+      # @raise [ProfileError] if profile definition is invalid
+      def self.define(name, &block)
+        definition = new(name)
+        definition.instance_eval(&block) if block
+        definition.validate!
+        definition.to_h
+      end
+
+      # Create DSL methods for each dimension
+      VALID_DIMENSIONS.each do |dimension|
+        define_method(dimension) do |behavior|
+          @settings[dimension] = behavior
+        end
+      end
+
+      # Set preprocessing mode
+      #
+      # @param mode [Symbol] Preprocessing mode
+      # @raise [ProfileError] if mode is invalid
+      def preprocessing(mode)
+        unless MatchOptions::PREPROCESSING_OPTIONS.include?(mode)
+          raise ProfileError,
+                "Invalid preprocessing mode: #{mode}. " \
+                "Valid options: #{MatchOptions::PREPROCESSING_OPTIONS.join(', ')}"
+        end
+
+        @settings[:preprocessing] = mode
+      end
+
+      # Enable/disable semantic diff
+      #
+      # @param enabled [Boolean] Whether to enable semantic diff (default: true)
+      def semantic_diff(enabled: true)
+        @settings[:semantic_diff] = enabled
+      end
+
+      # Set similarity threshold for semantic matching
+      #
+      # @param value [Numeric] Threshold between 0 and 1
+      # @raise [ProfileError] if value is out of range
+      def similarity_threshold(value)
+        unless value.is_a?(Numeric) && value >= 0 && value <= 1
+          raise ProfileError,
+                "Similarity threshold must be between 0 and 1, got: #{value}"
+        end
+
+        @settings[:similarity_threshold] = value
+      end
+
+      # Validate the profile definition
+      #
+      # @raise [ProfileError] if profile definition is invalid
+      def validate!
+        @settings.each do |key, value|
+          validate_dimension!(key, value) if VALID_DIMENSIONS.include?(key)
+        end
+      end
+
+      # Convert to hash
+      #
+      # @return [Hash] Profile settings
+      def to_h
+        @settings.dup
+      end
+
+      private
+
+      # Validate a dimension setting
+      #
+      # @param dimension [Symbol] Dimension name
+      # @param behavior [Symbol] Behavior value
+      # @raise [ProfileError] if dimension or behavior is invalid
+      def validate_dimension!(dimension, behavior)
+        unless DIMENSION_BEHAVIORS.key?(dimension)
+          raise ProfileError,
+                "Unknown dimension: #{dimension}. " \
+                "Valid dimensions: #{VALID_DIMENSIONS.join(', ')}"
+        end
+
+        valid_behaviors = DIMENSION_BEHAVIORS[dimension]
+        unless valid_behaviors.include?(behavior)
+          raise ProfileError,
+                "Invalid behavior '#{behavior}' for dimension '#{dimension}'. " \
+                "Valid behaviors: #{valid_behaviors.join(', ')}"
+        end
+      end
+    end
+
+    # Custom error for profile definition issues
+    class ProfileError < Error; end
+  end
+end

data/lib/canon/comparison/ruby_object_comparator.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+module Canon
+  module Comparison
+    # Ruby Object Comparison Utilities
+    #
+    # Provides public comparison methods for Ruby objects (Hash, Array, primitives).
+    # This module extracts shared comparison logic that was previously
+    # accessed via send() from YamlComparator.
+    module RubyObjectComparator
+      # Compare Ruby objects (Hash, Array, primitives) for JSON/YAML
+      #
+      # @param obj1 [Object] First object
+      # @param obj2 [Object] Second object
+      # @param opts [Hash] Comparison options
+      # @param differences [Array] Array to append differences to
+      # @param path [String] Current path in the object structure
+      # @return [Symbol] Comparison result constant
+      def self.compare_objects(obj1, obj2, opts, differences, path)
+        # Check for type mismatch
+        unless obj1.instance_of?(obj2.class)
+          add_difference(path, obj1, obj2, Comparison::UNEQUAL_TYPES,
+                         opts, differences)
+          return Comparison::UNEQUAL_TYPES
+        end
+
+        case obj1
+        when Hash
+          compare_hashes(obj1, obj2, opts, differences, path)
+        when Array
+          compare_arrays(obj1, obj2, opts, differences, path)
+        when NilClass, TrueClass, FalseClass, Numeric, String, Symbol
+          compare_primitives(obj1, obj2, opts, differences, path)
+        else
+          # Fallback to equality comparison
+          if obj1 == obj2
+            Comparison::EQUIVALENT
+          else
+            add_difference(path, obj1, obj2,
+                           Comparison::UNEQUAL_PRIMITIVES, opts,
+                           differences)
+            Comparison::UNEQUAL_PRIMITIVES
+          end
+        end
+      end
+
+      # Compare two hashes
+      #
+      # @param hash1 [Hash] First hash
+      # @param hash2 [Hash] Second hash
+      # @param opts [Hash] Comparison options
+      # @param differences [Array] Array to append differences to
+      # @param path [String] Current path in the object structure
+      # @return [Symbol] Comparison result constant
+      def self.compare_hashes(hash1, hash2, opts, differences, path)
+        keys1 = hash1.keys
+        keys2 = hash2.keys
+
+        # Sort keys if order should be ignored (based on match options)
+        match_opts = opts[:match_opts]
+        if match_opts && match_opts[:key_order] != :strict
+          keys1 = keys1.sort_by(&:to_s)
+          keys2 = keys2.sort_by(&:to_s)
+        elsif match_opts && match_opts[:key_order] == :strict
+          # Strict mode: key order matters
+          # Check if keys are in same order
+          # Keys are different or in different order
+          # First check if it's just ordering (same keys, different order)
+          if (keys1 != keys2) && (keys1.sort_by(&:to_s) == keys2.sort_by(&:to_s))
+            # Same keys, different order - this is a key_order difference
+            key_path = path.empty? ? "(key order)" : "#{path}.(key order)"
+            add_difference(key_path, keys1, keys2,
+                           Comparison::UNEQUAL_HASH_KEY_ORDER, opts, differences)
+            return Comparison::UNEQUAL_HASH_KEY_ORDER
+          end
+        end
+
+        # Check for missing keys
+        missing_in_second = keys1 - keys2
+        missing_in_first = keys2 - keys1
+
+        missing_in_second.each do |key|
+          key_path = path.empty? ? key.to_s : "#{path}.#{key}"
+          add_difference(key_path, hash1[key], nil,
+                         Comparison::MISSING_HASH_KEY, opts, differences)
+        end
+
+        missing_in_first.each do |key|
+          key_path = path.empty? ? key.to_s : "#{path}.#{key}"
+          add_difference(key_path, nil, hash2[key],
+                         Comparison::MISSING_HASH_KEY, opts, differences)
+        end
+
+        has_missing_keys = !missing_in_first.empty? || !missing_in_second.empty?
+
+        # Compare common keys
+        common_keys = keys1 & keys2
+        all_equivalent = true
+        common_keys.each do |key|
+          key_path = path.empty? ? key.to_s : "#{path}.#{key}"
+          result = compare_objects(hash1[key], hash2[key], opts,
+                                   differences, key_path)
+          all_equivalent = false unless result == Comparison::EQUIVALENT
+        end
+
+        # Return appropriate status
+        return Comparison::MISSING_HASH_KEY if has_missing_keys && all_equivalent
+        return Comparison::UNEQUAL_HASH_VALUES unless all_equivalent
+
+        has_missing_keys ? Comparison::MISSING_HASH_KEY : Comparison::EQUIVALENT
+      end
+
+      # Compare two arrays
+      #
+      # @param arr1 [Array] First array
+      # @param arr2 [Array] Second array
+      # @param opts [Hash] Comparison options
+      # @param differences [Array] Array to append differences to
+      # @param path [String] Current path in the object structure
+      # @return [Symbol] Comparison result constant
+      def self.compare_arrays(arr1, arr2, opts, differences, path)
+        unless arr1.length == arr2.length
+          add_difference(path, arr1, arr2,
+                         Comparison::UNEQUAL_ARRAY_LENGTHS, opts,
+                         differences)
+          return Comparison::UNEQUAL_ARRAY_LENGTHS
+        end
+
+        all_equivalent = true
+        arr1.each_with_index do |elem1, index|
+          elem2 = arr2[index]
+          elem_path = "#{path}[#{index}]"
+          result = compare_objects(elem1, elem2, opts, differences,
+                                   elem_path)
+          all_equivalent = false unless result == Comparison::EQUIVALENT
+        end
+
+        all_equivalent ? Comparison::EQUIVALENT : Comparison::UNEQUAL_ARRAY_ELEMENTS
+      end
+
+      # Compare primitive values
+      #
+      # @param val1 [Object] First value
+      # @param val2 [Object] Second value
+      # @param opts [Hash] Comparison options
+      # @param differences [Array] Array to append differences to
+      # @param path [String] Current path in the object structure
+      # @return [Symbol] Comparison result constant
+      def self.compare_primitives(val1, val2, opts, differences, path)
+        if val1 == val2
+          Comparison::EQUIVALENT
+        else
+          add_difference(path, val1, val2,
+                         Comparison::UNEQUAL_PRIMITIVES, opts,
+                         differences)
+          Comparison::UNEQUAL_PRIMITIVES
+        end
+      end
+
+      # Add a Ruby object difference
+      #
+      # @param path [String] Path to the difference
+      # @param obj1 [Object] First object
+      # @param obj2 [Object] Second object
+      # @param diff_code [Symbol] Difference code
+      # @param opts [Hash] Comparison options
+      # @param differences [Array] Array to append difference to
+      def self.add_difference(path, obj1, obj2, diff_code, opts, differences)
+        return unless opts[:verbose]
+
+        differences << {
+          path: path,
+          value1: obj1,
+          value2: obj2,
+          difference: diff_code,
+        }
+      end
+    end
+  end
+end

data/lib/canon/comparison/strategies/semantic_tree_match_strategy.rb

@@ -3,6 +3,7 @@
 require_relative "base_match_strategy"
 require_relative "../../tree_diff/tree_diff_integrator"
 require_relative "../../tree_diff/operation_converter"
+require_relative "../xml_node_comparison"
 
 module Canon
   module Comparison
@@ -125,10 +126,9 @@ module Canon
         # @return [Array<String>] Preprocessed strings
         def preprocess_xml(doc1, doc2)
           # Serialize XML to string
-          # Use XmlComparator's serializer for Canon::Xml::Node
+          # Use XmlNodeComparison's serializer for Canon::Xml::Node
           xml1 = if doc1.is_a?(Canon::Xml::Node)
-                   require_relative "../xml_comparator"
-                   XmlComparator.send(:serialize_node_to_xml, doc1)
+                   XmlNodeComparison.serialize_node_to_xml(doc1)
                  elsif doc1.respond_to?(:to_xml)
                    doc1.to_xml
                  else
@@ -136,8 +136,7 @@ module Canon
                  end
 
           xml2 = if doc2.is_a?(Canon::Xml::Node)
-                   require_relative "../xml_comparator"
-                   XmlComparator.send(:serialize_node_to_xml, doc2)
+                   XmlNodeComparison.serialize_node_to_xml(doc2)
                  elsif doc2.respond_to?(:to_xml)
                    doc2.to_xml
                  else
@@ -161,12 +160,11 @@ module Canon
         # @param doc2 [Object] Second HTML document
         # @return [Array<String>] Preprocessed strings
         def preprocess_html(doc1, doc2)
-          # For Canon::Xml::Node, use XmlComparator's serializer
+          # For Canon::Xml::Node, use XmlNodeComparison's serializer
           # For XML::DocumentFragment (from parse_node_as_fragment), use to_s
           # to avoid Nokogiri auto-inserting meta tags during to_html serialization
           html1 = if doc1.is_a?(Canon::Xml::Node)
-                    require_relative "../xml_comparator"
-                    XmlComparator.send(:serialize_node_to_xml, doc1)
+                    XmlNodeComparison.serialize_node_to_xml(doc1)
                   elsif doc1.is_a?(Nokogiri::XML::DocumentFragment)
                     doc1.to_s
                   elsif doc1.respond_to?(:to_html)
@@ -176,8 +174,7 @@ module Canon
                   end
 
           html2 = if doc2.is_a?(Canon::Xml::Node)
-                    require_relative "../xml_comparator"
-                    XmlComparator.send(:serialize_node_to_xml, doc2)
+                    XmlNodeComparison.serialize_node_to_xml(doc2)
                   elsif doc2.is_a?(Nokogiri::XML::DocumentFragment)
                     doc2.to_s
                   elsif doc2.respond_to?(:to_html)

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

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+module Canon
+  module Comparison
+    module XmlComparatorHelpers
+      # Attribute comparison logic
+      # Handles comparison of attribute sets with filtering and ordering
+      class AttributeComparator
+        # Compare attribute sets between two nodes
+        #
+        # @param node1 [Object] First node
+        # @param node2 [Object] Second node
+        # @param opts [Hash] Comparison options
+        # @param differences [Array] Array to append differences to
+        # @return [Symbol] Comparison result
+        def self.compare(node1, node2, opts, differences)
+          # Get attributes using the appropriate method for each node type
+          raw_attrs1 = node1.respond_to?(:attribute_nodes) ? node1.attribute_nodes : node1.attributes
+          raw_attrs2 = node2.respond_to?(:attribute_nodes) ? node2.attribute_nodes : node2.attributes
+
+          attrs1 = XmlComparatorHelpers::AttributeFilter.filter(raw_attrs1,
+                                                                opts)
+          attrs2 = XmlComparatorHelpers::AttributeFilter.filter(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
+            compare_strict_order(node1, node2, attrs1, attrs2, keys1, keys2, opts,
+                                 differences)
+          else
+            compare_flexible_order(node1, node2, attrs1, attrs2, keys1, keys2, opts,
+                                   differences)
+          end
+        end
+
+        # Compare with strict attribute ordering
+        #
+        # @param node1 [Object] First node
+        # @param node2 [Object] Second node
+        # @param attrs1 [Hash] First node's attributes
+        # @param attrs2 [Hash] Second node's attributes
+        # @param keys1 [Array<String>] First node's attribute keys
+        # @param keys2 [Array<String>] Second node's attribute keys
+        # @param opts [Hash] Comparison options
+        # @param differences [Array] Array to append differences to
+        # @return [Symbol] Comparison result
+        def self.compare_strict_order(node1, node2, attrs1, attrs2, keys1, keys2, opts,
+differences)
+          if keys1 != keys2
+            # Keys are different or in different order
+            if keys1.sort == keys2.sort
+              # Same keys, different order - attribute_order difference
+              add_attribute_difference(n1: node1, n2: node2,
+                                       diff1: Comparison::UNEQUAL_ATTRIBUTES,
+                                       diff2: Comparison::UNEQUAL_ATTRIBUTES,
+                                       dimension: :attribute_order,
+                                       opts: opts,
+                                       differences: differences)
+              return Comparison::UNEQUAL_ATTRIBUTES
+            else
+              # Different keys - attribute_presence difference
+              add_attribute_difference(n1: node1, n2: node2,
+                                       diff1: Comparison::MISSING_ATTRIBUTE,
+                                       diff2: Comparison::MISSING_ATTRIBUTE,
+                                       dimension: :attribute_presence,
+                                       opts: opts,
+                                       differences: differences)
+              return Comparison::MISSING_ATTRIBUTE
+            end
+          end
+
+          # Order matches, check values
+          compare_attribute_values(node1, node2, attrs1, attrs2, opts,
+                                   differences)
+        end
+
+        # Compare with flexible attribute ordering
+        #
+        # @param node1 [Object] First node
+        # @param node2 [Object] Second node
+        # @param attrs1 [Hash] First node's attributes
+        # @param attrs2 [Hash] Second node's attributes
+        # @param keys1 [Array<String>] First node's attribute keys
+        # @param keys2 [Array<String>] Second node's attribute keys
+        # @param opts [Hash] Comparison options
+        # @param differences [Array] Array to append differences to
+        # @return [Symbol] Comparison result
+        def self.compare_flexible_order(node1, node2, attrs1, attrs2, keys1, keys2, opts,
+differences)
+          # Check if order differs (but keys are the same) - track as informative
+          if keys1 != keys2 && keys1.sort == keys2.sort && opts[:verbose]
+            add_attribute_difference(n1: node1, n2: node2,
+                                     diff1: Comparison::UNEQUAL_ATTRIBUTES,
+                                     diff2: Comparison::UNEQUAL_ATTRIBUTES,
+                                     dimension: :attribute_order,
+                                     opts: opts,
+                                     differences: 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_attribute_difference(n1: node1, n2: node2,
+                                     diff1: Comparison::MISSING_ATTRIBUTE,
+                                     diff2: Comparison::MISSING_ATTRIBUTE,
+                                     dimension: :attribute_presence,
+                                     opts: opts,
+                                     differences: differences)
+            return Comparison::MISSING_ATTRIBUTE
+          end
+
+          compare_attribute_values(node1, node2, attrs1, attrs2, opts,
+                                   differences)
+        end
+
+        # Compare attribute values
+        #
+        # @param node1 [Object] First node
+        # @param node2 [Object] Second node
+        # @param attrs1 [Hash] First node's attributes
+        # @param attrs2 [Hash] Second node's attributes
+        # @param opts [Hash] Comparison options
+        # @param differences [Array] Array to append differences to
+        # @return [Symbol] Comparison result
+        def self.compare_attribute_values(node1, node2, attrs1, attrs2, opts,
+differences)
+          attrs1.each do |name, value|
+            unless attrs2[name] == value
+              add_attribute_difference(n1: node1, n2: node2,
+                                       diff1: Comparison::UNEQUAL_ATTRIBUTES,
+                                       diff2: Comparison::UNEQUAL_ATTRIBUTES,
+                                       dimension: :attribute_values,
+                                       opts: opts,
+                                       differences: differences)
+              return Comparison::UNEQUAL_ATTRIBUTES
+            end
+          end
+
+          Comparison::EQUIVALENT
+        end
+
+        # Add an attribute difference
+        #
+        # @param n1 [Object] First node
+        # @param n2 [Object] Second node
+        # @param diff1 [String] Difference type for node1
+        # @param diff2 [String] Difference type for node2
+        # @param dimension [Symbol] The match dimension
+        # @param opts [Hash] Options
+        # @param differences [Array] Array to append difference to
+        def self.add_attribute_difference(n1:, n2:, diff1:, diff2:,
+dimension:, differences:, **opts)
+          # Import DiffNodeBuilder to avoid circular dependency
+          require_relative "diff_node_builder"
+
+          diff_node = Canon::Comparison::DiffNodeBuilder.build(
+            node1: n1,
+            node2: n2,
+            diff1: diff1,
+            diff2: diff2,
+            dimension: dimension,
+            **opts,
+          )
+          differences << diff_node if diff_node
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+require_relative "../match_options"
+
+module Canon
+  module Comparison
+    module XmlComparatorHelpers
+      # Attribute filtering logic
+      # Handles filtering of attributes based on options and match settings
+      class AttributeFilter
+        # Filter attributes based on options
+        #
+        # @param attributes [Array, Hash] Raw attributes
+        # @param opts [Hash] Comparison options
+        # @return [Hash] Filtered attributes
+        def self.filter(attributes, opts)
+          filtered = {}
+          match_opts = opts[:match_opts]
+
+          # Handle Canon::Xml::Node attribute format (array of AttributeNode)
+          if attributes.is_a?(Array)
+            filter_array_attributes(attributes, opts, match_opts, filtered)
+          else
+            # Handle Nokogiri and Moxml attribute formats (Hash-like)
+            filter_hash_attributes(attributes, opts, match_opts, filtered)
+          end
+
+          filtered
+        end
+
+        # Filter array-format attributes (Canon::Xml::Node)
+        #
+        # @param attributes [Array] Array of AttributeNode objects
+        # @param opts [Hash] Comparison options
+        # @param match_opts [Hash] Resolved match options
+        # @param filtered [Hash] Output hash to populate
+        def self.filter_array_attributes(attributes, opts, match_opts, filtered)
+          attributes.each do |attr|
+            name = attr.name
+            value = attr.value
+
+            # Skip namespace declarations - they're handled separately
+            next if namespace_declaration?(name)
+
+            # Skip if attribute name should be ignored
+            next if ignore_by_name?(name, opts)
+
+            # Skip if attribute content should be ignored
+            next if ignore_by_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
+
+        # Filter hash-format attributes (Nokogiri/Moxml)
+        #
+        # @param attributes [Hash] Hash-like attributes
+        # @param opts [Hash] Comparison options
+        # @param match_opts [Hash] Resolved match options
+        # @param filtered [Hash] Output hash to populate
+        def self.filter_hash_attributes(attributes, opts, match_opts, filtered)
+          attributes.each do |key, val|
+            # Normalize key and value
+            name, value = normalize_attribute_pair(key, val)
+
+            # Skip namespace declarations - they're handled separately
+            next if namespace_declaration?(name)
+
+            # Skip if attribute name should be ignored
+            next if ignore_by_name?(name, opts)
+
+            # Skip if attribute content should be ignored
+            next if ignore_by_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
+
+        # Normalize attribute key-value pair from different formats
+        #
+        # @param key [Object] Attribute key (String or Attribute object)
+        # @param val [Object] Attribute value
+        # @return [Array<String, String>] Normalized [name, value] pair
+        def self.normalize_attribute_pair(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
+
+          [name, value]
+        end
+
+        # Check if attribute should be ignored by name
+        #
+        # @param name [String] Attribute name
+        # @param opts [Hash] Comparison options
+        # @return [Boolean] true if should ignore
+        def self.ignore_by_name?(name, opts)
+          opts[:ignore_attrs_by_name].any? { |pattern| name.include?(pattern) }
+        end
+
+        # Check if attribute should be ignored by content
+        #
+        # @param value [String] Attribute value
+        # @param opts [Hash] Comparison options
+        # @return [Boolean] true if should ignore
+        def self.ignore_by_content?(value, opts)
+          opts[:ignore_attr_content].any? do |pattern|
+            value.to_s.include?(pattern)
+          end
+        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 self.namespace_declaration?(attr_name)
+          attr_name == "xmlns" || attr_name.start_with?("xmlns:")
+        end
+      end
+    end
+  end
+end