canon 0.1.6 → 0.1.7

data/lib/canon/data_model.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Canon
+  # Abstract base class for format-specific data models
+  # Provides common interface for parsing and serializing documents
+  class DataModel
+    class << self
+      # Parse input into data model
+      # Must be implemented by subclasses
+      #
+      # @param input [String] Input content to parse
+      # @return [Object] Parsed data model representation
+      # @raise [NotImplementedError] if not implemented by subclass
+      def parse(input)
+        raise NotImplementedError, "#{self} must implement #parse"
+      end
+
+      # Serialize data model node
+      # Must be implemented by subclasses
+      #
+      # @param node [Object] Node to serialize
+      # @return [String] Serialized representation
+      # @raise [NotImplementedError] if not implemented by subclass
+      def serialize(node)
+        raise NotImplementedError, "#{self} must implement #serialize"
+      end
+    end
+  end
+end

data/lib/canon/diff/diff_classifier.rb

@@ -1,22 +1,54 @@
 # frozen_string_literal: true
 
+require_relative "formatting_detector"
+require_relative "../comparison/compare_profile"
+
 module Canon
   module Diff
     # Classifies DiffNodes as normative (affects equivalence) or informative (doesn't affect equivalence)
     # based on the match options in effect
     class DiffClassifier
-      attr_reader :match_options
+      attr_reader :match_options, :profile
 
       # @param match_options [Canon::Comparison::ResolvedMatchOptions] The match options
       def initialize(match_options)
         @match_options = match_options
+        # Use the compare_profile from ResolvedMatchOptions if available (e.g., HtmlCompareProfile)
+        # Otherwise create a base CompareProfile
+        @profile = if match_options.respond_to?(:compare_profile) && match_options.compare_profile
+                     match_options.compare_profile
+                   else
+                     Canon::Comparison::CompareProfile.new(match_options)
+                   end
       end
 
       # Classify a single DiffNode as normative or informative
+      # Hierarchy: formatting-only < informative < normative
+      # CompareProfile determines base classification, FormattingDetector refines informative differences
       # @param diff_node [DiffNode] The diff node to classify
-      # @return [DiffNode] The same diff node with normative attribute set
+      # @return [DiffNode] The same diff node with normative/formatting attributes set
       def classify(diff_node)
-        diff_node.normative = normative_for_dimension?(diff_node.dimension)
+        # FIRST: Determine if this dimension is normative based on CompareProfile
+        # This respects the policy settings (strict/normalize/ignore)
+        is_normative = profile.normative_dimension?(diff_node.dimension)
+
+        # SECOND: Check if FormattingDetector should be consulted
+        # Only check for formatting-only when dimension is NOT normative
+        # This ensures strict mode differences remain normative
+        should_check_formatting = !is_normative &&
+          profile.supports_formatting_detection?(diff_node.dimension)
+
+        # If we should check formatting, see if it's formatting-only
+        if should_check_formatting && formatting_only_diff?(diff_node)
+          diff_node.formatting = true
+          diff_node.normative = false
+          return diff_node
+        end
+
+        # Otherwise, use the normative determination from CompareProfile
+        diff_node.formatting = false
+        diff_node.normative = is_normative
+
         diff_node
       end
 
@@ -29,17 +61,45 @@ module Canon
 
       private
 
-      # Determine if a difference in a given dimension is normative
-      # @param dimension [Symbol] The match dimension
-      # @return [Boolean] true if differences in this dimension are normative
-      def normative_for_dimension?(dimension)
-        behavior = match_options.behavior_for(dimension)
-
-        # :ignore → informative (difference doesn't matter)
-        # :strict or :normalize → normative (difference persisted through matching)
-        # Note: If a DiffNode exists, it means the comparison FAILED even after
-        # applying normalization, so it's a real (normative) difference
-        behavior != :ignore
+      # Check if a DiffNode represents a formatting-only difference
+      # @param diff_node [DiffNode] The diff node to check
+      # @return [Boolean] true if formatting-only
+      def formatting_only_diff?(diff_node)
+        text1 = extract_text_content(diff_node.node1)
+        text2 = extract_text_content(diff_node.node2)
+
+        FormattingDetector.formatting_only?(text1, text2)
+      end
+
+      # Extract text content from a node for formatting comparison
+      # @param node [Object] The node to extract text from
+      # @return [String, nil] The text content or nil
+      def extract_text_content(node)
+        return nil if node.nil?
+
+        # For TextNode with value attribute (Canon::Xml::Nodes::TextNode)
+        return node.value if node.respond_to?(:value) && node.is_a?(Canon::Xml::Nodes::TextNode)
+
+        # For XML/HTML nodes with text_content method
+        return node.text_content if node.respond_to?(:text_content)
+
+        # For nodes with text method
+        return node.text if node.respond_to?(:text)
+
+        # For nodes with content method
+        return node.content if node.respond_to?(:content)
+
+        # For nodes with value method (other types)
+        return node.value if node.respond_to?(:value)
+
+        # For simple text nodes or strings
+        return node.to_s if node.is_a?(String)
+
+        # For other node types, try to_s
+        node.to_s
+      rescue StandardError
+        # If extraction fails, return nil (not formatting-only)
+        nil
       end
     end
   end

data/lib/canon/diff/diff_context_builder.rb

@@ -41,6 +41,9 @@ grouping_lines: nil)
           create_context_for_blocks(block_group)
         end
 
+        # Merge overlapping contexts to avoid duplicate line display
+        contexts = merge_overlapping_contexts(contexts)
+
         # Filter out all-informative contexts if show_diffs was :normative
         # Note: The filtering based on show_diffs happens at the block level
         # in DiffBlockBuilder, so we don't need to re-filter here.
@@ -51,6 +54,44 @@ grouping_lines: nil)
 
       private
 
+      # Merge overlapping contexts into single contexts
+      # When contexts have overlapping line ranges, combine them
+      def merge_overlapping_contexts(contexts)
+        return contexts if contexts.empty?
+
+        # Sort by start_idx
+        sorted = contexts.sort_by(&:start_idx)
+        merged = [sorted.first]
+
+        sorted[1..].each do |context|
+          last = merged.last
+
+          # Check if contexts overlap (including touching contexts)
+          if context.start_idx <= last.end_idx + 1
+            # Merge: extend the range and combine blocks
+            new_end = [last.end_idx, context.end_idx].max
+            combined_blocks = (last.blocks + context.blocks).uniq
+
+            # Extract combined lines
+            combined_lines = @all_lines[last.start_idx..new_end]
+
+            # Replace last context with merged one
+            merged[-1] = DiffContext.new(
+              start_line: last.start_idx,
+              end_line: new_end,
+              blocks: combined_blocks,
+              lines: combined_lines,
+              normative: last.normative? || context.normative?,
+            )
+          else
+            # No overlap, add as separate context
+            merged << context
+          end
+        end
+
+        merged
+      end
+
       # Group blocks that are close together
       def group_nearby_blocks(blocks, max_gap)
         return [] if blocks.empty?

data/lib/canon/diff/diff_line.rb

@@ -11,17 +11,22 @@ module Canon
       # @param content [String] The text content of the line
       # @param type [Symbol] The type of line (:unchanged, :added, :removed, :changed)
       # @param diff_node [DiffNode, nil] The semantic diff node this line belongs to
-      def initialize(line_number:, content:, type:, diff_node: nil)
+      # @param formatting [Boolean] Whether this is a formatting-only difference
+      def initialize(line_number:, content:, type:, diff_node: nil,
+formatting: false)
         @line_number = line_number
         @content = content
         @type = type
         @diff_node = diff_node
+        @formatting = formatting
       end
 
       # @return [Boolean] true if this line represents a normative difference
       # If diff_node is nil (not linked to any semantic difference), the line
       # is considered informative (cosmetic/unchanged)
+      # Formatting-only diffs are never normative
       def normative?
+        return false if formatting?
         return false if diff_node.nil?
 
         diff_node.normative?
@@ -29,12 +34,20 @@ module Canon
 
       # @return [Boolean] true if this line represents an informative-only difference
       # If diff_node is nil (not linked), it's not informative either (it's unchanged/cosmetic)
+      # Formatting-only diffs are never informative
       def informative?
+        return false if formatting?
         return false if diff_node.nil?
 
         diff_node.informative?
       end
 
+      # @return [Boolean] true if this line represents a formatting-only difference
+      # Formatting diffs are purely cosmetic (whitespace, line breaks) with no semantic meaning
+      def formatting?
+        @formatting == true
+      end
+
       # @return [Boolean] true if this line is unchanged
       def unchanged?
         type == :unchanged
@@ -62,6 +75,8 @@ module Canon
           type: type,
           diff_node: diff_node&.to_h,
           normative: normative?,
+          informative: informative?,
+          formatting: formatting?,
         }
       end
 
@@ -70,7 +85,8 @@ module Canon
           line_number == other.line_number &&
           content == other.content &&
           type == other.type &&
-          diff_node == other.diff_node
+          diff_node == other.diff_node &&
+          @formatting == other.instance_variable_get(:@formatting)
       end
     end
   end

data/lib/canon/diff/diff_node.rb

@@ -6,8 +6,8 @@ module Canon
     # This is created during the Comparison Layer and carries information about
     # which dimension caused the difference and whether it's normative or informative
     class DiffNode
-      attr_reader :node1, :node2, :dimension, :reason
-      attr_accessor :normative
+      attr_reader :node1, :node2
+      attr_accessor :dimension, :reason, :normative, :formatting
 
       # @param node1 [Object] The first node being compared
       # @param node2 [Object] The second node being compared
@@ -21,18 +21,31 @@ module Canon
         @dimension = dimension
         @reason = reason
         @normative = nil # Will be set by DiffClassifier
+        @formatting = nil # Will be set by DiffClassifier
       end
 
       # @return [Boolean] true if this diff is normative (affects equivalence)
+      # Formatting-only diffs are never normative
       def normative?
+        return false if formatting?
+
         @normative == true
       end
 
       # @return [Boolean] true if this diff is informative only (doesn't affect equivalence)
+      # Formatting-only diffs are never informative
       def informative?
+        return false if formatting?
+
         @normative == false
       end
 
+      # @return [Boolean] true if this diff is formatting-only (purely cosmetic)
+      # Formatting diffs are whitespace/line break differences with no semantic meaning
+      def formatting?
+        @formatting == true
+      end
+
       def to_h
         {
           node1: node1,
@@ -40,6 +53,7 @@ module Canon
           dimension: dimension,
           reason: reason,
           normative: normative,
+          formatting: formatting,
         }
       end
 
@@ -49,7 +63,8 @@ module Canon
           node2 == other.node2 &&
           dimension == other.dimension &&
           reason == other.reason &&
-          normative == other.normative
+          normative == other.normative &&
+          formatting == other.formatting
       end
     end
   end

data/lib/canon/diff/diff_node_mapper.rb

@@ -61,31 +61,75 @@ module Canon
                           diff_node: nil,
                         )
                       when "-"
+                        # Find the diff node for this line
+                        node = shared_informative_node || find_diff_node_for_line(
+                          line_num, lines1, :removed
+                        )
+
+                        # Check if this is formatting-only:
+                        # 1. First check if the DiffNode itself is marked as formatting-only
+                        # 2. Otherwise, check line-level formatting
+                        formatting = if node.respond_to?(:formatting?) && node.formatting?
+                                       true
+                                     else
+                                       formatting_only_line?(
+                                         change.old_element, ""
+                                       )
+                                     end
+
                         DiffLine.new(
                           line_number: line_num,
                           content: change.old_element,
                           type: :removed,
-                          diff_node: shared_informative_node || find_diff_node_for_line(
-                            line_num, lines1, :removed
-                          ),
+                          diff_node: node,
+                          formatting: formatting,
                         )
                       when "+"
+                        # Find the diff node for this line
+                        node = shared_informative_node || find_diff_node_for_line(
+                          line_num, lines2, :added
+                        )
+
+                        # Check if this is formatting-only:
+                        # 1. First check if the DiffNode itself is marked as formatting-only
+                        # 2. Otherwise, check line-level formatting
+                        formatting = if node.respond_to?(:formatting?) && node.formatting?
+                                       true
+                                     else
+                                       formatting_only_line?("",
+                                                             change.new_element)
+                                     end
+
                         DiffLine.new(
                           line_number: line_num,
                           content: change.new_element,
                           type: :added,
-                          diff_node: shared_informative_node || find_diff_node_for_line(
-                            line_num, lines2, :added
-                          ),
+                          diff_node: node,
+                          formatting: formatting,
                         )
                       when "!"
+                        # Find the diff node for this line
+                        node = shared_informative_node || find_diff_node_for_line(
+                          line_num, lines2, :changed
+                        )
+
+                        # Check if this is formatting-only:
+                        # 1. First check if the DiffNode itself is marked as formatting-only
+                        # 2. Otherwise, check line-level formatting
+                        formatting = if node.respond_to?(:formatting?) && node.formatting?
+                                       true
+                                     else
+                                       formatting_only_line?(
+                                         change.old_element, change.new_element
+                                       )
+                                     end
+
                         DiffLine.new(
                           line_number: line_num,
                           content: change.new_element,
                           type: :changed,
-                          diff_node: shared_informative_node || find_diff_node_for_line(
-                            line_num, lines2, :changed
-                          ),
+                          diff_node: node,
+                          formatting: formatting,
                         )
                       end
 
@@ -98,6 +142,15 @@ module Canon
 
       private
 
+      # Check if two lines differ only in formatting (whitespace)
+      # @param line1 [String] First line
+      # @param line2 [String] Second line
+      # @return [Boolean] true if formatting-only difference
+      def formatting_only_line?(line1, line2)
+        require_relative "formatting_detector"
+        FormattingDetector.formatting_only?(line1, line2)
+      end
+
       # Find the DiffNode associated with a line
       # Uses element name matching for precise line-level linking
       def find_diff_node_for_line(line_num, lines, change_type)
@@ -125,9 +178,15 @@ module Canon
                            end
 
           nodes_to_check.any? do |node|
-            next unless node.respond_to?(:name)
-
-            node.name == line_element_name
+            # Check if the node itself has the matching name
+            if node.respond_to?(:name) && node.name == line_element_name
+              true
+            # Check if the node's parent has the matching name (for TextNode diffs)
+            elsif node.respond_to?(:parent) && node.parent.respond_to?(:name) && node.parent.name == line_element_name
+              true
+            else
+              false
+            end
           end
         end
       end

data/lib/canon/diff/formatting_detector.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Canon
+  module Diff
+    # Detects if differences between lines are formatting-only
+    # (whitespace, line breaks) with no semantic content changes
+    class FormattingDetector
+      # Detect if two lines differ only in formatting
+      #
+      # @param line1 [String, nil] First line to compare
+      # @param line2 [String, nil] Second line to compare
+      # @return [Boolean] true if lines differ only in formatting
+      def self.formatting_only?(line1, line2)
+        # If both are nil or empty, not a formatting diff
+        return false if blank?(line1) && blank?(line2)
+
+        # If only one is blank, it's not just formatting
+        return false if blank?(line1) || blank?(line2)
+
+        # Compare normalized versions
+        normalize_for_comparison(line1) == normalize_for_comparison(line2)
+      end
+
+      # Aggressive normalization for formatting comparison
+      # Collapses all whitespace to single space and strips
+      # Also normalizes whitespace around tag delimiters
+      #
+      # @param line [String, nil] Line to normalize
+      # @return [String] Normalized line
+      def self.normalize_for_comparison(line)
+        return "" if line.nil?
+
+        # Collapse all whitespace (spaces, tabs, newlines) to single space
+        normalized = line.gsub(/\s+/, " ").strip
+
+        # Normalize whitespace around tag delimiters
+        # Remove spaces before > and after <
+        normalized = normalized.gsub(/\s+>/, ">") # "div >" -> "div>"
+        normalized.gsub(/<\s+/, "<") # "< div" -> "<div"
+      end
+
+      # Check if a line is blank (nil or whitespace-only)
+      #
+      # @param line [String, nil] Line to check
+      # @return [Boolean] true if blank
+      def self.blank?(line)
+        line.nil? || line.strip.empty?
+      end
+
+      private_class_method :normalize_for_comparison, :blank?
+    end
+  end
+end

data/lib/canon/diff_formatter/by_line/base_formatter.rb

@@ -68,6 +68,35 @@ module Canon
 
         protected
 
+        # Filter differences for display based on show_diffs setting
+        #
+        # @param differences [Array<Canon::Diff::DiffNode>] Array of differences
+        # @return [Array<Canon::Diff::DiffNode>] Filtered differences
+        def filter_differences_for_display(differences)
+          return differences if @show_diffs.nil? || @show_diffs == :all
+
+          differences.select do |diff|
+            # Handle both DiffNode objects and legacy Hash format
+            is_normative = if diff.respond_to?(:normative?)
+                             diff.normative?
+                           elsif diff.is_a?(Hash) && diff.key?(:normative)
+                             diff[:normative]
+                           else
+                             # Default to normative if unknown
+                             true
+                           end
+
+            case @show_diffs
+            when :normative
+              is_normative
+            when :informative
+              !is_normative
+            else
+              true # Unknown value, show all
+            end
+          end
+        end
+
         # Build hunks from diff with context lines
         #
         # @param diffs [Array] LCS diff array
@@ -252,6 +281,7 @@ module Canon
         # @return [String] Formatted context
         def format_context(context, diffs, base_line1, base_line2)
           output = []
+          max_lines = get_max_diff_lines
 
           (context.start_idx..context.end_idx).each do |idx|
             change = diffs[idx]
@@ -275,6 +305,18 @@ module Canon
                                             change.old_element,
                                             change.new_element)
             end
+
+            # Check if we've exceeded the line limit
+            if max_lines&.positive? && output.size >= max_lines
+              output << ""
+              output << colorize(
+                "... Output truncated at #{max_lines} lines ...", :yellow, :bold
+              )
+              output << colorize(
+                "Increase limit via CANON_MAX_DIFF_LINES or config.diff.max_diff_lines", :yellow
+              )
+              break
+            end
           end
 
           output.join("\n")
@@ -299,19 +341,22 @@ module Canon
         #
         # @param old_num [Integer, nil] Line number in old file
         # @param new_num [Integer, nil] Line number in new file
-        # @param marker [String] Diff marker (' ', '-', '+', '~')
+        # @param marker [String] Diff marker (' ', '-', '+', '<', '>', '[', ']')
         # @param content [String] Line content
         # @param color [Symbol, nil] Color for diff lines
         # @param informative [Boolean] Whether this is an informative diff
+        # @param formatting [Boolean] Whether this is a formatting-only diff
         # @return [String] Formatted line
         def format_unified_line(old_num, new_num, marker, content, color = nil,
-                                informative: false)
+                                informative: false, formatting: false)
           old_str = old_num ? "%4d" % old_num : "    "
           new_str = new_num ? "%4d" % new_num : "    "
-          marker_part = "#{marker} "
 
-          # For informative diffs, use cyan color
-          effective_color = informative ? :cyan : color
+          # Formatting and informative diffs use directional colors already passed in
+          # No need to override since callers set the correct color
+          effective_color = color
+
+          marker_part = "#{marker} "
 
           visualized_content = if effective_color
                                  apply_visualization(content, effective_color)
@@ -401,6 +446,16 @@ module Canon
             visual
           end
         end
+
+        # Get max diff lines limit
+        #
+        # @return [Integer, nil] Max diff output lines
+        def get_max_diff_lines
+          # Try to get from config if available
+          config = Canon::Config.instance
+          # Default to 10,000 if config not available
+          config&.xml&.diff&.max_diff_lines || 10_000
+        end
       end
     end
   end