canon 0.1.5 → 0.1.7

data/lib/canon/comparison.rb

@@ -100,8 +100,215 @@ module Canon
       # @param obj2 [Object] Second object to compare
       # @param opts [Hash] Comparison options
       #   - :format - Format hint (:xml, :html, :html4, :html5, :json, :yaml, :string)
+      #   - :diff_algorithm - Algorithm to use (:dom or :semantic)
       # @return [Boolean, Array] true if equivalent, or array of diffs if verbose
       def equivalent?(obj1, obj2, opts = {})
+        # Check if semantic tree diff is requested
+        # Support both :semantic and :semantic_tree for backward compatibility
+        if %i[semantic semantic_tree].include?(opts[:diff_algorithm])
+          return semantic_diff(obj1, obj2, opts)
+        end
+
+        # Otherwise use DOM-based comparison (default)
+        dom_diff(obj1, obj2, opts)
+      end
+
+      private
+
+      # Perform semantic tree diff comparison
+      def semantic_diff(obj1, obj2, opts = {})
+        require_relative "tree_diff"
+
+        # Detect format for both objects
+        format1 = opts[:format] || detect_format(obj1)
+        format2 = opts[:format] || detect_format(obj2)
+
+        # Handle string format (plain text comparison) - semantic tree doesn't support it
+        if format1 == :string
+          if opts[:verbose]
+            return obj1.to_s == obj2.to_s ? [] : [:different]
+          else
+            return obj1.to_s == obj2.to_s
+          end
+        end
+
+        # Ensure formats match
+        unless format1 == format2
+          raise Canon::CompareFormatMismatchError.new(format1, format2)
+        end
+
+        # Resolve match options for the format
+        match_opts_hash = resolve_match_options(format1, opts)
+
+        # Delegate parsing to comparators (reuses existing preprocessing logic)
+        doc1, doc2 = parse_with_comparator(obj1, obj2, format1, match_opts_hash)
+
+        # Normalize format for TreeDiff (html4/html5 -> html)
+        tree_diff_format = normalize_format_for_tree_diff(format1)
+
+        # Create TreeDiff integrator for the format
+        # CRITICAL: Use match_opts_hash (resolved options with profile) not opts[:match]
+        integrator = Canon::TreeDiff::TreeDiffIntegrator.new(
+          format: tree_diff_format,
+          options: match_opts_hash,
+        )
+
+        # Perform diff
+        tree_diff_result = integrator.diff(doc1, doc2)
+
+        # Convert operations to DiffNodes for unified pipeline
+        # CRITICAL: Use match_opts_hash (resolved options with profile) not opts[:match]
+        converter = Canon::TreeDiff::OperationConverter.new(
+          format: format1,
+          match_options: match_opts_hash,
+        )
+        diff_nodes = converter.convert(tree_diff_result[:operations])
+
+        # CRITICAL: Use strategy's preprocess_for_display to ensure proper line-breaking
+        # This matches DOM diff preprocessing pattern (xml_comparator.rb:106-109)
+        require_relative "comparison/strategies/semantic_tree_match_strategy"
+        strategy = Comparison::Strategies::SemanticTreeMatchStrategy.new(
+          format: format1, match_options: match_opts_hash,
+        )
+        str1, str2 = strategy.preprocess_for_display(doc1, doc2)
+
+        # Store tree diff data in match_options for access via result
+        enhanced_match_options = match_opts_hash.merge(
+          tree_diff_operations: tree_diff_result[:operations],
+          tree_diff_statistics: tree_diff_result[:statistics],
+          tree_diff_matching: tree_diff_result[:matching],
+        )
+
+        # Create ComparisonResult for unified handling
+        result = Canon::Comparison::ComparisonResult.new(
+          differences: diff_nodes,
+          preprocessed_strings: [str1, str2],
+          format: format1,
+          html_version: %i[html4 html5].include?(format1) ? format1 : nil,
+          match_options: enhanced_match_options,
+          algorithm: :semantic,
+        )
+
+        # Return boolean or ComparisonResult based on verbose flag
+        if opts[:verbose]
+          result
+        else
+          result.equivalent?
+        end
+      end
+
+      # Resolve match options for a format
+      #
+      # @param format [Symbol] Format type
+      # @param opts [Hash] User options
+      # @return [Hash] Resolved match options
+      def resolve_match_options(format, opts)
+        case format
+        when :xml, :html, :html4, :html5
+          MatchOptions::Xml.resolve(
+            format: format,
+            match_profile: opts[:match_profile],
+            match: opts[:match],
+            preprocessing: opts[:preprocessing],
+            global_profile: opts[:global_profile],
+            global_options: opts[:global_options],
+          )
+        when :json
+          MatchOptions::Json.resolve(
+            format: format,
+            match_profile: opts[:match_profile],
+            match: opts[:match],
+            preprocessing: opts[:preprocessing],
+            global_profile: opts[:global_profile],
+            global_options: opts[:global_options],
+          )
+        when :yaml
+          MatchOptions::Yaml.resolve(
+            format: format,
+            match_profile: opts[:match_profile],
+            match: opts[:match],
+            preprocessing: opts[:preprocessing],
+            global_profile: opts[:global_profile],
+            global_options: opts[:global_options],
+          )
+        else
+          opts[:match] || {}
+        end
+      end
+
+      # Parse documents using comparator's parse logic (reuses preprocessing)
+      #
+      # @param obj1 [Object] First object
+      # @param obj2 [Object] Second object
+      # @param format [Symbol] Format type
+      # @param match_opts_hash [Hash] Resolved match options
+      # @return [Array<Object, Object>] Parsed documents
+      def parse_with_comparator(obj1, obj2, format, match_opts_hash)
+        preprocessing = match_opts_hash[:preprocessing] || :none
+
+        case format
+        when :xml
+          # Delegate to XmlComparator's parse_node - returns Canon::Xml::Node
+          # Adapter now handles Canon::Xml::Node directly
+          doc1 = XmlComparator.send(:parse_node, obj1, preprocessing)
+          doc2 = XmlComparator.send(:parse_node, obj2, preprocessing)
+          [doc1, doc2]
+        when :html, :html4, :html5
+          # Delegate to HtmlComparator's parse_node_for_semantic for Canon::Xml::Node
+          [
+            HtmlComparator.send(:parse_node_for_semantic, obj1, preprocessing),
+            HtmlComparator.send(:parse_node_for_semantic, obj2, preprocessing),
+          ]
+        when :json
+          # Delegate to JsonComparator's parse_json
+          [
+            JsonComparator.send(:parse_json, obj1),
+            JsonComparator.send(:parse_json, obj2),
+          ]
+        when :yaml
+          # Delegate to YamlComparator's parse_yaml
+          [
+            YamlComparator.send(:parse_yaml, obj1),
+            YamlComparator.send(:parse_yaml, obj2),
+          ]
+        else
+          [obj1, obj2]
+        end
+      end
+
+      # Normalize format for TreeDiff (html4/html5 -> html)
+      #
+      # @param format [Symbol] Original format
+      # @return [Symbol] Normalized format for TreeDiff
+      def normalize_format_for_tree_diff(format)
+        case format
+        when :html4, :html5
+          :html
+        else
+          format
+        end
+      end
+
+      # Serialize document back to string
+      def serialize_document(doc, format)
+        case format
+        when :xml, :html, :html4, :html5
+          doc.respond_to?(:to_html) ? doc.to_html : doc.to_xml
+        when :json
+          require "json"
+          JSON.pretty_generate(doc)
+        when :yaml
+          require "yaml"
+          doc.to_yaml
+        else
+          doc.to_s
+        end
+      rescue StandardError
+        doc.to_s
+      end
+
+      # Perform DOM-based comparison (original behavior)
+      def dom_diff(obj1, obj2, opts = {})
         # Use format hint if provided
         if opts[:format]
           format1 = format2 = opts[:format]
@@ -159,8 +366,6 @@ module Canon
         end
       end
 
-      private
-
       # Parse HTML string into Nokogiri document
       #
       # @param content [String, Object] Content to parse (returns as-is if not a string)

data/lib/canon/config/env_provider.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require_relative "env_schema"
+require_relative "type_converter"
+
+module Canon
+  class Config
+    # Provides environment variable values for configuration
+    # Reads and parses CANON_* environment variables
+    class EnvProvider
+      class << self
+        # Load environment overrides for a specific format's diff config
+        def load_diff_for_format(format)
+          load_config_for_format(format, :diff, EnvSchema.all_diff_attributes)
+        end
+
+        # Load environment overrides for a specific format's match config
+        def load_match_for_format(format)
+          load_config_for_format(format, :match, EnvSchema.all_match_attributes)
+        end
+
+        # Load environment overrides for a specific format's format config
+        def load_format_for_format(format)
+          load_config_for_format(format, :format,
+                                 EnvSchema.all_format_attributes)
+        end
+
+        # Load global environment overrides (apply to all formats)
+        def load_global_diff
+          load_global_config(EnvSchema.all_diff_attributes)
+        end
+
+        private
+
+        def load_config_for_format(format, config_type, attributes)
+          result = {}
+          attributes.each do |attr|
+            # Try format-specific ENV var first
+            env_key = EnvSchema.env_key(format, config_type, attr)
+            value = ENV[env_key]
+
+            # Fall back to global ENV var if format-specific not set
+            if value.nil?
+              global_key = EnvSchema.global_env_key(attr)
+              value = ENV[global_key]
+            end
+
+            # Convert and store if value exists
+            if value
+              result[attr] = TypeConverter.convert(attr, value)
+            end
+          end
+          result
+        end
+
+        def load_global_config(attributes)
+          result = {}
+          attributes.each do |attr|
+            global_key = EnvSchema.global_env_key(attr)
+            value = ENV[global_key]
+
+            if value
+              result[attr] = TypeConverter.convert(attr, value)
+            end
+          end
+          result
+        end
+      end
+    end
+  end
+end

data/lib/canon/config/env_schema.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Canon
+  class Config
+    # Schema definition for configuration attributes
+    # Defines attribute types and ENV variable mappings
+    class EnvSchema
+      ATTRIBUTE_TYPES = {
+        # DiffConfig attributes
+        mode: :symbol,
+        use_color: :boolean,
+        context_lines: :integer,
+        grouping_lines: :integer,
+        show_diffs: :symbol,
+        verbose_diff: :boolean,
+        algorithm: :symbol,
+
+        # MatchConfig attributes
+        profile: :symbol,
+
+        # FormatConfig attributes
+        preprocessing: :string,
+
+        # Size limits to prevent hangs on large files
+        max_file_size: :integer,
+        max_node_count: :integer,
+        max_diff_lines: :integer,
+      }.freeze
+
+      class << self
+        def type_for(attribute)
+          ATTRIBUTE_TYPES[attribute.to_sym]
+        end
+
+        def env_key(format, config_type, attribute)
+          "CANON_#{format.to_s.upcase}_#{config_type.to_s.upcase}_#{attribute.to_s.upcase}"
+        end
+
+        def global_env_key(attribute)
+          "CANON_#{attribute.to_s.upcase}"
+        end
+
+        def all_diff_attributes
+          %i[mode use_color context_lines grouping_lines show_diffs
+             verbose_diff algorithm max_file_size max_node_count max_diff_lines]
+        end
+
+        def all_match_attributes
+          %i[profile]
+        end
+
+        def all_format_attributes
+          %i[preprocessing]
+        end
+      end
+    end
+  end
+end

data/lib/canon/config/override_resolver.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Canon
+  class Config
+    # Resolves configuration values using priority chain
+    # Priority: ENV > programmatic > defaults
+    class OverrideResolver
+      attr_reader :defaults, :programmatic, :env
+
+      def initialize(defaults: {}, programmatic: {}, env: {})
+        @defaults = defaults
+        @programmatic = programmatic
+        @env = env
+      end
+
+      # Resolve a single value using priority chain
+      # Uses .key? to properly handle false values
+      def resolve(key)
+        return @env[key] if @env.key?(key)
+        return @programmatic[key] if @programmatic.key?(key)
+
+        @defaults[key]
+      end
+
+      # Update programmatic value
+      def set_programmatic(key, value)
+        @programmatic[key] = value
+      end
+
+      # Update ENV override
+      def set_env(key, value)
+        @env[key] = value
+      end
+
+      # Check if value is set by ENV
+      def env_set?(key)
+        @env.key?(key)
+      end
+
+      # Check if value is set programmatically
+      def programmatic_set?(key)
+        @programmatic.key?(key)
+      end
+
+      # Get the source of a value
+      def source_for(key)
+        return :env if @env.key?(key)
+        return :programmatic if @programmatic.key?(key)
+        return :default if @defaults.key?(key)
+
+        nil
+      end
+    end
+  end
+end

data/lib/canon/config/type_converter.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Canon
+  class Config
+    # Type converter for environment variable values
+    # Converts string ENV values to appropriate Ruby types
+    class TypeConverter
+      BOOLEAN_VALUES = {
+        "true" => true,
+        "1" => true,
+        "yes" => true,
+        "false" => false,
+        "0" => false,
+        "no" => false,
+      }.freeze
+
+      class << self
+        def convert(attribute, value)
+          return nil if value.nil? || value.empty?
+
+          type = EnvSchema.type_for(attribute)
+          case type
+          when :boolean
+            convert_boolean(value)
+          when :integer
+            convert_integer(value)
+          when :symbol
+            convert_symbol(value)
+          when :string
+            value
+          else
+            value
+          end
+        end
+
+        private
+
+        def convert_boolean(value)
+          normalized = value.to_s.downcase
+          return BOOLEAN_VALUES[normalized] if BOOLEAN_VALUES.key?(normalized)
+
+          raise ArgumentError,
+                "Invalid boolean value: #{value}. " \
+                "Valid values: #{BOOLEAN_VALUES.keys.join(', ')}"
+        end
+
+        def convert_integer(value)
+          Integer(value)
+        rescue ArgumentError
+          raise ArgumentError, "Invalid integer value: #{value}"
+        end
+
+        def convert_symbol(value)
+          value.to_sym
+        end
+      end
+    end
+  end
+end

data/lib/canon/config.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require_relative "config/env_provider"
+require_relative "config/override_resolver"
+
 module Canon
   # Global configuration for Canon
   # Provides unified configuration across CLI, Ruby API, and RSpec interfaces
@@ -93,8 +96,8 @@ module Canon
 
       def initialize(format)
         @format = format
-        @match = MatchConfig.new
-        @diff = DiffConfig.new
+        @match = MatchConfig.new(format)
+        @diff = DiffConfig.new(format)
         @preprocessing = nil
       end
 
@@ -107,11 +110,11 @@ module Canon
 
     # Match configuration for comparison behavior
     class MatchConfig
-      attr_accessor :profile
       attr_reader :options
 
-      def initialize
-        @profile = nil
+      def initialize(format = nil)
+        @format = format
+        @resolver = build_resolver(format)
         @options = {}
       end
 
@@ -120,53 +123,179 @@ module Canon
       end
 
       def reset!
-        @profile = nil
+        @resolver = build_resolver(@format)
         @options = {}
       end
 
+      # Profile accessor with ENV override support
+      def profile
+        @resolver.resolve(:profile)
+      end
+
+      def profile=(value)
+        @resolver.set_programmatic(:profile, value)
+      end
+
       # Build match options from profile and options
       def to_h
         result = {}
-        result[:match_profile] = @profile if @profile
+        result[:match_profile] = profile if profile
         result[:match] = @options if @options && !@options.empty?
         result
       end
+
+      private
+
+      def build_resolver(format)
+        defaults = {
+          profile: nil,
+        }
+
+        env = format ? EnvProvider.load_match_for_format(format) : {}
+
+        OverrideResolver.new(
+          defaults: defaults,
+          programmatic: {},
+          env: env,
+        )
+      end
     end
 
     # Diff configuration for output formatting
     class DiffConfig
-      attr_accessor :mode, :use_color, :context_lines, :grouping_lines,
-                    :show_diffs, :verbose_diff
-
-      def initialize
-        @mode = :by_line
-        @use_color = true
-        @context_lines = 3
-        @grouping_lines = 10
-        @show_diffs = :all
-        @verbose_diff = false
+      def initialize(format = nil)
+        @format = format
+        @resolver = build_resolver(format)
       end
 
       def reset!
-        @mode = :by_line
-        @use_color = true
-        @context_lines = 3
-        @grouping_lines = 10
-        @show_diffs = :all
-        @verbose_diff = false
+        @resolver = build_resolver(@format)
+      end
+
+      # Accessors with ENV override support
+      def mode
+        @resolver.resolve(:mode)
+      end
+
+      def mode=(value)
+        @resolver.set_programmatic(:mode, value)
+      end
+
+      def use_color
+        @resolver.resolve(:use_color)
+      end
+
+      def use_color=(value)
+        @resolver.set_programmatic(:use_color, value)
+      end
+
+      def context_lines
+        @resolver.resolve(:context_lines)
+      end
+
+      def context_lines=(value)
+        @resolver.set_programmatic(:context_lines, value)
+      end
+
+      def grouping_lines
+        @resolver.resolve(:grouping_lines)
+      end
+
+      def grouping_lines=(value)
+        @resolver.set_programmatic(:grouping_lines, value)
+      end
+
+      def show_diffs
+        @resolver.resolve(:show_diffs)
+      end
+
+      def show_diffs=(value)
+        @resolver.set_programmatic(:show_diffs, value)
+      end
+
+      def verbose_diff
+        @resolver.resolve(:verbose_diff)
+      end
+
+      def verbose_diff=(value)
+        @resolver.set_programmatic(:verbose_diff, value)
+      end
+
+      def algorithm
+        @resolver.resolve(:algorithm)
+      end
+
+      def algorithm=(value)
+        @resolver.set_programmatic(:algorithm, value)
+      end
+
+      # File size limit in bytes (default 5MB)
+      def max_file_size
+        @resolver.resolve(:max_file_size)
+      end
+
+      def max_file_size=(value)
+        @resolver.set_programmatic(:max_file_size, value)
+      end
+
+      # Maximum node count in tree (default 10,000)
+      def max_node_count
+        @resolver.resolve(:max_node_count)
+      end
+
+      def max_node_count=(value)
+        @resolver.set_programmatic(:max_node_count, value)
+      end
+
+      # Maximum diff output lines (default 10,000)
+      def max_diff_lines
+        @resolver.resolve(:max_diff_lines)
+      end
+
+      def max_diff_lines=(value)
+        @resolver.set_programmatic(:max_diff_lines, value)
       end
 
       # Build diff options
       def to_h
         {
-          diff: @mode,
-          use_color: @use_color,
-          context_lines: @context_lines,
-          grouping_lines: @grouping_lines,
-          show_diffs: @show_diffs,
-          verbose_diff: @verbose_diff,
+          diff: mode,
+          use_color: use_color,
+          context_lines: context_lines,
+          grouping_lines: grouping_lines,
+          show_diffs: show_diffs,
+          verbose_diff: verbose_diff,
+          diff_algorithm: algorithm,
+          max_file_size: max_file_size,
+          max_node_count: max_node_count,
+          max_diff_lines: max_diff_lines,
         }
       end
+
+      private
+
+      def build_resolver(format)
+        defaults = {
+          mode: :by_line,
+          use_color: true,
+          context_lines: 3,
+          grouping_lines: 10,
+          show_diffs: :all,
+          verbose_diff: false,
+          algorithm: :dom,
+          max_file_size: 5_242_880, # 5MB in bytes
+          max_node_count: 10_000,   # Maximum nodes in tree
+          max_diff_lines: 10_000,   # Maximum diff output lines
+        }
+
+        env = format ? EnvProvider.load_diff_for_format(format) : {}
+
+        OverrideResolver.new(
+          defaults: defaults,
+          programmatic: {},
+          env: env,
+        )
+      end
     end
   end
 end