canon 0.1.21 → 0.1.23

data/lib/canon/diff/diff_node_mapper.rb

@@ -67,6 +67,7 @@ module Canon
                       when "="
                         DiffLine.new(
                           line_number: change.old_position,
+                          new_position: change.new_position,
                           content: change.old_element,
                           type: :unchanged,
                           diff_node: nil,
@@ -133,6 +134,12 @@ module Canon
         # element reflow with different line counts).
         apply_block_formatting!(diff_lines, lcs_diffs)
 
+        # Post-process: merge adjacent "-" lines into preceding "!" changes
+        # when the removed content already appears in the new line.
+        # This handles the case where N old lines map to 1 new line
+        # (e.g., closing tag on its own line merged into previous line).
+        merge_adjacent_removals!(diff_lines, lines1)
+
         diff_lines
       end
 
@@ -188,6 +195,7 @@ module Canon
 
         lcs_diffs.each_with_index do |change, idx|
           if change.action == "="
+            blocks << current_block if current_block
             current_block = nil
             next
           end
@@ -261,6 +269,52 @@ module Canon
         FormattingDetector.formatting_only?(line1, line2)
       end
 
+      # Merge adjacent "-" lines into a preceding "!" change when the
+      # removed content already appears in the changed line's new content.
+      #
+      # This handles the common case where N old lines map to 1 new line
+      # (e.g., a closing tag on its own line gets merged into the previous
+      # line in the reformatted document). Without this merge, the closing
+      # tag would appear as a spurious deletion even though it still exists.
+      #
+      # @param diff_lines [Array<DiffLine>] The diff lines to update in place
+      # @param lines1 [Array<String>] Lines from text1 for content lookup
+      def merge_adjacent_removals!(diff_lines, lines1)
+        i = 0
+        while i < diff_lines.length
+          dl = diff_lines[i]
+          unless dl.changed?
+            i += 1
+            next
+          end
+
+          j = i + 1
+          while j < diff_lines.length && diff_lines[j].removed?
+            removed = diff_lines[j]
+            removed_stripped = removed.content.strip
+
+            # Only merge if the removed content actually appears in the
+            # new line — it's not a real deletion, just a line-wrap change
+            if removed_stripped.empty? || !dl.content.include?(removed_stripped)
+              j += 1
+              next
+            end
+
+            # Extend old_content to span multiple old lines
+            dl.old_content ||= lines1[dl.line_number]
+            dl.old_content += "\n#{lines1[removed.line_number]}"
+
+            # Remove the absorbed line
+            diff_lines[j] = nil
+            j += 1
+          end
+
+          i = j
+        end
+
+        diff_lines.compact!
+      end
+
       # Determine formatting status for a changed line.
       # Checks: DiffNode formatting flag → line-level formatting → comment-only heuristic
       #

data/lib/canon/diff/source_locator.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Canon
+  module Diff
+    # Locates serialized content within source text and maps character offsets
+    # to line/column positions. Used during DiffNode enrichment (Phase 1).
+    #
+    # The SourceLocator uses String#index on the full source text (not LCS on
+    # lines) to find where a DiffNode's serialized content appears. It then
+    # maps the character offset to a line number and column position using
+    # a pre-built line offset map.
+    #
+    # @example
+    #   line_map = SourceLocator.build_line_map("line1\nline2\nline3")
+    #   SourceLocator.locate("line2", "line1\nline2\nline3", line_map)
+    #   # => { char_offset: 6, line_number: 1, col: 0 }
+    class SourceLocator
+      # Build a line offset map from source text.
+      # Each entry records the start and end character offset of a line.
+      #
+      # @param text [String] the full source text
+      # @return [Array<Hash>] array of { start_offset:, end_offset: } hashes,
+      #   one per line (0-indexed)
+      def self.build_line_map(text)
+        return [] if text.nil? || text.empty?
+
+        map = []
+        offset = 0
+        text.each_line do |line|
+          line_end = offset + line.length
+          map << { start_offset: offset, end_offset: line_end }
+          offset = line_end
+        end
+        map
+      end
+
+      # Locate a substring within source text and return its position.
+      #
+      # @param substring [String] the content to find (e.g., serialized_before)
+      # @param text [String] the full source text
+      # @param line_map [Array<Hash>] pre-built line offset map
+      # @param start_from [Integer, nil] character offset to start searching from
+      # @return [Hash, nil] { char_offset:, line_number:, col: } or nil if not found
+      def self.locate(substring, text, line_map, start_from: nil)
+        return nil if substring.nil? || substring.empty?
+        return nil if text.nil? || line_map.empty?
+
+        char_offset = if start_from
+                        text.index(substring, start_from)
+                      else
+                        text.index(substring)
+                      end
+        return nil if char_offset.nil?
+
+        line_idx = find_line_for_offset(char_offset, line_map)
+        return nil if line_idx.nil?
+
+        col = char_offset - line_map[line_idx][:start_offset]
+
+        { char_offset: char_offset, line_number: line_idx, col: col }
+      end
+
+      # Locate ALL occurrences of a substring within source text.
+      #
+      # @param substring [String] the content to find
+      # @param text [String] the full source text
+      # @param line_map [Array<Hash>] pre-built line offset map
+      # @return [Array<Hash>] array of { char_offset:, line_number:, col: } hashes
+      def self.locate_all(substring, text, line_map)
+        return [] if substring.nil? || substring.empty?
+        return [] if text.nil? || line_map.empty?
+
+        results = []
+        offset = 0
+
+        while (pos = text.index(substring, offset))
+          line_idx = find_line_for_offset(pos, line_map)
+          break if line_idx.nil?
+
+          col = pos - line_map[line_idx][:start_offset]
+          results << { char_offset: pos, line_number: line_idx, col: col }
+          offset = pos + 1
+        end
+
+        results
+      end
+
+      class << self
+        private
+
+        # Binary search for the line containing a character offset.
+        #
+        # @param char_offset [Integer] the character offset
+        # @param line_map [Array<Hash>] the line offset map
+        # @return [Integer, nil] the 0-based line index, or nil
+        def find_line_for_offset(char_offset, line_map)
+          # Use bsearch for efficiency on large files
+          line_map.bsearch_index do |entry|
+            entry[:end_offset] > char_offset
+          end
+        end
+      end
+    end
+  end
+end

data/lib/canon/diff/text_decomposer.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module Canon
+  module Diff
+    # Decomposes two strings into their common prefix, changed portion, and
+    # common suffix. Used during DiffNode enrichment (Phase 1) to produce
+    # the 3-part decomposition: before-text, changed-text, after-text.
+    #
+    # This is a pure function with no side effects. It operates on short
+    # serialized strings (e.g., "Hello World" vs "Hello Universe"), NOT
+    # on full document text.
+    #
+    # @example Simple substitution
+    #   TextDecomposer.decompose("Hello World", "Hello Universe")
+    #   # => { common_prefix: "Hello ", changed_old: "World",
+    #   #      changed_new: "Universe", common_suffix: "" }
+    #
+    # @example Mid-string insertion
+    #   TextDecomposer.decompose("abc", "aXbc")
+    #   # => { common_prefix: "a", changed_old: "",
+    #   #      changed_new: "X", common_suffix: "bc" }
+    #
+    # @example Full replacement
+    #   TextDecomposer.decompose("foo", "bar")
+    #   # => { common_prefix: "", changed_old: "foo",
+    #   #      changed_new: "bar", common_suffix: "" }
+    class TextDecomposer
+      # Decompose two strings into common prefix / changed / common suffix.
+      #
+      # Algorithm: character-by-character prefix scan from the start,
+      # then reverse suffix scan from the end. The middle portion is
+      # the actual change. O(n) where n is the string length.
+      #
+      # @param text1 [String] the old text (serialized_before)
+      # @param text2 [String] the new text (serialized_after)
+      # @return [Hash] with keys :common_prefix, :changed_old, :changed_new, :common_suffix
+      def self.decompose(text1, text2)
+        return empty_result if text1.nil? && text2.nil?
+
+        if text2.nil?
+          return { common_prefix: "", changed_old: text1.to_s,
+                   changed_new: "", common_suffix: "" }
+        end
+        if text1.nil?
+          return { common_prefix: "", changed_old: "",
+                   changed_new: text2.to_s, common_suffix: "" }
+        end
+
+        prefix_len = find_common_prefix_length(text1, text2)
+        suffix_len = find_common_suffix_length(text1, text2, prefix_len)
+
+        {
+          common_prefix: text1[0...prefix_len],
+          changed_old: text1[prefix_len...(text1.length - suffix_len)],
+          changed_new: text2[prefix_len...(text2.length - suffix_len)],
+          common_suffix: text1[(text1.length - suffix_len)..],
+        }
+      end
+
+      class << self
+        private
+
+        def empty_result
+          { common_prefix: "", changed_old: "", changed_new: "",
+            common_suffix: "" }
+        end
+
+        # Find the length of the common prefix of two strings.
+        # @param text1 [String]
+        # @param text2 [String]
+        # @return [Integer] number of matching characters from the start
+        def find_common_prefix_length(text1, text2)
+          max_len = [text1.length, text2.length].min
+          count = 0
+          while count < max_len && text1[count] == text2[count]
+            count += 1
+          end
+          count
+        end
+
+        # Find the length of the common suffix of two strings,
+        # excluding the common prefix.
+        # @param text1 [String]
+        # @param text2 [String]
+        # @param prefix_len [Integer] length of already-matched prefix
+        # @return [Integer] number of matching characters from the end
+        def find_common_suffix_length(text1, text2, prefix_len)
+          remaining1 = text1.length - prefix_len
+          remaining2 = text2.length - prefix_len
+          max_suffix = [remaining1, remaining2].min
+          return 0 if max_suffix <= 0
+
+          count = 0
+          while count < max_suffix &&
+              text1[text1.length - 1 - count] == text2[text2.length - 1 - count]
+            count += 1
+          end
+          count
+        end
+      end
+    end
+  end
+end

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

@@ -3,6 +3,7 @@
 require "diff/lcs"
 require "diff/lcs/hunk"
 require_relative "../debug_output"
+require_relative "../theme"
 
 module Canon
   class DiffFormatter
@@ -11,7 +12,7 @@ module Canon
       # Provides common LCS diff logic and hunk building
       class BaseFormatter
         attr_reader :use_color, :context_lines, :diff_grouping_lines,
-                    :visualization_map, :show_diffs
+                    :visualization_map, :show_diffs, :diff_mode, :legacy_terminal
 
         # Create a format-specific by-line formatter
         #
@@ -46,13 +47,210 @@ module Canon
 
         def initialize(use_color: true, context_lines: 3,
                        diff_grouping_lines: nil, visualization_map: nil,
-                       show_diffs: :all, differences: [])
+                       show_diffs: :all, differences: [],
+                       diff_mode: :separate, legacy_terminal: false,
+                       equivalent: nil, theme: nil)
           @use_color = use_color
           @context_lines = context_lines
           @diff_grouping_lines = diff_grouping_lines
           @visualization_map = visualization_map
           @show_diffs = show_diffs
           @differences = differences
+          @line_num_width = 4
+          @diff_mode = legacy_terminal ? :separate : diff_mode
+          @legacy_terminal = legacy_terminal
+          @equivalent = equivalent
+          @theme = theme
+        end
+
+        # Get the resolved theme hash
+        # @return [Hash] Theme hash
+        def theme
+          @theme ||= Theme.resolver(Canon::Config.instance).resolve
+        end
+
+        # Get theme by section and type
+        # @param section [Symbol] e.g., :diff, :xml, :structure
+        # @param diff_type [Symbol] e.g., :removed, :added, :changed
+        # @param element [Symbol] e.g., :marker, :content
+        # @return [Hash] Style properties
+        def theme_style(section, diff_type, element)
+          theme.dig(section, diff_type, element) || {}
+        end
+
+        # Apply full theme styling to text
+        # @param text [String] Text to style
+        # @param style [Hash] Style properties from theme (color, bg, bold, underline, strikethrough)
+        # @return [String] Styled text
+        def apply_theme_style(text, style)
+          return text if style.empty? || !@use_color
+
+          color = style[:color]
+          bg = style[:bg]
+          bold = style[:bold]
+          underline = style[:underline]
+          strikethrough = style[:strikethrough]
+
+          # Apply visualization first
+          visual = apply_visualization(text)
+
+          return visual unless color || bg || bold || underline || strikethrough
+
+          require "rainbow"
+          rainbow = Rainbow.new
+          rainbow.enabled = true
+          presenter = rainbow.wrap(visual)
+
+          if color && color != :default
+            presenter = apply_color(presenter,
+                                    color)
+          end
+          presenter = apply_bg(presenter, bg) if bg
+          presenter = presenter.bold if bold
+          presenter = presenter.underline if underline
+          presenter = presenter.cross_out if strikethrough
+
+          presenter.to_s
+        end
+
+        # Compute line number column width from document line counts
+        def compute_line_num_width(doc1, doc2)
+          max_lines = [doc1.count("\n"), doc2.count("\n")].max
+          @line_num_width = [max_lines.to_s.length, 4].max
+        end
+
+        # =====================================================================
+        # Theme Style Helpers
+        # These methods look up theme styles for different diff types
+        # =====================================================================
+
+        # Get marker style for a diff type
+        # @param diff_type [Symbol] :removed, :added, :changed, :formatting, :informative
+        # @return [Hash] Style properties
+        def marker_style(diff_type)
+          theme_style(:diff, diff_type, :marker)
+        end
+
+        # Get content style for a diff type
+        # @param diff_type [Symbol] :removed, :added, :formatting, :informative
+        # @return [Hash] Style properties
+        def content_style(diff_type)
+          theme_style(:diff, diff_type, :content)
+        end
+
+        # Get changed content styles (old and new)
+        # @return [Hash] Keys: :content_old, :content_new
+        def changed_content_styles
+          {
+            content_old: theme_style(:diff, :changed, :content_old),
+            content_new: theme_style(:diff, :changed, :content_new),
+          }
+        end
+
+        # Get style for unchanged content
+        # @return [Hash] Style properties
+        def unchanged_content_style
+          theme_style(:diff, :unchanged, :content)
+        end
+
+        # Get structure styles
+        # @return [Hash] Keys: :line_number, :pipe, :context
+        def structure_styles
+          theme[:structure] || {}
+        end
+
+        # Get visualization characters
+        # @return [Hash] Keys: :space, :tab, :newline, :nbsp
+        def visualization_chars
+          theme[:visualization] || {}
+        end
+
+        # Get display mode
+        # @return [Symbol] :separate, :inline, :mixed
+        def display_mode
+          theme[:display_mode] || :separate
+        end
+
+        # Apply marker styling using theme
+        # @param text [String] Marker text (e.g., "-", "+", "*")
+        # @param diff_type [Symbol] Type of diff
+        # @return [String] Styled marker
+        def styled_marker(text, diff_type)
+          style = marker_style(diff_type)
+          return text unless @use_color && style[:color]
+
+          apply_theme_style(text, style)
+        end
+
+        # Get theme color for a specific diff type and element
+        # @param diff_type [Symbol] :removed, :added, :changed, :formatting, :informative
+        # @param element [Symbol] :marker, :content, :content_old, :content_new
+        # @return [Symbol, nil] Color value
+        def theme_color(diff_type, element)
+          theme_style(:diff, diff_type, element)[:color]
+        end
+
+        # Get structure color
+        # @param element [Symbol] :line_number, :pipe, :context
+        # @return [Symbol, nil] Color value
+        def structure_color(element)
+          theme.dig(:structure, element, :color)
+        end
+
+        # Normalize a color symbol for Rainbow presenter.
+        # Rainbow doesn't support :bright_blue directly - instead it uses
+        # chained methods like .blue.bright or .bright.blue.
+        # This returns an array of method symbols to chain.
+        #
+        # @param color [Symbol] Color like :bright_blue, :light_red, etc.
+        # @return [Array<Symbol>] Method chain for Rainbow
+        def normalize_color_for_rainbow(color)
+          return [] if color.nil?
+
+          case color.to_s
+          when /^bright_(.+)$/
+            # :bright_blue -> [:blue, :bright]
+            base = $1.to_sym
+            [base, :bright]
+          when /^light_(.+)$/
+            # :light_red -> Rainbow doesn't support light_, treat as white
+            [:white]
+          when "default", "black", "red", "green", "yellow", "blue", "magenta", "cyan", "white"
+            [color]
+          else
+            # Unknown color, return as-is and let Rainbow raise
+            [color]
+          end
+        end
+
+        # Apply a color to a Rainbow presenter, normalizing bright_/light_ colors.
+        # @param presenter [Rainbow::Presenter] The presenter to colorize
+        # @param color [Symbol] Color like :bright_blue, :red, etc.
+        # @return [Rainbow::Presenter] Colorized presenter
+        def apply_color(presenter, color)
+          valid_colors = normalize_color_for_rainbow(color)
+          valid_colors.each { |c| presenter = presenter.send(c) }
+          presenter
+        end
+
+        # Apply a background color to a Rainbow presenter.
+        # @param presenter [Rainbow::Presenter] The presenter to colorize
+        # @param bg_color [Symbol] Background color like :red, :light_blue, etc.
+        # @return [Rainbow::Presenter] Colorized presenter
+        def apply_bg(presenter, bg_color)
+          return presenter unless bg_color
+
+          case bg_color.to_s
+          when /^light_(.+)$/
+            # Rainbow doesn't support light_ backgrounds, use the base color
+            base = $1.to_sym
+            presenter.background(base)
+          when "default", "black", "red", "green", "yellow", "blue", "magenta", "cyan", "white"
+            presenter.background(bg_color)
+          else
+            # Try as-is and let Rainbow handle unknown colors
+            presenter.background(bg_color)
+          end
         end
 
         # Format line-by-line diff
@@ -167,14 +365,24 @@ module Canon
         # RSpec-aware: resets any existing ANSI codes before applying new colors
         #
         # @param text [String] Text to colorize
-        # @param colors [Array<Symbol>] Paint color arguments
+        # @param colors [Array<Symbol>] Rainbow color/effect arguments
         # @return [String] Colorized or plain text
         def colorize(text, *colors)
           return text unless @use_color
 
-          require "paint"
-          # Reset ANSI codes first to prevent RSpec's initial red from interfering
-          "\e[0m#{Paint[text, *colors]}"
+          # Filter out nil colors and normalize bright_/light_ colors
+          valid_colors = colors.compact.flat_map do |c|
+            normalize_color_for_rainbow(c)
+          end
+          return text if valid_colors.empty?
+
+          require "rainbow"
+          # Use a local Rainbow instance that ignores global TTY detection
+          rainbow = Rainbow.new
+          rainbow.enabled = true
+          presenter = rainbow.wrap(text)
+          valid_colors.each { |c| presenter = presenter.send(c) }
+          presenter.to_s
         end
 
         # Identify contiguous diff blocks
@@ -349,8 +557,8 @@ module Canon
         # @return [String] Formatted line
         def format_unified_line(old_num, new_num, marker, content, color = nil,
                                 informative: false, formatting: false)
-          old_str = old_num ? "%4d" % old_num : "    "
-          new_str = new_num ? "%4d" % new_num : "    "
+          old_str = old_num ? "%#{@line_num_width}d" % old_num : " " * @line_num_width
+          new_str = new_num ? "%#{@line_num_width}d" % new_num : " " * @line_num_width
 
           # Formatting and informative diffs use directional colors already passed in
           # No need to override since callers set the correct color
@@ -365,16 +573,18 @@ module Canon
                                end
 
           if @use_color
-            yellow_old = colorize(old_str, :yellow)
-            yellow_pipe1 = colorize("|", :yellow)
-            yellow_new = colorize(new_str, :yellow)
-            yellow_pipe2 = colorize("|", :yellow)
+            ln_color = structure_color(:line_number) || :yellow
+            pipe_color = structure_color(:pipe) || :yellow
+            ln_old = colorize(old_str, ln_color)
+            pipe1 = colorize("|", pipe_color)
+            ln_new = colorize(new_str, ln_color)
+            pipe2 = colorize("|", pipe_color)
 
             if effective_color
               colored_marker = colorize(marker, effective_color)
-              "#{yellow_old}#{yellow_pipe1}#{yellow_new}#{colored_marker} #{yellow_pipe2} #{visualized_content}"
+              "#{ln_old}#{pipe1}#{ln_new}#{colored_marker} #{pipe2} #{visualized_content}"
             else
-              "#{yellow_old}#{yellow_pipe1}#{yellow_new}#{marker} #{yellow_pipe2} #{visualized_content}"
+              "#{ln_old}#{pipe1}#{ln_new}#{marker} #{pipe2} #{visualized_content}"
             end
           else
             "#{old_str}|#{new_str}#{marker_part}| #{visualized_content}"
@@ -409,19 +619,24 @@ module Canon
           old_visualized = apply_visualization(old_text, old_color)
           new_visualized = apply_visualization(new_text, new_color)
 
+          fmt = "%#{@line_num_width}d"
+          blank = " " * @line_num_width
+
           if @use_color
-            yellow_old = colorize("%4d" % old_line, :yellow)
-            yellow_pipe1 = colorize("|", :yellow)
-            yellow_new = colorize("%4d" % new_line, :yellow)
-            yellow_pipe2 = colorize("|", :yellow)
+            ln_color = structure_color(:line_number) || :yellow
+            pipe_color = structure_color(:pipe) || :yellow
+            ln_old = colorize(fmt % old_line, ln_color)
+            pipe1 = colorize("|", pipe_color)
+            ln_new = colorize(fmt % new_line, ln_color)
+            pipe2 = colorize("|", pipe_color)
             old_marker_colored = colorize(old_marker, old_color)
             new_marker_colored = colorize(new_marker, new_color)
 
-            output << "#{yellow_old}#{yellow_pipe1}    #{old_marker_colored} #{yellow_pipe2} #{old_visualized}"
-            output << "    #{yellow_pipe1}#{yellow_new}#{new_marker_colored} #{yellow_pipe2} #{new_visualized}"
+            output << "#{ln_old}#{pipe1}#{blank}#{old_marker_colored} #{pipe2} #{old_visualized}"
+            output << "#{blank}#{pipe1}#{ln_new}#{new_marker_colored} #{pipe2} #{new_visualized}"
           else
-            output << "#{'%4d' % old_line}|    #{old_marker} | #{old_visualized}"
-            output << "    |#{'%4d' % new_line}#{new_marker} | #{new_visualized}"
+            output << "#{fmt % old_line}|#{blank}#{old_marker} | #{old_visualized}"
+            output << "#{blank}|#{fmt % new_line}#{new_marker} | #{new_visualized}"
           end
 
           output.join("\n")
@@ -440,8 +655,24 @@ module Canon
           end.join
 
           if color && @use_color
-            require "paint"
-            Paint[visual, color, :bold]
+            require "rainbow"
+            rainbow = Rainbow.new
+            rainbow.enabled = true
+            presenter = rainbow.wrap(visual)
+
+            # Handle Rainbow color methods - :bright_blue -> .blue.bright, etc.
+            if color.to_s.start_with?("bright_")
+              base_color = color.to_s.sub(/^bright_/, "").to_sym
+              presenter = presenter.send(base_color).bright
+            elsif color.to_s.start_with?("light_")
+              # Rainbow doesn't have light_ versions, treat as white on bg
+              base_color = color.to_s.sub(/^light_/, "").to_sym
+              presenter = presenter.send(base_color)
+            else
+              presenter = presenter.send(color)
+            end
+
+            presenter.to_s
           else
             visual
           end
@@ -528,6 +759,15 @@ module Canon
         #
         # @return [Boolean] True if diff display should be skipped
         def should_skip_diff_display?
+          # If documents are equivalent and there are no normative diffs,
+          # skip display entirely - showing even informative diffs when
+          # equivalent is misleading
+          if @equivalent == true
+            return @differences.none? do |diff|
+              diff.is_a?(Canon::Diff::DiffNode) && diff.normative?
+            end
+          end
+
           return false if @differences.nil? || @differences.empty?
 
           case @show_diffs