canon 0.1.6 → 0.1.7

data/lib/canon/comparison/match_options.rb

@@ -15,11 +15,12 @@ module Canon
     # Wrapper class for resolved match options
     # Provides convenient methods for accessing behaviors by dimension
     class ResolvedMatchOptions
-      attr_reader :options, :format
+      attr_reader :options, :format, :compare_profile
 
-      def initialize(options, format:)
+      def initialize(options, format:, compare_profile: nil)
         @options = options
         @format = format
+        @compare_profile = compare_profile
       end
 
       # Get the behavior for a specific dimension
@@ -35,6 +36,12 @@ module Canon
         @options[:preprocessing]
       end
 
+      # Check if semantic diff is enabled
+      # @return [Boolean] true if semantic diff is enabled
+      def semantic_diff?
+        @options[:semantic_diff] == true
+      end
+
       def to_h
         @options.dup
       end
@@ -116,8 +123,13 @@ module Canon
           text_content
           structural_whitespace
           attribute_presence
+          attribute_order
           attribute_values
+          element_position
           comments
+          element_structure
+          element_position
+          element_hierarchy
         ].freeze
 
         # Format-specific defaults
@@ -127,7 +139,9 @@ module Canon
             text_content: :normalize,
             structural_whitespace: :normalize,
             attribute_presence: :strict,
+            attribute_order: :ignore,
             attribute_values: :strict,
+            element_position: :ignore,
             comments: :ignore,
           },
           xml: {
@@ -135,7 +149,9 @@ module Canon
             text_content: :strict,
             structural_whitespace: :strict,
             attribute_presence: :strict,
+            attribute_order: :ignore,
             attribute_values: :strict,
+            element_position: :strict,
             comments: :strict,
           },
         }.freeze
@@ -148,7 +164,9 @@ module Canon
             text_content: :strict,
             structural_whitespace: :strict,
             attribute_presence: :strict,
+            attribute_order: :strict,
             attribute_values: :strict,
+            element_position: :strict,
             comments: :strict,
           },
 
@@ -159,7 +177,9 @@ module Canon
             text_content: :normalize,
             structural_whitespace: :normalize,
             attribute_presence: :strict,
+            attribute_order: :strict,
             attribute_values: :strict,
+            element_position: :strict,
             comments: :ignore,
           },
 
@@ -170,7 +190,9 @@ module Canon
             text_content: :normalize,
             structural_whitespace: :normalize,
             attribute_presence: :strict,
+            attribute_order: :strict,
             attribute_values: :normalize,
+            element_position: :ignore,
             comments: :ignore,
           },
 
@@ -180,7 +202,9 @@ module Canon
             text_content: :normalize,
             structural_whitespace: :normalize,
             attribute_presence: :strict,
+            attribute_order: :strict,
             attribute_values: :strict,
+            element_position: :ignore,
             comments: :ignore,
           },
 
@@ -191,7 +215,9 @@ module Canon
             text_content: :normalize,
             structural_whitespace: :ignore,
             attribute_presence: :strict,
+            attribute_order: :ignore,
             attribute_values: :normalize,
+            element_position: :ignore,
             comments: :ignore,
           },
 
@@ -201,7 +227,9 @@ module Canon
             text_content: :normalize,
             structural_whitespace: :ignore,
             attribute_presence: :strict,
+            attribute_order: :ignore,
             attribute_values: :normalize,
+            element_position: :ignore,
             comments: :ignore,
           },
         }.freeze
@@ -293,9 +321,19 @@ module Canon
 
           # Validate match options
           def validate_match_options!(match_options)
+            # Special options that don't need validation as dimensions
+            special_options = %i[
+              preprocessing
+              semantic_diff
+              similarity_threshold
+              hash_matching
+              similarity_matching
+              propagation
+            ]
+
             match_options.each do |dimension, behavior|
-              # Skip preprocessing as it's validated separately
-              next if dimension == :preprocessing
+              # Skip special options (validated elsewhere or passed through)
+              next if special_options.include?(dimension)
 
               unless MATCH_DIMENSIONS.include?(dimension)
                 raise Canon::Error,

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

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Canon
+  module Comparison
+    module Strategies
+      # Abstract base class for match strategies
+      #
+      # All match strategies must inherit from this class and implement:
+      # - match(doc1, doc2) → Array<DiffNode>
+      # - preprocess_for_display(doc1, doc2) → [String, String]
+      #
+      # This provides a common interface for different matching algorithms,
+      # enabling the Strategy Pattern for extensible comparison methods.
+      #
+      # @example Create a custom match strategy
+      #   class MyMatchStrategy < BaseMatchStrategy
+      #     def match(doc1, doc2)
+      #       # Custom matching logic
+      #       # Must return Array<Canon::Diff::DiffNode>
+      #     end
+      #
+      #     def preprocess_for_display(doc1, doc2)
+      #       # Format documents for diff display
+      #       # Must return [String, String]
+      #     end
+      #   end
+      #
+      class BaseMatchStrategy
+        attr_reader :format, :match_options
+
+        # Initialize strategy
+        #
+        # @param format [Symbol] Document format (:xml, :html, :json, :yaml)
+        # @param match_options [Hash] Match options for comparison
+        def initialize(format:, match_options:)
+          @format = format
+          @match_options = match_options
+        end
+
+        # Perform matching and return DiffNodes
+        #
+        # This is the core method that implements the matching algorithm.
+        # All strategies must implement this to produce DiffNodes that
+        # flow through the standard diff rendering pipeline.
+        #
+        # @param doc1 [Object] First document
+        # @param doc2 [Object] Second document
+        # @return [Array<Canon::Diff::DiffNode>] Array of differences
+        # @raise [NotImplementedError] If not implemented by subclass
+        def match(doc1, doc2)
+          raise NotImplementedError,
+                "#{self.class} must implement #match(doc1, doc2)"
+        end
+
+        # Preprocess documents for display in diff output
+        #
+        # This method formats the documents into strings suitable for
+        # line-by-line diff display. The format must be consistent across
+        # all strategies for the same format to ensure the diff rendering
+        # pipeline produces correct output.
+        #
+        # @param doc1 [Object] First document
+        # @param doc2 [Object] Second document
+        # @return [Array<String>] Preprocessed [doc1_string, doc2_string]
+        # @raise [NotImplementedError] If not implemented by subclass
+        def preprocess_for_display(doc1, doc2)
+          raise NotImplementedError,
+                "#{self.class} must implement #preprocess_for_display(doc1, doc2)"
+        end
+
+        # Optional metadata to include in ComparisonResult
+        #
+        # Subclasses can override this to provide algorithm-specific
+        # metadata such as statistics, configuration, etc.
+        #
+        # @return [Hash] Additional metadata
+        def metadata
+          {}
+        end
+
+        # Algorithm name derived from class name
+        #
+        # Automatically generates algorithm identifier from class name.
+        # For example:
+        # - DomMatchStrategy → :dom
+        # - SemanticTreeMatchStrategy → :semantic_tree
+        #
+        # @return [Symbol] Algorithm identifier
+        def algorithm_name
+          self.class.name.split("::").last
+            .gsub("MatchStrategy", "")
+            .gsub(/([A-Z])/, '_\1')
+            .downcase[1..]
+            .to_sym
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require_relative "base_match_strategy"
+
+module Canon
+  module Comparison
+    module Strategies
+      # Factory for creating match strategies
+      #
+      # Selects the appropriate match strategy based on match options.
+      # This provides a single point for strategy instantiation and enables
+      # easy extension with new matching algorithms.
+      #
+      # @example Create a strategy
+      #   strategy = MatchStrategyFactory.create(
+      #     format: :xml,
+      #     match_options: { semantic_diff: true }
+      #   )
+      #   differences = strategy.match(doc1, doc2)
+      #
+      class MatchStrategyFactory
+        # Create appropriate match strategy
+        #
+        # Examines match options to determine which strategy to use:
+        # - If semantic_diff is enabled: SemanticTreeMatchStrategy
+        # - Otherwise (default): DomMatchStrategy
+        #
+        # Future strategies can be added here by checking additional
+        # options and returning the appropriate strategy class.
+        #
+        # @param format [Symbol] Document format (:xml, :html, :json, :yaml)
+        # @param match_options [Hash] Match options
+        # @option match_options [Boolean] :semantic_diff Use semantic tree matching
+        # @return [BaseMatchStrategy] Instantiated strategy
+        #
+        # @example DOM matching (default)
+        #   strategy = MatchStrategyFactory.create(
+        #     format: :xml,
+        #     match_options: {}
+        #   )
+        #   # Returns DomMatchStrategy
+        #
+        # @example Semantic tree matching
+        #   strategy = MatchStrategyFactory.create(
+        #     format: :xml,
+        #     match_options: { semantic_diff: true }
+        #   )
+        #   # Returns SemanticTreeMatchStrategy
+        #
+        def self.create(format:, match_options:)
+          # Check for semantic diff option
+          if match_options[:semantic_diff]
+            require_relative "semantic_tree_match_strategy"
+            SemanticTreeMatchStrategy.new(format: format,
+                                          match_options: match_options)
+          else
+            # Default to DOM matching
+            require_relative "dom_match_strategy"
+            DomMatchStrategy.new(format: format, match_options: match_options)
+          end
+
+          # Future: Add more strategies here
+          # Example:
+          # elsif match_options[:hybrid_diff]
+          #   require_relative "hybrid_match_strategy"
+          #   HybridMatchStrategy.new(format, match_options)
+          # elsif match_options[:fuzzy_diff]
+          #   require_relative "fuzzy_match_strategy"
+          #   FuzzyMatchStrategy.new(format, match_options)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,220 @@
+# frozen_string_literal: true
+
+require_relative "base_match_strategy"
+require_relative "../../tree_diff/tree_diff_integrator"
+require_relative "../../tree_diff/operation_converter"
+
+module Canon
+  module Comparison
+    module Strategies
+      # Semantic tree matching strategy
+      #
+      # Uses TreeDiffIntegrator for intelligent structure-aware matching.
+      # This strategy:
+      # 1. Converts documents to tree representation
+      # 2. Performs semantic matching via TreeDiffIntegrator
+      # 3. Converts Operations to DiffNodes via OperationConverter
+      # 4. Returns DiffNodes that flow through standard rendering pipeline
+      #
+      # Key difference from DOM matching: Uses tree-based structural
+      # similarity and edit distance for matching instead of simple
+      # node-by-node comparison.
+      #
+      # @example Use semantic tree matching
+      #   strategy = SemanticTreeMatchStrategy.new(:xml, match_options)
+      #   diff_nodes = strategy.match(doc1, doc2)
+      #
+      class SemanticTreeMatchStrategy < BaseMatchStrategy
+        # Perform semantic tree matching
+        #
+        # @param doc1 [Object] First document (Nokogiri node, Hash, etc.)
+        # @param doc2 [Object] Second document
+        # @return [Array<Canon::Diff::DiffNode>] Array of differences
+        def match(doc1, doc2)
+          # Create integrator with format-specific adapter
+          integrator = create_integrator
+
+          # Perform tree diff - returns Operations
+          result = integrator.diff(doc1, doc2)
+
+          # Store statistics for metadata
+          @statistics = result[:statistics]
+
+          # Convert Operations to DiffNodes using OperationConverter
+          # This is the KEY FIX - ensures we use proper DiffNodes
+          convert_operations_to_diff_nodes(result[:operations])
+        end
+
+        # Preprocess documents for display
+        #
+        # IMPORTANT: This must use the SAME format as DomMatchStrategy
+        # to ensure consistent diff rendering.
+        #
+        # @param doc1 [Object] First document
+        # @param doc2 [Object] Second document
+        # @return [Array<String>] Preprocessed [doc1_string, doc2_string]
+        def preprocess_for_display(doc1, doc2)
+          case @format
+          when :xml
+            preprocess_xml(doc1, doc2)
+          when :html, :html4, :html5
+            preprocess_html(doc1, doc2)
+          when :json
+            preprocess_json(doc1, doc2)
+          when :yaml
+            preprocess_yaml(doc1, doc2)
+          else
+            raise ArgumentError, "Unsupported format: #{@format}"
+          end
+        end
+
+        # Include tree diff statistics in metadata
+        #
+        # @return [Hash] Metadata including statistics
+        def metadata
+          {
+            tree_diff_statistics: @statistics,
+            tree_diff_enabled: true,
+          }
+        end
+
+        private
+
+        # Create TreeDiffIntegrator with options
+        #
+        # @return [Canon::TreeDiff::TreeDiffIntegrator] Configured integrator
+        def create_integrator
+          Canon::TreeDiff::TreeDiffIntegrator.new(
+            format: @format,
+            options: {
+              similarity_threshold: @match_options[:similarity_threshold] || 0.95,
+              hash_matching: @match_options.fetch(:hash_matching, true),
+              similarity_matching: @match_options.fetch(:similarity_matching,
+                                                        true),
+              propagation: @match_options.fetch(:propagation, true),
+              attribute_order: @match_options[:attribute_order] || :ignore,
+            },
+          )
+        end
+
+        # Convert Operations to DiffNodes using OperationConverter
+        #
+        # This is crucial - it ensures we produce proper DiffNodes with:
+        # - Correct dimension mapping
+        # - Normative/informative classification
+        # - Proper node extraction from TreeNodes
+        #
+        # @param operations [Array<Operation>] Operations from tree diff
+        # @return [Array<Canon::Diff::DiffNode>] Converted DiffNodes
+        def convert_operations_to_diff_nodes(operations)
+          converter = Canon::TreeDiff::OperationConverter.new(
+            format: @format,
+            match_options: @match_options,
+          )
+
+          converter.convert(operations)
+        end
+
+        # Preprocess XML documents
+        #
+        # Uses simple line break insertion (same as DOM diff)
+        # NOT Canon.format() which adds full indentation
+        #
+        # @param doc1 [Object] First XML document
+        # @param doc2 [Object] Second XML document
+        # @return [Array<String>] Preprocessed strings
+        def preprocess_xml(doc1, doc2)
+          # Serialize XML to string
+          # Use XmlComparator'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)
+                 elsif doc1.respond_to?(:to_xml)
+                   doc1.to_xml
+                 else
+                   doc1.to_s
+                 end
+
+          xml2 = if doc2.is_a?(Canon::Xml::Node)
+                   require_relative "../xml_comparator"
+                   XmlComparator.send(:serialize_node_to_xml, doc2)
+                 elsif doc2.respond_to?(:to_xml)
+                   doc2.to_xml
+                 else
+                   doc2.to_s
+                 end
+
+          # MUST match DOM diff preprocessing EXACTLY (xml_comparator.rb:106-109)
+          # Simple pattern: add newline between adjacent tags
+          [
+            xml1.gsub(/></, ">\n<"),
+            xml2.gsub(/></, ">\n<"),
+          ]
+        end
+
+        # Preprocess HTML documents
+        #
+        # Uses native HTML serialization with line break insertion
+        # (same as DOM diff) to ensure proper line-by-line display
+        #
+        # @param doc1 [Object] First HTML document
+        # @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 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)
+                  elsif doc1.is_a?(Nokogiri::XML::DocumentFragment)
+                    doc1.to_s
+                  elsif doc1.respond_to?(:to_html)
+                    doc1.to_html
+                  else
+                    doc1.to_s
+                  end
+
+          html2 = if doc2.is_a?(Canon::Xml::Node)
+                    require_relative "../xml_comparator"
+                    XmlComparator.send(:serialize_node_to_xml, doc2)
+                  elsif doc2.is_a?(Nokogiri::XML::DocumentFragment)
+                    doc2.to_s
+                  elsif doc2.respond_to?(:to_html)
+                    doc2.to_html
+                  else
+                    doc2.to_s
+                  end
+
+          # KEY FIX: Use simple gsub, NOT Canon.format
+          # This ensures proper line-by-line display matching DOM diff format
+          [html1.gsub(/></, ">\n<"), html2.gsub(/></, ">\n<")]
+        end
+
+        # Preprocess JSON documents
+        #
+        # Uses Canon formatter for consistent formatting
+        #
+        # @param doc1 [Object] First JSON document
+        # @param doc2 [Object] Second JSON document
+        # @return [Array<String>] Preprocessed strings
+        def preprocess_json(doc1, doc2)
+          require_relative "../../formatters/json_formatter"
+          [Canon.format(doc1, :json), Canon.format(doc2, :json)]
+        end
+
+        # Preprocess YAML documents
+        #
+        # Uses Canon formatter for consistent formatting
+        #
+        # @param doc1 [Object] First YAML document
+        # @param doc2 [Object] Second YAML document
+        # @return [Array<String>] Preprocessed strings
+        def preprocess_yaml(doc1, doc2)
+          require_relative "../../formatters/yaml_formatter"
+          [Canon.format(doc1, :yaml), Canon.format(doc2, :yaml)]
+        end
+      end
+    end
+  end
+end