canon 0.2.11 → 0.2.12

data/lib/canon/comparison/dimensions/attribute_values_dimension.rb

@@ -1,167 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "base_dimension"
-require_relative "../match_options"
-
-module Canon
-  module Comparison
-    module Dimensions
-      # Attribute values dimension
-      #
-      # Handles comparison of attribute values.
-      # Supports :strict, :strip, :compact, :normalize, and :ignore behaviors.
-      #
-      # Behaviors:
-      # - :strict - Exact attribute value comparison
-      # - :strip - Compare with leading/trailing whitespace removed
-      # - :compact - Compare with internal whitespace collapsed
-      # - :normalize - Compare with whitespace stripped and collapsed
-      # - :ignore - Skip attribute value comparison
-      class AttributeValuesDimension < BaseDimension
-        # Extract attribute values from a node
-        #
-        # Returns a hash of attribute name to value.
-        #
-        # @param node [Moxml::Node, Nokogiri::XML::Node] Node to extract from
-        # @return [Hash] Attribute name to value mapping
-        def extract_data(node)
-          return {} unless node
-
-          if Canon::XmlBackend.nokogiri?
-            extract_from_nokogiri(node)
-          else
-            extract_from_moxml(node)
-          end
-        end
-
-        # Strict attribute value comparison
-        #
-        # @param attrs1 [Hash] First attributes hash
-        # @param attrs2 [Hash] Second attributes hash
-        # @return [Boolean] true if all attribute values are exactly equal
-        def compare_strict(attrs1, attrs2)
-          # Get all unique attribute names
-          all_keys = (attrs1.keys | attrs2.keys)
-
-          all_keys.all? do |key|
-            attrs1[key].to_s == attrs2[key].to_s
-          end
-        end
-
-        # Strip comparison
-        #
-        # Compare with leading/trailing whitespace removed.
-        #
-        # @param attrs1 [Hash] First attributes hash
-        # @param attrs2 [Hash] Second attributes hash
-        # @return [Boolean] true if stripped values are equal
-        def compare_strip(attrs1, attrs2)
-          all_keys = (attrs1.keys | attrs2.keys)
-
-          all_keys.all? do |key|
-            attrs1[key].to_s.strip == attrs2[key].to_s.strip
-          end
-        end
-
-        # Compact comparison
-        #
-        # Compare with internal whitespace collapsed.
-        #
-        # @param attrs1 [Hash] First attributes hash
-        # @param attrs2 [Hash] Second attributes hash
-        # @return [Boolean] true if compacted values are equal
-        def compare_compact(attrs1, attrs2)
-          all_keys = (attrs1.keys | attrs2.keys)
-
-          all_keys.all? do |key|
-            compact_whitespace(attrs1[key].to_s) == compact_whitespace(attrs2[key].to_s)
-          end
-        end
-
-        # Normalized comparison
-        #
-        # Compare with whitespace stripped and collapsed.
-        #
-        # @param attrs1 [Hash] First attributes hash
-        # @param attrs2 [Hash] Second attributes hash
-        # @return [Boolean] true if normalized values are equal
-        def compare_normalize(attrs1, attrs2)
-          all_keys = (attrs1.keys | attrs2.keys)
-
-          all_keys.all? do |key|
-            normalize_text(attrs1[key].to_s) == normalize_text(attrs2[key].to_s)
-          end
-        end
-
-        # Compare with custom behavior
-        #
-        # Supports the extended behaviors for attribute values.
-        #
-        # @param data1 [Object] First data
-        # @param data2 [Object] Second data
-        # @param behavior [Symbol] Comparison behavior
-        # @return [Boolean] true if data matches according to behavior
-        def compare(data1, data2, behavior)
-          case behavior
-          when :strip
-            compare_strip(data1, data2)
-          when :compact
-            compare_compact(data1, data2)
-          else
-            super
-          end
-        end
-
-        private
-
-        # Extract attributes from Moxml node
-        #
-        # @param node [Moxml::Node] Moxml node
-        # @return [Hash] Attribute name to value mapping
-        def extract_from_moxml(node)
-          return {} unless node.node_type == :element
-
-          attrs = {}
-          node.attributes.each do |attr|
-            attrs[attr.name] = attr.value
-          end
-          attrs
-        end
-
-        # Extract attributes from Nokogiri node
-        #
-        # @param node [Nokogiri::XML::Node] Nokogiri node
-        # @return [Hash] Attribute name to value mapping
-        def extract_from_nokogiri(node)
-          return {} unless node.node_type == Nokogiri::XML::Node::ELEMENT_NODE
-
-          attrs = {}
-          node.attribute_nodes.each do |attr|
-            attrs[attr.name] = attr.value
-          end
-          attrs
-        end
-
-        # Compact whitespace
-        #
-        # Collapses internal whitespace without trimming.
-        #
-        # @param text [String] Text to compact
-        # @return [String] Compacted text
-        def compact_whitespace(text)
-          text.gsub(/[\p{Space}\u00a0]+/, " ")
-        end
-
-        # Normalize text
-        #
-        # Collapses and trims whitespace.
-        #
-        # @param text [String] Text to normalize
-        # @return [String] Normalized text
-        def normalize_text(text)
-          MatchOptions.normalize_text(text)
-        end
-      end
-    end
-  end
-end

data/lib/canon/comparison/dimensions/base_dimension.rb

@@ -1,107 +0,0 @@
-# frozen_string_literal: true
-
-module Canon
-  module Comparison
-    module Dimensions
-      # Base class for comparison dimensions
-      #
-      # A dimension represents "WHAT to compare" - a specific aspect of a document
-      # that can be compared (e.g., text content, attributes, comments).
-      #
-      # Each dimension knows how to:
-      # - Extract relevant data from a node
-      # - Compare data according to a behavior (:strict, :normalize, :ignore)
-      #
-      # Subclasses must implement:
-      # - extract_data(node) - Extract relevant data from a node
-      # - compare_strict(data1, data2) - Strict comparison
-      # - compare_normalize(data1, data2) - Normalized comparison (optional)
-      #
-      # @abstract Subclass and implement abstract methods
-      class BaseDimension
-        # Behavior constants
-        STRICT = :strict
-        NORMALIZE = :normalize
-        IGNORE = :ignore
-
-        # Get the dimension name
-        #
-        # @return [Symbol] Dimension name
-        def dimension_name
-          @dimension_name ||= self.class.name.split("::").last.gsub(
-            /Dimension$/, ""
-          ).downcase.to_sym
-        end
-
-        # Compare extracted data according to behavior
-        #
-        # @param data1 [Object] First data
-        # @param data2 [Object] Second data
-        # @param behavior [Symbol] Comparison behavior (:strict, :normalize, :ignore)
-        # @return [Boolean] true if data matches according to behavior
-        def compare(data1, data2, behavior)
-          case behavior
-          when STRICT
-            compare_strict(data1, data2)
-          when NORMALIZE
-            compare_normalize(data1, data2)
-          when IGNORE
-            true
-          else
-            raise Error, "Unknown behavior: #{behavior}"
-          end
-        end
-
-        # Check if two nodes are equivalent for this dimension
-        #
-        # @param node1 [Object] First node
-        # @param node2 [Object] Second node
-        # @param behavior [Symbol] Comparison behavior
-        # @return [Boolean] true if nodes match for this dimension
-        def equivalent?(node1, node2, behavior)
-          data1 = extract_data(node1)
-          data2 = extract_data(node2)
-          compare(data1, data2, behavior)
-        end
-
-        # Extract data from a node
-        #
-        # @param node [Object] Node to extract data from
-        # @return [Object] Extracted data
-        # @abstract Subclass must implement
-        def extract_data(node)
-          raise NotImplementedError, "#{self.class} must implement extract_data"
-        end
-
-        # Strict comparison
-        #
-        # @param data1 [Object] First data
-        # @param data2 [Object] Second data
-        # @return [Boolean] true if data matches strictly
-        # @abstract Subclass must implement
-        def compare_strict(data1, data2)
-          raise NotImplementedError,
-                "#{self.class} must implement compare_strict"
-        end
-
-        # Normalized comparison
-        #
-        # @param data1 [Object] First data
-        # @param data2 [Object] Second data
-        # @return [Boolean] true if data matches after normalization
-        def compare_normalize(data1, data2)
-          # Default implementation: delegate to strict comparison
-          compare_strict(data1, data2)
-        end
-
-        # Check if this dimension supports normalization
-        #
-        # @return [Boolean] true if normalization is supported
-        def supports_normalization?
-          # Check if compare_normalize is overridden (not the default implementation)
-          method(:compare_normalize).owner != BaseDimension
-        end
-      end
-    end
-  end
-end

data/lib/canon/comparison/dimensions/comments_dimension.rb

@@ -1,117 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "base_dimension"
-
-module Canon
-  module Comparison
-    module Dimensions
-      # Comments dimension
-      #
-      # Handles comparison of comment nodes.
-      # Supports :strict and :ignore behaviors.
-      #
-      # Behaviors:
-      # - :strict - Exact comment comparison including whitespace
-      # - :ignore - Skip comment comparison
-      class CommentsDimension < BaseDimension
-        # Extract comments from a node
-        #
-        # @param node [Moxml::Node, Nokogiri::XML::Node] Node to extract from
-        # @return [Array<String>] Array of comment strings
-        def extract_data(node)
-          return [] unless node
-
-          if Canon::XmlBackend.nokogiri?
-            extract_from_nokogiri(node)
-          else
-            extract_from_moxml(node)
-          end
-        end
-
-        # Strict comment comparison
-        #
-        # @param comments1 [Array<String>] First comments array
-        # @param comments2 [Array<String>] Second comments array
-        # @return [Boolean] true if comments are exactly equal
-        def compare_strict(comments1, comments2) # rubocop:disable Naming/PredicateMethod
-          comments1 == comments2
-        end
-
-        # Normalized comment comparison
-        #
-        # For comments, normalized comparison collapses whitespace in each comment.
-        #
-        # @param comments1 [Array<String>] First comments array
-        # @param comments2 [Array<String>] Second comments array
-        # @return [Boolean] true if normalized comments are equal
-        def compare_normalize(comments1, comments2) # rubocop:disable Naming/PredicateMethod
-          normalize_comments(comments1) == normalize_comments(comments2)
-        end
-
-        private
-
-        # Extract comments from Moxml node
-        #
-        # @param node [Moxml::Node] Moxml node
-        # @return [Array<String>] Array of comment strings
-        def extract_from_moxml(node)
-          comments = []
-
-          # If node itself is a comment
-          if node.node_type == :comment
-            comments << node.content
-          end
-
-          # Extract child comments
-          node.children.each do |child|
-            comments << child.content if child.node_type == :comment
-          end
-
-          comments
-        end
-
-        # Extract comments from Nokogiri node
-        #
-        # @param node [Nokogiri::XML::Node] Nokogiri node
-        # @return [Array<String>] Array of comment strings
-        def extract_from_nokogiri(node)
-          comments = []
-
-          # If node itself is a comment
-          if node.node_type == Nokogiri::XML::Node::COMMENT_NODE
-            comments << node.content
-          end
-
-          # Extract child comments
-          node.children.each do |child|
-            if child.node_type == Nokogiri::XML::Node::COMMENT_NODE
-              comments << child.content
-            end
-          end
-
-          comments
-        end
-
-        # Normalize comments by collapsing whitespace
-        #
-        # @param comments [Array<String>] Comments to normalize
-        # @return [Array<String>] Normalized comments
-        def normalize_comments(comments)
-          comments.map { |c| normalize_text(c) }
-        end
-
-        # Normalize text by collapsing whitespace
-        #
-        # @param text [String, nil] Text to normalize
-        # @return [String] Normalized text
-        def normalize_text(text)
-          return "" if text.nil?
-
-          text.to_s
-            .gsub(/[\p{Space}\u00a0]+/, " ")
-            .strip
-        end
-      end
-    end
-  end
-end

data/lib/canon/comparison/dimensions/element_position_dimension.rb

@@ -1,86 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "base_dimension"
-
-module Canon
-  module Comparison
-    module Dimensions
-      # Element position dimension
-      #
-      # Handles comparison of element positions within their parent.
-      # Supports :strict and :ignore behaviors.
-      #
-      # Behaviors:
-      # - :strict - Elements must appear in the same position (index)
-      # - :ignore - Element position doesn't matter
-      class ElementPositionDimension < BaseDimension
-        # Extract element position from a node
-        #
-        # Returns the index of this node among its siblings of the same type.
-        #
-        # @param node [Moxml::Node, Nokogiri::XML::Node] Node to extract from
-        # @return [Integer] Position index (0-based)
-        def extract_data(node)
-          return 0 unless node
-
-          if Canon::XmlBackend.nokogiri?
-            extract_from_nokogiri(node)
-          else
-            extract_from_moxml(node)
-          end
-        end
-
-        # Strict element position comparison
-        #
-        # @param pos1 [Integer] First position
-        # @param pos2 [Integer] Second position
-        # @return [Boolean] true if positions are equal
-        def compare_strict(pos1, pos2) # rubocop:disable Naming/PredicateMethod
-          pos1 == pos2
-        end
-
-        private
-
-        # Extract position from Moxml node
-        #
-        # @param node [Moxml::Node] Moxml node
-        # @return [Integer] Position index
-        def extract_from_moxml(node)
-          return 0 unless node.parent
-
-          # Find position among siblings of the same element name
-          siblings = node.parent.children
-          node.name
-
-          siblings.each_with_index do |sibling, index|
-            if sibling == node
-              return index
-            end
-          end
-
-          0
-        end
-
-        # Extract position from Nokogiri node
-        #
-        # @param node [Nokogiri::XML::Node] Nokogiri node
-        # @return [Integer] Position index
-        def extract_from_nokogiri(node)
-          return 0 unless node.parent
-
-          # Find position among siblings
-          siblings = node.parent.children
-          node.name
-
-          siblings.each_with_index do |sibling, index|
-            if sibling == node
-              return index
-            end
-          end
-
-          0
-        end
-      end
-    end
-  end
-end

data/lib/canon/comparison/dimensions/structural_whitespace_dimension.rb

@@ -1,115 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "base_dimension"
-require_relative "../match_options"
-
-module Canon
-  module Comparison
-    module Dimensions
-      # Structural whitespace dimension
-      #
-      # Handles comparison of structural whitespace (whitespace between elements).
-      # Supports :strict, :normalize, and :ignore behaviors.
-      #
-      # Behaviors:
-      # - :strict - Exact whitespace comparison
-      # - :normalize - Collapse whitespace and compare
-      # - :ignore - Skip structural whitespace comparison
-      class StructuralWhitespaceDimension < BaseDimension
-        # Extract structural whitespace from a node
-        #
-        # Returns whitespace text nodes that are between elements (structural).
-        #
-        # @param node [Moxml::Node, Nokogiri::XML::Node] Node to extract from
-        # @return [Array<String>] Array of structural whitespace strings
-        def extract_data(node)
-          return [] unless node
-
-          if Canon::XmlBackend.nokogiri?
-            extract_from_nokogiri(node)
-          else
-            extract_from_moxml(node)
-          end
-        end
-
-        # Strict structural whitespace comparison
-        #
-        # @param ws1 [Array<String>] First whitespace array
-        # @param ws2 [Array<String>] Second whitespace array
-        # @return [Boolean] true if structural whitespace is exactly equal
-        def compare_strict(ws1, ws2) # rubocop:disable Naming/PredicateMethod
-          ws1 == ws2
-        end
-
-        # Normalized structural whitespace comparison
-        #
-        # Collapses whitespace in each entry and compares.
-        #
-        # @param ws1 [Array<String>] First whitespace array
-        # @param ws2 [Array<String>] Second whitespace array
-        # @return [Boolean] true if normalized structural whitespace is equal
-        def compare_normalize(ws1, ws2) # rubocop:disable Naming/PredicateMethod
-          normalize_whitespace(ws1) == normalize_whitespace(ws2)
-        end
-
-        private
-
-        # Extract structural whitespace from Moxml node
-        #
-        # @param node [Moxml::Node] Moxml node
-        # @return [Array<String>] Array of structural whitespace strings
-        def extract_from_moxml(node)
-          whitespace = []
-
-          node.children.each do |child|
-            if child.node_type == :text
-              text = child.content.strip
-              # Check if this is purely whitespace (structural)
-              if text.empty? || child.content =~ /\A\s*\z/
-                whitespace << child.content
-              end
-            end
-          end
-
-          whitespace
-        end
-
-        # Extract structural whitespace from Nokogiri node
-        #
-        # @param node [Nokogiri::XML::Node] Nokogiri node
-        # @return [Array<String>] Array of structural whitespace strings
-        def extract_from_nokogiri(node)
-          whitespace = []
-
-          node.children.each do |child|
-            if child.node_type == Nokogiri::XML::Node::TEXT_NODE
-              text = child.content.strip
-              # Check if this is purely whitespace (structural)
-              if text.empty? || child.content =~ /\A\s*\z/
-                whitespace << child.content
-              end
-            end
-          end
-
-          whitespace
-        end
-
-        # Normalize whitespace array
-        #
-        # @param whitespace [Array<String>] Whitespace strings
-        # @return [Array<String>] Normalized whitespace strings
-        def normalize_whitespace(whitespace)
-          whitespace.map { |ws| normalize_text(ws) }
-        end
-
-        # Normalize text
-        #
-        # @param text [String, nil] Text to normalize
-        # @return [String] Normalized text
-        def normalize_text(text)
-          MatchOptions.normalize_text(text)
-        end
-      end
-    end
-  end
-end

data/lib/canon/comparison/dimensions/text_content_dimension.rb

@@ -1,102 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "base_dimension"
-require_relative "../match_options"
-
-module Canon
-  module Comparison
-    module Dimensions
-      # Text content dimension
-      #
-      # Handles comparison of text content in nodes.
-      # Supports :strict, :normalize, and :ignore behaviors.
-      #
-      # Behaviors:
-      # - :strict - Exact text comparison including whitespace
-      # - :normalize - Collapse whitespace and compare
-      # - :ignore - Skip text content comparison
-      class TextContentDimension < BaseDimension
-        # Extract text content from a node
-        #
-        # @param node [Moxml::Node, Nokogiri::XML::Node] Node to extract from
-        # @return [String, nil] Text content or nil if not a text node
-        def extract_data(node)
-          return nil unless node
-
-          if Canon::XmlBackend.nokogiri?
-            extract_from_nokogiri(node)
-          else
-            extract_from_moxml(node)
-          end
-        end
-
-        # Strict text comparison
-        #
-        # @param text1 [String, nil] First text
-        # @param text2 [String, nil] Second text
-        # @return [Boolean] true if texts are exactly equal
-        def compare_strict(text1, text2) # rubocop:disable Naming/PredicateMethod
-          text1.to_s == text2.to_s
-        end
-
-        # Normalized text comparison
-        #
-        # Collapses whitespace and compares.
-        # Two whitespace-only strings that both normalize to empty are equivalent.
-        #
-        # @param text1 [String, nil] First text
-        # @param text2 [String, nil] Second text
-        # @return [Boolean] true if normalized texts are equal
-        def compare_normalize(text1, text2) # rubocop:disable Naming/PredicateMethod
-          normalized1 = normalize_text(text1)
-          normalized2 = normalize_text(text2)
-
-          # Both empty after normalization = equivalent
-          # This handles whitespace-only text nodes that normalize to empty
-          return true if normalized1.empty? && normalized2.empty?
-
-          normalized1 == normalized2
-        end
-
-        private
-
-        # Extract text from Moxml node
-        #
-        # @param node [Moxml::Node] Moxml node
-        # @return [String, nil] Text content
-        def extract_from_moxml(node)
-          case node.node_type
-          when :text, :cdata
-            node.content
-          when :element
-            # For element nodes, extract concatenated text from children
-            node.text
-          end
-        end
-
-        # Extract text from Nokogiri node
-        #
-        # @param node [Nokogiri::XML::Node] Nokogiri node
-        # @return [String, nil] Text content
-        def extract_from_nokogiri(node)
-          case node.node_type
-          when Nokogiri::XML::Node::TEXT_NODE, Nokogiri::XML::Node::CDATA_SECTION_NODE
-            node.content
-          when Nokogiri::XML::Node::ELEMENT_NODE
-            node.content
-          end
-        end
-
-        # Normalize text by collapsing whitespace
-        #
-        # Uses MatchOptions.normalize_text for consistency.
-        #
-        # @param text [String, nil] Text to normalize
-        # @return [String] Normalized text
-        def normalize_text(text)
-          MatchOptions.normalize_text(text)
-        end
-      end
-    end
-  end
-end