canon 0.1.23 → 0.2.1

data/lib/canon/commands/diff_command.rb

@@ -26,8 +26,8 @@ module Canon
         check_file_size(file2, format2)
 
         # Read raw content for potential by-line diff
-        content1 = File.read(file1)
-        content2 = File.read(file2)
+        content1 = File.read(file1, encoding: "utf-8")
+        content2 = File.read(file2, encoding: "utf-8")
 
         # Parse documents
         doc1 = parse_document_content(content1, format1)
@@ -56,6 +56,11 @@ module Canon
           show_diffs: @options[:show_diffs]&.to_sym || :all,
           show_raw_inputs: @options[:show_raw_inputs] || false,
           show_preprocessed_inputs: @options[:show_preprocessed_inputs] || false,
+          show_preprocessed_expected: @options[:show_preprocessed_expected] || false,
+          show_preprocessed_received: @options[:show_preprocessed_received] || false,
+          show_prettyprint_inputs: @options[:show_prettyprint_inputs] || false,
+          show_prettyprint_expected: @options[:show_prettyprint_expected] || false,
+          show_prettyprint_received: @options[:show_prettyprint_received] || false,
           show_line_numbered_inputs: @options[:show_line_numbered_inputs] || false,
         )
 

data/lib/canon/commands/format_command.rb

@@ -15,7 +15,7 @@ module Canon
       # rubocop:disable Metrics/MethodLength
       def run(input_file)
         # Read input file
-        content = File.read(input_file)
+        content = File.read(input_file, encoding: "utf-8")
 
         # Detect or use specified format
         format = detect_format(input_file)

data/lib/canon/comparison/html_comparator.rb

@@ -60,10 +60,14 @@ module Canon
         def equivalent?(html1, html2, opts = {}, child_opts = {})
           opts = DEFAULT_OPTS.merge(opts)
 
-          # Capture original HTML strings BEFORE any parsing/transformation
-          # These are used for display to preserve original formatting
-          original_str1 = extract_original_string(html1)
-          original_str2 = extract_original_string(html2)
+          # Capture original HTML strings for display.
+          # Prefer the true originals preserved by dom_diff (before
+          # HtmlParser.parse mutated the DOM), falling back to
+          # extract_original_string for callers that bypass dom_diff.
+          original_str1 = opts.delete(:_original_str1) ||
+            extract_original_string(html1)
+          original_str2 = opts.delete(:_original_str2) ||
+            extract_original_string(html2)
 
           # Resolve match options with format-specific defaults
           match_opts_hash = MatchOptions::Xml.resolve(
@@ -217,10 +221,11 @@ module Canon
         # @param match_opts_hash [Hash] Resolved match options
         # @return [Boolean, ComparisonResult] Result of tree diff comparison
         def perform_semantic_tree_diff(html1, html2, opts, match_opts_hash)
-          # Capture original HTML strings BEFORE any parsing/transformation
-          # These are used for display to preserve original formatting
-          original_str1 = extract_original_string(html1)
-          original_str2 = extract_original_string(html2)
+          # Capture original HTML strings for display (see equivalent? for details).
+          original_str1 = opts.delete(:_original_str1) ||
+            extract_original_string(html1)
+          original_str2 = opts.delete(:_original_str2) ||
+            extract_original_string(html2)
 
           # Parse to Canon::Xml::Node (preserves preprocessing)
           # For HTML, we parse as XML to get Canon::Xml::Node structure
@@ -388,12 +393,17 @@ module Canon
               end
             end
 
-            # For :rendered preprocessing with Nokogiri nodes
-            if preprocessing == :rendered
-              # Normalize and return
+            # For preprocessing modes that require whitespace filtering,
+            # apply the same post-parsing normalization used for string inputs.
+            # This is needed because dom_diff() pre-parses HTML5 strings into
+            # Nokogiri fragments before calling HtmlComparator, bypassing the
+            # string-input path where these filters are normally applied.
+            if %i[normalize format rendered].include?(preprocessing)
               frag = node.is_a?(Nokogiri::XML::DocumentFragment) ? node : Nokogiri::XML.fragment(node.to_html)
               normalize_html_style_script_comments(frag)
-              normalize_rendered_whitespace(frag, match_opts)
+              if preprocessing == :rendered
+                normalize_rendered_whitespace(frag, match_opts)
+              end
               remove_whitespace_only_text_nodes(frag)
               return frag
             end
@@ -628,22 +638,22 @@ compare_profile = nil)
           return if match_opts[:text_content] == :strict
 
           # Elements where whitespace is significant - don't normalize
-          # SINGLE SOURCE OF TRUTH: WhitespaceSensitivity.format_default_sensitive_elements
+          # SINGLE SOURCE OF TRUTH: WhitespaceSensitivity.format_default_preserve_elements
           # This ensures consistency between preprocessing and comparison logic
-          # SINGLE SOURCE OF TRUTH: WhitespaceSensitivity.format_default_sensitive_elements
+          # SINGLE SOURCE OF TRUTH: WhitespaceSensitivity.format_default_preserve_elements
           # This ensures consistency between preprocessing and comparison logic
           preserve_whitespace = if compare_profile.is_a?(HtmlCompareProfile)
                                   # Profile handles HTML-specific whitespace rules
                                   # Get default list and filter by profile
                                   WhitespaceSensitivity
-                                    .format_default_sensitive_elements(match_opts)
+                                    .format_default_preserve_elements(match_opts)
                                     .select do |elem|
                                       compare_profile.preserve_whitespace?(elem.to_s)
                                     end
                                     .map(&:to_s)
                                 else
                                   # Use default list from WhitespaceSensitivity (single source of truth)
-                                  WhitespaceSensitivity.format_default_sensitive_elements(match_opts).map(&:to_s)
+                                  WhitespaceSensitivity.format_default_preserve_elements(match_opts).map(&:to_s)
                                 end
 
           # Walk all text nodes
@@ -700,11 +710,11 @@ compare_profile = nil)
         # CRITICAL: Do NOT remove whitespace-only text nodes from whitespace-sensitive
         # elements like <pre>, <code>, <textarea>, <script>, <style>
         #
-        # SINGLE SOURCE OF TRUTH: Uses WhitespaceSensitivity.format_default_sensitive_elements
+        # SINGLE SOURCE OF TRUTH: Uses WhitespaceSensitivity.format_default_preserve_elements
         def remove_whitespace_only_text_nodes(doc)
           # Elements where whitespace is significant - don't remove whitespace-only nodes
-          # SINGLE SOURCE OF TRUTH: WhitespaceSensitivity.format_default_sensitive_elements
-          preserve_whitespace = WhitespaceSensitivity.format_default_sensitive_elements(format: :html).map(&:to_s)
+          # SINGLE SOURCE OF TRUTH: WhitespaceSensitivity.format_default_preserve_elements
+          preserve_whitespace = WhitespaceSensitivity.format_default_preserve_elements(format: :html).map(&:to_s)
 
           doc.xpath(".//text()").each do |text_node|
             # CRITICAL: Skip if this text node is inside a whitespace-preserving element

data/lib/canon/comparison/html_compare_profile.rb

@@ -69,7 +69,7 @@ module Canon
       # @param element_name [String] The element name to check
       # @return [Boolean] true if whitespace should be preserved
       def preserve_whitespace?(element_name)
-        whitespace_sensitive_elements.include?(element_name.to_s.downcase)
+        html_preserve_elements.include?(element_name.to_s.downcase)
       end
 
       # Check if element names should be compared case-sensitively
@@ -85,12 +85,12 @@ module Canon
 
       # Elements where whitespace is semantically significant in HTML
       #
-      # SINGLE SOURCE OF TRUTH: Delegates to WhitespaceSensitivity.format_default_sensitive_elements
+      # SINGLE SOURCE OF TRUTH: Delegates to WhitespaceSensitivity.format_default_preserve_elements
       # This ensures consistency across the codebase.
       #
       # @return [Array<String>] List of element names (as strings)
-      def whitespace_sensitive_elements
-        WhitespaceSensitivity.format_default_sensitive_elements(format: @html_version).map(&:to_s)
+      def html_preserve_elements
+        WhitespaceSensitivity.format_default_preserve_elements(format: @html_version).map(&:to_s)
       end
 
       # Check if a dimension is explicitly set to :strict

data/lib/canon/comparison/markup_comparator.rb

@@ -177,8 +177,8 @@ module Canon
           end
 
           # Strip whitespace-only text nodes based on parent element configuration.
-          # Use sensitive_elements / insensitive_elements to control.
-          # Blacklist (insensitive) > whitelist (sensitive) > format defaults.
+          # Use preserve_whitespace_elements / strip_whitespace_elements to control.
+          # Blacklist (strip) > preserve > collapse > format defaults.
           return false unless text_node?(node) && node.parent
           return false unless MatchOptions.normalize_text(node_text(node)).empty?
 
@@ -186,7 +186,16 @@ module Canon
             node.parent, match_opts
           )
 
-          false
+          # When the pretty-print-side flag is active (set by opts_for_side in
+          # ChildComparison.compare), drop whitespace-only text nodes that start
+          # with "\n" inside :collapse elements — they are structural indentation
+          # from the pretty-printer, not content.  Space-only nodes (no initial "\n") are
+          # real inline content and are kept for normalised comparison.
+          # :preserve elements are always left unchanged.
+          if match_opts[:_pretty_print_side_active]
+            ws_class = WhitespaceSensitivity.classify_text_node(node, opts)
+            return true if ws_class == :collapse && node_text(node).start_with?("\n")
+          end
 
           false
         end

data/lib/canon/comparison/match_options/base_resolver.rb

@@ -95,6 +95,25 @@ module Canon
 
           protected
 
+          # Valid match behaviors per dimension for this format.
+          # Override in subclasses to provide format-specific behaviors.
+          # Used for per-dimension validation in validate_match_options!
+          #
+          # @return [Hash{Symbol => Array<Symbol>}] Dimension to valid behaviors mapping
+          def dimension_behaviors
+            # Default: XML/HTML behaviors (override in JSON/YAML resolvers)
+            {
+              text_content: %i[strict normalize ignore].freeze,
+              structural_whitespace: %i[strict normalize ignore].freeze,
+              attribute_presence: %i[strict ignore].freeze,
+              attribute_order: %i[strict ignore].freeze,
+              attribute_values: %i[strict strip compact normalize
+                                   ignore].freeze,
+              element_position: %i[strict ignore].freeze,
+              comments: %i[strict ignore].freeze,
+            }
+          end
+
           # Validate preprocessing option
           #
           # @param preprocessing [Symbol] Preprocessing option
@@ -107,7 +126,7 @@ module Canon
             end
           end
 
-          # Validate match options
+          # Validate match options using per-dimension behavior validation
           #
           # @param match_options [Hash] Options to validate
           # @raise [Canon::Error] If invalid dimension or behavior
@@ -121,11 +140,12 @@ module Canon
               hash_matching
               similarity_matching
               propagation
-              sensitive_elements
-              insensitive_elements
-              whitespace_sensitive_elements
-              whitespace_insensitive_elements
+              preserve_whitespace_elements
+              collapse_whitespace_elements
+              strip_whitespace_elements
               respect_xml_space
+              pretty_printed_expected
+              pretty_printed_received
             ]
 
             match_options.each do |dimension, behavior|
@@ -138,10 +158,12 @@ module Canon
                       "Valid dimensions: #{match_dimensions.join(', ')}"
               end
 
-              unless MatchOptions::MATCH_BEHAVIORS.include?(behavior)
+              # Per-dimension behavior validation using overridable method
+              valid_behaviors = dimension_behaviors[dimension]
+              unless valid_behaviors&.include?(behavior)
                 raise Canon::Error,
                       "Unknown match behavior: #{behavior} for #{dimension}. " \
-                      "Valid behaviors: #{MatchOptions::MATCH_BEHAVIORS.join(', ')}"
+                      "Valid behaviors for #{dimension}: #{valid_behaviors&.join(', ')}"
               end
             end
           end

data/lib/canon/comparison/match_options/json_resolver.rb

@@ -75,6 +75,15 @@ module Canon
             end
             MATCH_PROFILES[profile].dup
           end
+
+          # JSON-specific dimension behaviors
+          def dimension_behaviors
+            {
+              text_content: %i[strict normalize ignore].freeze,
+              structural_whitespace: %i[strict normalize ignore].freeze,
+              key_order: %i[strict ignore].freeze,
+            }
+          end
         end
       end
     end

data/lib/canon/comparison/match_options/xml_resolver.rb

@@ -12,7 +12,7 @@ module Canon
         # Sensitive elements (preserve structural whitespace):
         # - XML: none by default — all structural whitespace stripped
         # - HTML: pre, code, textarea, script, style by default
-        # Use sensitive_elements option to add elements that preserve whitespace.
+        # Use preserve_whitespace_elements option to add elements that preserve whitespace.
         #
         FORMAT_DEFAULTS = {
           html: {
@@ -41,7 +41,7 @@ module Canon
         MATCH_PROFILES = {
           # Strict: Match exactly as written in source (XML default).
           # Structural whitespace is stripped by default for XML.
-          # Use sensitive_elements to preserve structural whitespace in specific elements.
+          # Use preserve_whitespace_elements to preserve structural whitespace in specific elements.
           strict: {
             preprocessing: :none,
             text_content: :strict,
@@ -152,6 +152,20 @@ module Canon
             end
             MATCH_PROFILES[profile].dup
           end
+
+          # XML/HTML-specific dimension behaviors
+          def dimension_behaviors
+            {
+              text_content: %i[strict normalize ignore].freeze,
+              structural_whitespace: %i[strict normalize ignore].freeze,
+              attribute_presence: %i[strict ignore].freeze,
+              attribute_order: %i[strict ignore].freeze,
+              attribute_values: %i[strict strip compact normalize
+                                   ignore].freeze,
+              element_position: %i[strict ignore].freeze,
+              comments: %i[strict ignore].freeze,
+            }
+          end
         end
       end
     end

data/lib/canon/comparison/match_options/yaml_resolver.rb

@@ -80,6 +80,16 @@ module Canon
             end
             MATCH_PROFILES[profile].dup
           end
+
+          # YAML-specific dimension behaviors
+          def dimension_behaviors
+            {
+              text_content: %i[strict normalize ignore].freeze,
+              structural_whitespace: %i[strict normalize ignore].freeze,
+              key_order: %i[strict ignore].freeze,
+              comments: %i[strict ignore].freeze,
+            }
+          end
         end
       end
     end

data/lib/canon/comparison/match_options.rb

@@ -57,7 +57,10 @@ module Canon
       # Preprocessing options - what to do before comparison
       PREPROCESSING_OPTIONS = %i[none c14n normalize format rendered].freeze
 
-      # Matching behaviors (mutually exclusive)
+      # Matching behaviors (deprecated - use per-dimension validation instead)
+      # This universal constant is kept for backward compatibility but should not
+      # be used for validation. Use BaseResolver.dimension_behaviors instead.
+      # Note: :strip and :compact are only valid for attribute_values dimension.
       MATCH_BEHAVIORS = %i[strict strip compact normalize ignore].freeze
 
       class << self