canon 0.1.2 → 0.1.5

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

@@ -0,0 +1,284 @@
+# frozen_string_literal: true
+
+require_relative "base_formatter"
+require_relative "../legend"
+require "strscan"
+
+module Canon
+  class DiffFormatter
+    module ByLine
+      # JSON formatter with semantic token-level highlighting
+      # Pretty-prints JSON before diffing for better structure awareness
+      class JsonFormatter < BaseFormatter
+        # Format semantic JSON diff with token-level highlighting
+        #
+        # @param doc1 [String] First JSON document
+        # @param doc2 [String] Second JSON document
+        # @return [String] Formatted diff
+        def format(doc1, doc2)
+          output = []
+
+          begin
+            # Pretty print both JSON files
+            require "canon/pretty_printer/json"
+            formatter = Canon::PrettyPrinter::Json.new(indent: 2)
+            pretty1 = formatter.format(doc1)
+            pretty2 = formatter.format(doc2)
+
+            lines1 = pretty1.split("\n")
+            lines2 = pretty2.split("\n")
+
+            # Get LCS diff
+            diffs = ::Diff::LCS.sdiff(lines1, lines2)
+
+            # Format with semantic token highlighting
+            output << format_semantic_diff(diffs, lines1, lines2)
+          rescue StandardError => e
+            output << colorize(
+              "Warning: JSON parsing failed (#{e.message}), using simple diff", :yellow
+            )
+            require_relative "simple_formatter"
+            simple = SimpleFormatter.new(
+              use_color: @use_color,
+              context_lines: @context_lines,
+              diff_grouping_lines: @diff_grouping_lines,
+              visualization_map: @visualization_map,
+            )
+            output << simple.format(doc1, doc2)
+          end
+
+          output.join("\n")
+        end
+
+        private
+
+        # Format semantic diff with token-level highlighting
+        #
+        # @param diffs [Array] LCS diff array
+        # @param lines1 [Array<String>] Lines from first document
+        # @param lines2 [Array<String>] Lines from second document
+        # @return [String] Formatted diff
+        def format_semantic_diff(diffs, lines1, lines2)
+          output = []
+
+          # Detect non-ASCII characters in the diff
+          all_text = (lines1 + lines2).join
+          non_ascii = Legend.detect_non_ascii(all_text, @visualization_map)
+
+          # Add Unicode legend if any non-ASCII characters detected
+          unless non_ascii.empty?
+            output << Legend.build_legend(non_ascii, use_color: @use_color)
+            output << ""
+          end
+
+          diffs.each do |change|
+            old_line = change.old_position ? change.old_position + 1 : nil
+            new_line = change.new_position ? change.new_position + 1 : nil
+
+            case change.action
+            when "="
+              # Unchanged line
+              output << format_unified_line(old_line, new_line, " ",
+                                            change.old_element)
+            when "-"
+              # Deletion
+              output << format_unified_line(old_line, nil, "-",
+                                            change.old_element, :red)
+            when "+"
+              # Addition
+              output << format_unified_line(nil, new_line, "+",
+                                            change.new_element, :green)
+            when "!"
+              # Change - show with semantic token highlighting
+              old_text = change.old_element
+              new_text = change.new_element
+
+              # Tokenize JSON
+              old_tokens = tokenize_json(old_text)
+              new_tokens = tokenize_json(new_text)
+
+              # Get token-level diff
+              token_diffs = ::Diff::LCS.sdiff(old_tokens, new_tokens)
+
+              # Build highlighted versions
+              old_highlighted = build_token_highlighted_text(token_diffs, :old)
+              new_highlighted = build_token_highlighted_text(token_diffs, :new)
+
+              # Format both lines
+              output << format_token_diff_line(old_line, new_line,
+                                               old_highlighted,
+                                               new_highlighted)
+            end
+          end
+
+          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
+        # @param new_line [Integer] New line number
+        # @param old_highlighted [String] Highlighted old text
+        # @param new_highlighted [String] Highlighted new text
+        # @return [String] Formatted lines
+        def format_token_diff_line(old_line, new_line, old_highlighted,
+                                    new_highlighted)
+          output = []
+
+          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)
+            red_marker = colorize("-", :red)
+            green_marker = colorize("+", :green)
+
+            output << "#{yellow_old}#{yellow_pipe1}    #{red_marker} #{yellow_pipe2} #{old_highlighted}"
+            output << "    #{yellow_pipe1}#{yellow_new}#{green_marker} #{yellow_pipe2} #{new_highlighted}"
+          else
+            output << "#{'%4d' % old_line}|    - | #{old_highlighted}"
+            output << "    |#{'%4d' % new_line}+ | #{new_highlighted}"
+          end
+
+          output.join("\n")
+        end
+
+        # Tokenize JSON line into meaningful tokens
+        #
+        # @param line [String] JSON line to tokenize
+        # @return [Array<String>] Tokens
+        def tokenize_json(line)
+          tokens = []
+          scanner = StringScanner.new(line)
+
+          until scanner.eos?
+            tokens << if scanner.scan(/\s+/)
+                        # Whitespace
+                        scanner.matched
+                      elsif scanner.scan(/"(?:[^"\\]|\\.)*"/)
+                        # String values (with quotes)
+                        scanner.matched
+                      elsif scanner.scan(/-?\d+\.?\d*(?:[eE][+-]?\d+)?/)
+                        # Numbers
+                        scanner.matched
+                      elsif scanner.scan(/\b(?:true|false|null)\b/)
+                        # Booleans and null
+                        scanner.matched
+                      elsif scanner.scan(/[{}\[\]:,]/)
+                        # Structural characters
+                        scanner.matched
+                      else
+                        # Any other character
+                        scanner.getch
+                      end
+          end
+
+          tokens
+        end
+
+        # Build highlighted text from token diff
+        #
+        # @param token_diffs [Array] Token-level diff
+        # @param side [Symbol] Which side (:old or :new)
+        # @return [String] Highlighted text
+        def build_token_highlighted_text(token_diffs, side)
+          parts = []
+
+          token_diffs.each do |change|
+            case change.action
+            when "="
+              # Unchanged token - apply visualization with explicit reset
+              visual = change.old_element.chars.map do |char|
+                @visualization_map.fetch(char, char)
+              end.join
+
+              parts << if @use_color
+                         colorize(visual, :default)
+                       else
+                         visual
+                       end
+            when "-"
+              # Deleted token (only show on old side)
+              if side == :old
+                token = change.old_element
+                parts << apply_visualization(token, :red)
+              end
+            when "+"
+              # Added token (only show on new side)
+              if side == :new
+                token = change.new_element
+                parts << apply_visualization(token, :green)
+              end
+            when "!"
+              # Changed token
+              if side == :old
+                token = change.old_element
+                parts << apply_visualization(token, :red)
+              else
+                token = change.new_element
+                parts << apply_visualization(token, :green)
+              end
+            end
+          end
+
+          parts.join
+        end
+
+        # Apply character visualization
+        #
+        # @param token [String] Token to visualize
+        # @param color [Symbol, nil] Optional color
+        # @return [String] Visualized token
+        def apply_visualization(token, color = nil)
+          visual = token.chars.map do |char|
+            @visualization_map.fetch(char, char)
+          end.join
+
+          if color && @use_color
+            require "paint"
+            Paint[visual, color, :bold]
+          else
+            visual
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+require_relative "base_formatter"
+require_relative "../legend"
+
+module Canon
+  class DiffFormatter
+    module ByLine
+      # Simple line-based formatter (fallback)
+      # Uses basic LCS diff without format-specific intelligence
+      class SimpleFormatter < BaseFormatter
+        # Format simple line-by-line diff
+        #
+        # @param doc1 [String] First document
+        # @param doc2 [String] Second document
+        # @return [String] Formatted diff
+        def format(doc1, doc2)
+          output = []
+          # Use split with -1 to preserve trailing empty strings (from trailing \n)
+          lines1 = doc1.split("\n", -1)
+          lines2 = doc2.split("\n", -1)
+
+          # Detect non-ASCII characters in the diff
+          all_text = (lines1 + lines2).join
+          non_ascii = Legend.detect_non_ascii(all_text, @visualization_map)
+
+          # Add Unicode legend if any non-ASCII characters detected
+          unless non_ascii.empty?
+            output << Legend.build_legend(non_ascii, use_color: @use_color)
+            output << ""
+          end
+
+          # Get LCS diff
+          diffs = ::Diff::LCS.sdiff(lines1, lines2)
+
+          # Group into hunks with context
+          hunks = build_hunks(diffs, lines1, lines2,
+                              context_lines: @context_lines)
+
+          # Format each hunk
+          hunks.each do |hunk|
+            output << format_hunk(hunk)
+          end
+
+          output.join("\n")
+        end
+
+        private
+
+        # Format a hunk of changes
+        #
+        # @param hunk [Array] Hunk of diff changes
+        # @return [String] Formatted hunk
+        def format_hunk(hunk)
+          output = []
+          old_line = hunk.first.old_position + 1
+          new_line = hunk.first.new_position + 1
+
+          hunk.each do |change|
+            case change.action
+            when "="
+              # Unchanged line (context)
+              output << format_unified_line(old_line, new_line, " ",
+                                            change.old_element)
+              old_line += 1
+              new_line += 1
+            when "-"
+              # Deletion
+              output << format_unified_line(old_line, nil, "-",
+                                            change.old_element, :red)
+              old_line += 1
+            when "+"
+              # Addition
+              output << format_unified_line(nil, new_line, "+",
+                                            change.new_element, :green)
+              new_line += 1
+            when "!"
+              # Change - show both with inline diff highlighting
+              old_text = change.old_element
+              new_text = change.new_element
+
+              # Format with inline highlighting
+              output << format_changed_line(old_line, old_text, new_text)
+              old_line += 1
+              new_line += 1
+            end
+          end
+
+          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
+        # @param old_text [String] Old line text
+        # @param new_text [String] New line text
+        # @return [String] Formatted change
+        def format_changed_line(line_num, old_text, new_text)
+          output = []
+
+          # Apply visualization
+          old_visualized = apply_visualization(old_text, :red)
+          new_visualized = apply_visualization(new_text, :green)
+
+          # Format both lines with yellow line numbers and pipes
+          if @use_color
+            yellow_old = colorize("%4d" % line_num, :yellow)
+            yellow_pipe1 = colorize("|", :yellow)
+            yellow_new = colorize("%4d" % line_num, :yellow)
+            yellow_pipe2 = colorize("|", :yellow)
+            red_marker = colorize("-", :red)
+            green_marker = colorize("+", :green)
+
+            output << "#{yellow_old}#{yellow_pipe1}    #{red_marker} #{yellow_pipe2} #{old_visualized}"
+            output << "    #{yellow_pipe1}#{yellow_new}#{green_marker} #{yellow_pipe2} #{new_visualized}"
+          else
+            old_str = "%4d" % line_num
+            new_str = "%4d" % line_num
+            output << "#{old_str}|    - | #{old_visualized}"
+            output << "    |#{new_str}+ | #{new_visualized}"
+          end
+
+          output.join("\n")
+        end
+
+        # Apply character visualization using configurable visualization map
+        #
+        # @param token [String] The token to apply visualization to
+        # @param color [Symbol, nil] Optional color to apply
+        # @return [String] Visualized and optionally colored token
+        def apply_visualization(token, color = nil)
+          # Replace each character with its visualization from the map
+          visual = token.chars.map do |char|
+            @visualization_map.fetch(char, char)
+          end.join
+
+          # Apply color if provided and color is enabled
+          if color && @use_color
+            require "paint"
+            Paint[visual, color, :bold]
+          else
+            visual
+          end
+        end
+      end
+    end
+  end
+end