canon 0.1.6 → 0.1.7

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

@@ -186,31 +186,83 @@ module Canon
                                             diff_line.content)
             when :removed
               line_num = diff_line.line_number + 1
+              formatting = diff_line.formatting?
               informative = diff_line.informative?
-              output << format_unified_line(line_num, nil, "-",
-                                            diff_line.content,
-                                            informative ? :cyan : :red,
-                                            informative: informative)
+
+              output << if formatting
+                          # Formatting-only removal: [ marker in dark gray
+                          format_unified_line(line_num, nil, "[",
+                                              diff_line.content,
+                                              :black,
+                                              formatting: true)
+                        elsif informative
+                          # Informative removal: < marker in blue
+                          format_unified_line(line_num, nil, "<",
+                                              diff_line.content,
+                                              :blue,
+                                              informative: true)
+                        else
+                          # Normative removal: - marker in red
+                          format_unified_line(line_num, nil, "-",
+                                              diff_line.content,
+                                              :red)
+                        end
             when :added
               line_num = diff_line.line_number + 1
+              formatting = diff_line.formatting?
               informative = diff_line.informative?
-              output << format_unified_line(nil, line_num, "+",
-                                            diff_line.content,
-                                            informative ? :cyan : :green,
-                                            informative: informative)
+
+              output << if formatting
+                          # Formatting-only addition: ] marker in light gray
+                          format_unified_line(nil, line_num, "]",
+                                              diff_line.content,
+                                              :white,
+                                              formatting: true)
+                        elsif informative
+                          # Informative addition: > marker in cyan
+                          format_unified_line(nil, line_num, ">",
+                                              diff_line.content,
+                                              :cyan,
+                                              informative: true)
+                        else
+                          # Normative addition: + marker in green
+                          format_unified_line(nil, line_num, "+",
+                                              diff_line.content,
+                                              :green)
+                        end
             when :changed
               line_num = diff_line.line_number + 1
+              formatting = diff_line.formatting?
               informative = diff_line.informative?
               old_content = lines1[diff_line.line_number]
               new_content = diff_line.content
-              output << format_unified_line(line_num, nil, "-",
-                                            old_content,
-                                            informative ? :cyan : :red,
-                                            informative: informative)
-              output << format_unified_line(nil, line_num, "+",
-                                            new_content,
-                                            informative ? :cyan : :green,
-                                            informative: informative)
+
+              if formatting
+                output << format_unified_line(line_num, nil, "[",
+                                              old_content,
+                                              :black,
+                                              formatting: true)
+                output << format_unified_line(nil, line_num, "]",
+                                              new_content,
+                                              :white,
+                                              formatting: true)
+              elsif informative
+                output << format_unified_line(line_num, nil, "<",
+                                              old_content,
+                                              :blue,
+                                              informative: true)
+                output << format_unified_line(nil, line_num, ">",
+                                              new_content,
+                                              :cyan,
+                                              informative: true)
+              else
+                output << format_unified_line(line_num, nil, "-",
+                                              old_content,
+                                              :red)
+                output << format_unified_line(nil, line_num, "+",
+                                              new_content,
+                                              :green)
+              end
             end
           end
 

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

@@ -114,43 +114,6 @@ module Canon
           output.join("\n")
         end
 
-        # Format a unified diff line
-        #
-        # @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 content [String] Line content
-        # @param color [Symbol, nil] Color for diff lines
-        # @return [String] Formatted line
-        def format_unified_line(old_num, new_num, marker, content, color = nil)
-          old_str = old_num ? "%4d" % old_num : "    "
-          new_str = new_num ? "%4d" % new_num : "    "
-          marker_part = "#{marker} "
-
-          visualized_content = if color
-                                 apply_visualization(content,
-                                                     color)
-                               else
-                                 content
-                               end
-
-          if @use_color
-            yellow_old = colorize(old_str, :yellow)
-            yellow_pipe1 = colorize("|", :yellow)
-            yellow_new = colorize(new_str, :yellow)
-            yellow_pipe2 = colorize("|", :yellow)
-
-            if color
-              colored_marker = colorize(marker, color)
-              "#{yellow_old}#{yellow_pipe1}#{yellow_new}#{colored_marker} #{yellow_pipe2} #{visualized_content}"
-            else
-              "#{yellow_old}#{yellow_pipe1}#{yellow_new}#{marker} #{yellow_pipe2} #{visualized_content}"
-            end
-          else
-            "#{old_str}|#{new_str}#{marker_part}| #{visualized_content}"
-          end
-        end
-
         # Format token diff lines
         #
         # @param old_line [Integer] Old line number

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

@@ -89,48 +89,6 @@ module Canon
           output.join("\n")
         end
 
-        # Format a unified diff line
-        #
-        # @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 content [String] Line content
-        # @param color [Symbol, nil] Color for diff lines
-        # @return [String] Formatted line
-        def format_unified_line(old_num, new_num, marker, content, color = nil)
-          old_str = old_num ? "%4d" % old_num : "    "
-          new_str = new_num ? "%4d" % new_num : "    "
-          marker_part = "#{marker} "
-
-          # Only apply visualization to diff lines (when color is provided),
-          # not context lines
-          visualized_content = if color
-                                 apply_visualization(content, color)
-                               else
-                                 content
-                               end
-
-          if @use_color
-            # Yellow for line numbers and pipes
-            yellow_old = colorize(old_str, :yellow)
-            yellow_pipe1 = colorize("|", :yellow)
-            yellow_new = colorize(new_str, :yellow)
-            yellow_pipe2 = colorize("|", :yellow)
-
-            if color
-              # Colored marker for additions/deletions
-              colored_marker = colorize(marker, color)
-              "#{yellow_old}#{yellow_pipe1}#{yellow_new}#{colored_marker} #{yellow_pipe2} #{visualized_content}"
-            else
-              # Context line - apply visualization but no color
-              "#{yellow_old}#{yellow_pipe1}#{yellow_new}#{marker} #{yellow_pipe2} #{visualized_content}"
-            end
-          else
-            # No color mode
-            "#{old_str}|#{new_str}#{marker_part}| #{visualized_content}"
-          end
-        end
-
         # Format changed lines with basic character-level diff
         #
         # @param line_num [Integer] Line number

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

@@ -99,33 +99,85 @@ module Canon
                                             diff_line.content)
             when :removed
               line_num = diff_line.line_number + 1
+              formatting = diff_line.formatting?
               informative = diff_line.informative?
-              output << format_unified_line(line_num, nil, "-",
-                                            diff_line.content,
-                                            informative ? :cyan : :red,
-                                            informative: informative)
+
+              output << if formatting
+                          # Formatting-only removal: [ marker in dark gray
+                          format_unified_line(line_num, nil, "[",
+                                              diff_line.content,
+                                              :black,
+                                              formatting: true)
+                        elsif informative
+                          # Informative removal: < marker in blue
+                          format_unified_line(line_num, nil, "<",
+                                              diff_line.content,
+                                              :blue,
+                                              informative: true)
+                        else
+                          # Normative removal: - marker in red
+                          format_unified_line(line_num, nil, "-",
+                                              diff_line.content,
+                                              :red)
+                        end
             when :added
               line_num = diff_line.line_number + 1
+              formatting = diff_line.formatting?
               informative = diff_line.informative?
-              output << format_unified_line(nil, line_num, "+",
-                                            diff_line.content,
-                                            informative ? :cyan : :green,
-                                            informative: informative)
+
+              output << if formatting
+                          # Formatting-only addition: ] marker in light gray
+                          format_unified_line(nil, line_num, "]",
+                                              diff_line.content,
+                                              :white,
+                                              formatting: true)
+                        elsif informative
+                          # Informative addition: > marker in cyan
+                          format_unified_line(nil, line_num, ">",
+                                              diff_line.content,
+                                              :cyan,
+                                              informative: true)
+                        else
+                          # Normative addition: + marker in green
+                          format_unified_line(nil, line_num, "+",
+                                              diff_line.content,
+                                              :green)
+                        end
             when :changed
               line_num = diff_line.line_number + 1
+              formatting = diff_line.formatting?
               informative = diff_line.informative?
               # For changed lines, we need both old and new content
               # For now, show as removed + added
               old_content = lines1[diff_line.line_number]
               new_content = diff_line.content
-              output << format_unified_line(line_num, nil, "-",
-                                            old_content,
-                                            informative ? :cyan : :red,
-                                            informative: informative)
-              output << format_unified_line(nil, line_num, "+",
-                                            new_content,
-                                            informative ? :cyan : :green,
-                                            informative: informative)
+
+              if formatting
+                output << format_unified_line(line_num, nil, "[",
+                                              old_content,
+                                              :black,
+                                              formatting: true)
+                output << format_unified_line(nil, line_num, "]",
+                                              new_content,
+                                              :white,
+                                              formatting: true)
+              elsif informative
+                output << format_unified_line(line_num, nil, "<",
+                                              old_content,
+                                              :blue,
+                                              informative: true)
+                output << format_unified_line(nil, line_num, ">",
+                                              new_content,
+                                              :cyan,
+                                              informative: true)
+              else
+                output << format_unified_line(line_num, nil, "-",
+                                              old_content,
+                                              :red)
+                output << format_unified_line(nil, line_num, "+",
+                                              new_content,
+                                              :green)
+              end
             end
           end
 
@@ -626,6 +678,8 @@ module Canon
 
         # Format a context
         def format_context(context, diffs, base_line1, base_line2)
+          require_relative "../../diff/formatting_detector"
+
           output = []
 
           (context.start_idx..context.end_idx).each do |idx|
@@ -639,22 +693,53 @@ module Canon
               output << format_unified_line(line1, line2, " ",
                                             change.old_element)
             when "-"
-              output << format_unified_line(line1, nil, "-",
-                                            change.old_element, :red)
+              # Check if removal is formatting-only
+              output << if Canon::Diff::FormattingDetector.formatting_only?(
+                change.old_element, ""
+              )
+                          format_unified_line(line1, nil, "[",
+                                              change.old_element, :black,
+                                              formatting: true)
+                        else
+                          format_unified_line(line1, nil, "-",
+                                              change.old_element, :red)
+                        end
             when "+"
-              output << format_unified_line(nil, line2, "+",
-                                            change.new_element, :green)
+              # Check if addition is formatting-only
+              output << if Canon::Diff::FormattingDetector.formatting_only?("",
+                                                                            change.new_element)
+                          format_unified_line(nil, line2, "]",
+                                              change.new_element, :white,
+                                              formatting: true)
+                        else
+                          format_unified_line(nil, line2, "+",
+                                              change.new_element, :green)
+                        end
             when "!"
-              # Token-level highlighting
-              old_tokens = tokenize_xml(change.old_element)
-              new_tokens = tokenize_xml(change.new_element)
-              token_diffs = ::Diff::LCS.sdiff(old_tokens, new_tokens)
-
-              old_highlighted = build_token_highlighted_text(token_diffs, :old)
-              new_highlighted = build_token_highlighted_text(token_diffs, :new)
-
-              output << format_token_diff_line(line1, line2, old_highlighted,
-                                               new_highlighted)
+              # Check if change is formatting-only
+              if Canon::Diff::FormattingDetector.formatting_only?(
+                change.old_element, change.new_element
+              )
+                output << format_unified_line(line1, nil, "[",
+                                              change.old_element, :black,
+                                              formatting: true)
+                output << format_unified_line(nil, line2, "]",
+                                              change.new_element, :white,
+                                              formatting: true)
+              else
+                # Token-level highlighting
+                old_tokens = tokenize_xml(change.old_element)
+                new_tokens = tokenize_xml(change.new_element)
+                token_diffs = ::Diff::LCS.sdiff(old_tokens, new_tokens)
+
+                old_highlighted = build_token_highlighted_text(token_diffs,
+                                                               :old)
+                new_highlighted = build_token_highlighted_text(token_diffs,
+                                                               :new)
+
+                output << format_token_diff_line(line1, line2, old_highlighted,
+                                                 new_highlighted)
+              end
             end
           end
 
@@ -722,7 +807,7 @@ module Canon
 
         # Format a unified diff 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} "

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

@@ -113,43 +113,6 @@ module Canon
           output.join("\n")
         end
 
-        # Format a unified diff line
-        #
-        # @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 content [String] Line content
-        # @param color [Symbol, nil] Color for diff lines
-        # @return [String] Formatted line
-        def format_unified_line(old_num, new_num, marker, content, color = nil)
-          old_str = old_num ? "%4d" % old_num : "    "
-          new_str = new_num ? "%4d" % new_num : "    "
-          marker_part = "#{marker} "
-
-          visualized_content = if color
-                                 apply_visualization(content,
-                                                     color)
-                               else
-                                 content
-                               end
-
-          if @use_color
-            yellow_old = colorize(old_str, :yellow)
-            yellow_pipe1 = colorize("|", :yellow)
-            yellow_new = colorize(new_str, :yellow)
-            yellow_pipe2 = colorize("|", :yellow)
-
-            if color
-              colored_marker = colorize(marker, color)
-              "#{yellow_old}#{yellow_pipe1}#{yellow_new}#{colored_marker} #{yellow_pipe2} #{visualized_content}"
-            else
-              "#{yellow_old}#{yellow_pipe1}#{yellow_new}#{marker} #{yellow_pipe2} #{visualized_content}"
-            end
-          else
-            "#{old_str}|#{new_str}#{marker_part}| #{visualized_content}"
-          end
-        end
-
         # Format token diff lines
         #
         # @param old_line [Integer] Old line number

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

@@ -8,10 +8,12 @@ module Canon
       class BaseFormatter
         attr_reader :use_color, :visualization_map
 
-        def initialize(use_color: true, visualization_map: nil)
+        def initialize(use_color: true, visualization_map: nil,
+show_diffs: :all)
           @use_color = use_color
           @visualization_map = visualization_map ||
-            DiffFormatter::DEFAULT_VISUALIZATION_MAP
+            Canon::DiffFormatter::DEFAULT_VISUALIZATION_MAP
+          @show_diffs = show_diffs
         end
 
         # Format differences for display
@@ -35,37 +37,90 @@ module Canon
           output = []
           output << colorize("Visual Diff:", :cyan, :bold)
 
+          # Filter differences for display based on show_diffs setting
+          filtered_diffs = filter_differences_for_display(diffs_array)
+
           # Group differences by path for tree building
-          tree = build_diff_tree(diffs_array)
+          tree = build_diff_tree(filtered_diffs)
+
+          # Render tree with line counting
+          @line_count = 0
+          @max_lines = get_max_diff_lines
+          rendered = render_tree(tree)
+
+          # Add truncation notice if needed
+          if @truncated
+            rendered += "\n\n"
+            rendered += colorize(
+              "... Output truncated at #{@max_lines} lines ...", :yellow, :bold
+            )
+            rendered += "\n"
+            rendered += colorize(
+              "Increase limit via CANON_MAX_DIFF_LINES or config.diff.max_diff_lines", :yellow
+            )
+          end
 
-          # Render tree
-          output << render_tree(tree)
+          output << rendered
 
           output.join("\n")
         end
 
         # Factory method to create format-specific formatter
-        def self.for_format(format, use_color: true, visualization_map: nil)
+        def self.for_format(format, use_color: true, visualization_map: nil,
+show_diffs: :all)
           case format
           when :xml, :html
             require_relative "xml_formatter"
             XmlFormatter.new(use_color: use_color,
-                             visualization_map: visualization_map)
+                             visualization_map: visualization_map,
+                             show_diffs: show_diffs)
           when :json
             require_relative "json_formatter"
             JsonFormatter.new(use_color: use_color,
-                              visualization_map: visualization_map)
+                              visualization_map: visualization_map,
+                              show_diffs: show_diffs)
           when :yaml
             require_relative "yaml_formatter"
             YamlFormatter.new(use_color: use_color,
-                              visualization_map: visualization_map)
+                              visualization_map: visualization_map,
+                              show_diffs: show_diffs)
           else
-            new(use_color: use_color, visualization_map: visualization_map)
+            new(use_color: use_color, visualization_map: visualization_map,
+                show_diffs: show_diffs)
           end
         end
 
         private
 
+        # 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
+
         # Generate success message
         def success_message
           emoji = @use_color ? "✅ " : ""
@@ -104,7 +159,9 @@ module Canon
           parts.each_with_index do |part, index|
             current[part] ||= {}
             if index == parts.length - 1
-              current[part][:__diff__] = diff
+              # Support multiple diffs at the same path
+              current[part][:__diffs__] ||= []
+              current[part][:__diffs__] << diff
             else
               current = current[part]
             end
@@ -135,9 +192,24 @@ module Canon
 
           parts = []
           current = node
+          visited = Set.new
 
           while current.respond_to?(:name)
+            # Prevent infinite loops by tracking visited nodes
+            break if visited.include?(current.object_id)
+
+            visited << current.object_id
+
             parts.unshift(current.name) if current.name
+
+            # Stop at document or fragment roots
+            break if current.is_a?(Nokogiri::XML::Document) ||
+              current.is_a?(Nokogiri::HTML4::Document) ||
+              current.is_a?(Nokogiri::HTML5::Document) ||
+              current.is_a?(Nokogiri::XML::DocumentFragment) ||
+              current.is_a?(Nokogiri::HTML4::DocumentFragment) ||
+              current.is_a?(Nokogiri::HTML5::DocumentFragment)
+
             current = current.parent if current.respond_to?(:parent)
           end
 
@@ -148,7 +220,7 @@ module Canon
         def render_tree(tree, prefix: "", is_last: true)
           output = []
 
-          sorted_keys = tree.keys.reject { |k| k == :__diff__ }
+          sorted_keys = tree.keys.reject { |k| k == :__diffs__ }
           begin
             sorted_keys = sorted_keys.sort_by(&:to_s)
           rescue ArgumentError
@@ -156,25 +228,50 @@ module Canon
           end
 
           sorted_keys.each_with_index do |key, index|
+            # Check line limit
+            if @max_lines&.positive? && @line_count >= @max_lines
+              @truncated = true
+              break
+            end
+
             is_last_item = (index == sorted_keys.length - 1)
             connector = is_last_item ? "└── " : "├── "
             continuation = is_last_item ? "    " : "│   "
 
             value = tree[key]
-            diff = value[:__diff__] if value.is_a?(Hash)
-
-            if diff
-              # Render difference
-              output << render_diff_node(key, diff, prefix, connector)
+            diffs = value[:__diffs__] if value.is_a?(Hash)
+
+            if diffs && !diffs.empty?
+              # Render all differences at this path
+              diffs.each_with_index do |diff, diff_idx|
+                # Use proper connector for each diff
+                current_connector = if diff_idx == diffs.length - 1
+                                      connector
+                                    else
+                                      is_last_item ? "├── " : "├── "
+                                    end
+
+                line = render_diff_node(key, diff, prefix, current_connector)
+                output << line
+                @line_count += line.count("\n") + 1
+              end
             else
               # Render intermediate path
-              output << colorize("#{prefix}#{connector}#{key}:", :cyan)
+              line = colorize("#{prefix}#{connector}#{key}:", :cyan)
+              output << line
+              @line_count += 1
+
               # Recurse into subtree
               if value.is_a?(Hash)
-                output << render_tree(value, prefix: prefix + continuation,
+                subtree = render_tree(value, prefix: prefix + continuation,
                                              is_last: is_last_item)
+                output << subtree
+                # line_count already updated in recursive call
               end
             end
+
+            # Check again after adding content
+            break if @truncated
           end
 
           output.join("\n")
@@ -193,6 +290,16 @@ module Canon
           require "paint"
           "\e[0m#{Paint[text, *colors]}"
         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