canon 0.1.6 → 0.1.7

data/lib/canon/commands/diff_command.rb

@@ -20,6 +20,10 @@ module Canon
         format1 = @options[:format1] || @options[:format] || detect_format(file1)
         format2 = @options[:format2] || @options[:format] || detect_format(file2)
 
+        # Check file sizes before reading
+        check_file_size(file1, format1)
+        check_file_size(file2, format2)
+
         # Read raw content for potential by-line diff
         content1 = File.read(file1)
         content2 = File.read(file2)
@@ -48,25 +52,36 @@ module Canon
           mode: mode,
           context_lines: @options.fetch(:context_lines, 3),
           diff_grouping_lines: @options[:diff_grouping_lines],
+          show_diffs: @options[:show_diffs]&.to_sym || :all,
         )
-        if comp_opts[:verbose]
-          # result is always a ComparisonResult object
-          output = formatter.format(
+
+        # Show configuration in verbose mode using shared DebugOutput
+        if @options[:verbose]
+          require_relative "../diff_formatter/debug_output"
+          config_output = Canon::DiffFormatter::DebugOutput.verbose_tables_only(
             result,
-            format1,
-            doc1: formatted1,
-            doc2: formatted2,
+            {
+              use_color: @options[:color],
+              mode: mode,
+              context_lines: @options.fetch(:context_lines, 3),
+              diff_grouping_lines: @options[:diff_grouping_lines],
+              show_diffs: @options[:show_diffs]&.to_sym || :all,
+              verbose_diff: true, # Enable verbose table output
+            },
           )
-          puts output
-          exit result.equivalent? ? 0 : 1
-        elsif result
-          # result is a boolean
-          puts formatter.send(:success_message)
-          exit 0
-        else
-          puts "Files are semantically different"
-          exit 1
+          puts config_output unless config_output.empty?
         end
+
+        # Always show diff when files are not equivalent
+        # result is always a ComparisonResult object when verbose: true
+        output = formatter.format(
+          result,
+          format1,
+          doc1: formatted1,
+          doc2: formatted2,
+        )
+        puts output
+        exit result.equivalent? ? 0 : 1
       rescue Errno::ENOENT => e
         abort "Error: #{e.message}"
       rescue JSON::ParserError => e
@@ -90,7 +105,12 @@ module Canon
 
         opts[:match] = match_opts unless match_opts.empty?
         opts[:ignore_attr_order] = @options.fetch(:ignore_attr_order, true)
-        opts[:verbose] = @options.fetch(:verbose, false)
+        # Always request verbose comparison to get ComparisonResult with differences
+        # The CLI --verbose flag only affects output formatting, not comparison detail
+        opts[:verbose] = true
+
+        add_algorithm_option(opts)
+        add_show_diffs_option(opts)
 
         opts
       end
@@ -113,7 +133,7 @@ module Canon
       def build_match_dimension_options
         dimensions = %i[
           text_content structural_whitespace attribute_whitespace
-          comments key_order
+          attribute_order attribute_values comments key_order
         ]
 
         dimensions.each_with_object({}) do |dim, opts|
@@ -121,16 +141,46 @@ module Canon
         end
       end
 
+      # Add show_diffs option to comparison options
+      # @param opts [Hash] Options hash to modify
+      def add_show_diffs_option(opts)
+        return unless @options[:show_diffs]
+
+        opts[:show_diffs] = @options[:show_diffs].to_sym
+      end
+
+      # Add diff_algorithm option to comparison options
+      # @param opts [Hash] Options hash to modify
+      def add_algorithm_option(opts)
+        opts[:diff_algorithm] = determine_algorithm
+      end
+
       # Determine diff mode based on format and options
       def determine_mode(format)
-        # HTML always uses by-line mode
-        return :by_line if format == :html
+        # Check for explicit --diff-mode flag (new approach)
+        if @options[:diff_mode]
+          return @options[:diff_mode].to_sym
+        end
 
-        # Check for explicit --by-line flag for XML, JSON, YAML
-        return :by_line if @options[:by_line]
+        # Backward compatibility: check --by-line flag (deprecated)
+        if @options[:by_line]
+          warn "WARNING: --by-line is deprecated. Use --diff-mode by_line instead."
+          return :by_line
+        end
+
+        # Format-specific defaults
+        case format
+        when :html
+          :by_line
+        else
+          :by_object
+        end
+      end
 
-        # Default: by-object mode for JSON and YAML, by-object for XML
-        :by_object
+      # Determine diff algorithm based on options
+      def determine_algorithm
+        algo = @options[:diff_algorithm] || "dom"
+        algo.to_sym
       end
 
       # Parse document content based on its format
@@ -190,6 +240,41 @@ module Canon
                 "Please specify --format (xml, html, json, or yaml)"
         end
       end
+
+      # Check if file size exceeds configured limit
+      #
+      # @param filename [String] Path to file
+      # @param format [Symbol] File format
+      # @raise [Canon::SizeLimitExceededError] if file exceeds limit
+      def check_file_size(filename, format)
+        file_size = File.size(filename)
+        max_size = get_max_file_size(format)
+
+        return unless max_size&.positive?
+        return if file_size <= max_size
+
+        raise Canon::SizeLimitExceededError.new(:file_size, file_size, max_size)
+      end
+
+      # Get max file size limit for format
+      #
+      # @param format [Symbol] File format
+      # @return [Integer, nil] Max file size in bytes
+      def get_max_file_size(format)
+        config = Canon::Config.instance
+        case format
+        when :xml
+          config.xml.diff.max_file_size
+        when :html
+          config.html.diff.max_file_size
+        when :json
+          config.json.diff.max_file_size
+        when :yaml
+          config.yaml.diff.max_file_size
+        else
+          5_242_880 # Default 5MB
+        end
+      end
     end
   end
 end

data/lib/canon/comparison/compare_profile.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Canon
+  module Comparison
+    # CompareProfile encapsulates the policy decisions about how differences
+    # in various dimensions should be handled during comparison
+    #
+    # This class provides separation of concerns:
+    # - CompareProfile: Policy decisions (what to track, what affects equivalence)
+    # - Comparator: Comparison logic (detect differences)
+    # - DiffClassifier: Classification logic (normative vs informative vs formatting)
+    class CompareProfile
+      attr_reader :match_options
+
+      # @param match_options [ResolvedMatchOptions, Hash] The match options to use
+      def initialize(match_options)
+        @match_options = match_options
+      end
+
+      # Should DiffNodes be created for differences in this dimension?
+      #
+      # In verbose mode, we want to track ALL differences for reporting.
+      # In non-verbose mode, we only need to track normative differences.
+      #
+      # @param dimension [Symbol] The match dimension to check
+      # @return [Boolean] true if differences should be tracked
+      def track_dimension?(_dimension)
+        # Always track dimensions that affect equivalence
+        # In verbose mode, also track informative dimensions
+        true
+      end
+
+      # Should differences in this dimension affect equivalence?
+      #
+      # This determines the return value of the comparison:
+      # - true: differences make documents non-equivalent
+      # - false: differences are informative only
+      #
+      # @param dimension [Symbol] The match dimension to check
+      # @return [Boolean] true if differences affect equivalence
+      def affects_equivalence?(dimension)
+        behavior = behavior_for(dimension)
+
+        # :strict → affects equivalence
+        # :normalize → might affect (if normalization fails)
+        # :ignore → does NOT affect equivalence
+        behavior != :ignore
+      end
+
+      # Is a difference in this dimension normative (affects equivalence)?
+      #
+      # This is used by DiffClassifier to determine the normative flag.
+      #
+      # @param dimension [Symbol] The match dimension to check
+      # @return [Boolean] true if normative, false if informative
+      def normative_dimension?(dimension)
+        # Element structure changes are ALWAYS normative
+        return true if dimension == :element_structure
+
+        # Structural whitespace with :normalize or :ignore behavior is INFORMATIVE
+        # Only :strict mode makes whitespace normative
+        if dimension == :structural_whitespace
+          behavior = behavior_for(dimension)
+          return behavior == :strict
+        end
+
+        # For other dimensions, if behavior affects equivalence, it's normative
+        affects_equivalence?(dimension)
+      end
+
+      # Can a difference in this dimension be formatting-only?
+      #
+      # This determines whether FormattingDetector should be applied.
+      # Only text/content dimensions can have formatting-only differences.
+      #
+      # @param dimension [Symbol] The match dimension to check
+      # @return [Boolean] true if formatting detection should apply
+      def supports_formatting_detection?(dimension)
+        # Only text_content and structural_whitespace can have formatting-only diffs
+        # Comments are policy-based (strict/ignore), not formatting-based
+        %i[text_content structural_whitespace].include?(dimension)
+      end
+
+      private
+
+      # Get the behavior setting for a dimension
+      # @param dimension [Symbol] The match dimension
+      # @return [Symbol] The behavior (:strict, :normalize, :ignore)
+      def behavior_for(dimension)
+        # Handle both ResolvedMatchOptions and Hash
+        if match_options.respond_to?(:behavior_for)
+          match_options.behavior_for(dimension)
+        elsif match_options.is_a?(Hash)
+          match_options[dimension] || :strict
+        else
+          :strict
+        end
+      end
+    end
+  end
+end

data/lib/canon/comparison/comparison_result.rb

@@ -6,20 +6,24 @@ module Canon
     # Provides methods to query equivalence based on normative diffs
     class ComparisonResult
       attr_reader :differences, :preprocessed_strings, :format, :html_version,
-                  :match_options
+                  :match_options, :algorithm, :original_strings
 
       # @param differences [Array<DiffNode>] Array of difference nodes
       # @param preprocessed_strings [Array<String, String>] Pre-processed content for display
       # @param format [Symbol] Format type (:xml, :html, :json, :yaml)
       # @param html_version [Symbol, nil] HTML version (:html4 or :html5) for HTML format only
       # @param match_options [Hash, nil] Resolved match options used for comparison
+      # @param algorithm [Symbol] Diff algorithm used (:dom or :semantic)
+      # @param original_strings [Array<String, String>, nil] Original unprocessed content for line diff
       def initialize(differences:, preprocessed_strings:, format:,
-html_version: nil, match_options: nil)
+html_version: nil, match_options: nil, algorithm: :dom, original_strings: nil)
         @differences = differences
         @preprocessed_strings = preprocessed_strings
+        @original_strings = original_strings || preprocessed_strings
         @format = format
         @html_version = html_version
         @match_options = match_options
+        @algorithm = algorithm
       end
 
       # Check if documents are semantically equivalent (no normative diffs)
@@ -74,6 +78,41 @@ html_version: nil, match_options: nil)
           diff.is_a?(Canon::Diff::DiffNode) && diff.informative?
         end
       end
+
+      # Get tree diff operations (only available when diff_algorithm: :semantic)
+      #
+      # @return [Array<Operation>] Array of tree diff operations
+      def operations
+        @match_options&.[](:tree_diff_operations) || []
+      end
+
+      # Generate formatted diff output
+      #
+      # @param use_color [Boolean] Whether to use ANSI color codes
+      # @param context_lines [Integer] Number of context lines to show
+      # @param diff_grouping_lines [Integer] Maximum gap for grouping diffs
+      # @param show_diffs [Symbol] Which diffs to show (:all, :normative, :informative)
+      # @return [String] Formatted diff output
+      def diff(use_color: true, context_lines: 3, diff_grouping_lines: nil,
+show_diffs: :all)
+        require_relative "../diff_formatter"
+
+        formatter = Canon::DiffFormatter.new(
+          use_color: use_color,
+          mode: :by_line,
+          context_lines: context_lines,
+          diff_grouping_lines: diff_grouping_lines,
+          show_diffs: show_diffs,
+        )
+
+        formatter.format(
+          @differences,
+          @format,
+          doc1: @original_strings[0],
+          doc2: @original_strings[1],
+          html_version: @html_version,
+        )
+      end
     end
   end
 end