canon 0.1.2 → 0.1.5

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

@@ -0,0 +1,292 @@
+# frozen_string_literal: true
+
+require_relative "base_formatter"
+require_relative "../legend"
+require "strscan"
+
+module Canon
+  class DiffFormatter
+    module ByLine
+      # YAML formatter with semantic token-level highlighting
+      # Pretty-prints YAML before diffing for better structure awareness
+      class YamlFormatter < BaseFormatter
+        # Format semantic YAML diff with token-level highlighting
+        #
+        # @param doc1 [String] First YAML document
+        # @param doc2 [String] Second YAML document
+        # @return [String] Formatted diff
+        def format(doc1, doc2)
+          output = []
+
+          begin
+            # Pretty print both YAML files (canonicalized)
+            require "canon"
+            pretty1 = Canon.format(doc1, :yaml)
+            pretty2 = Canon.format(doc2, :yaml)
+
+            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: YAML 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 YAML
+              old_tokens = tokenize_yaml(old_text)
+              new_tokens = tokenize_yaml(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 YAML line into meaningful tokens
+        #
+        # @param line [String] YAML line to tokenize
+        # @return [Array<String>] Tokens
+        def tokenize_yaml(line)
+          tokens = []
+          scanner = StringScanner.new(line)
+
+          until scanner.eos?
+            tokens << if scanner.scan(/\s+/)
+                        # Whitespace (preserve for indentation)
+                        scanner.matched
+                      elsif scanner.scan(/[\w-]+:/)
+                        # YAML key with colon
+                        scanner.matched
+                      elsif scanner.scan(/"(?:[^"\\]|\\.)*"/)
+                        # Quoted strings
+                        scanner.matched
+                      elsif scanner.scan(/'(?:[^'\\]|\\.)*'/)
+                        # Single-quoted strings
+                        scanner.matched
+                      elsif scanner.scan(/-?\d+\.?\d*/)
+                        # Numbers
+                        scanner.matched
+                      elsif scanner.scan(/\b(?:true|false|yes|no)\b/)
+                        # Booleans
+                        scanner.matched
+                      elsif scanner.scan(/-\s/)
+                        # List markers
+                        scanner.matched
+                      elsif scanner.scan(/[^\s:]+/)
+                        # Bare words (unquoted values)
+                        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_object/base_formatter.rb

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+
+module Canon
+  class DiffFormatter
+    module ByObject
+      # Base class for by-object diff formatters
+      # Provides tree visualization for semantic differences
+      class BaseFormatter
+        attr_reader :use_color, :visualization_map
+
+        def initialize(use_color: true, visualization_map: nil)
+          @use_color = use_color
+          @visualization_map = visualization_map ||
+            DiffFormatter::DEFAULT_VISUALIZATION_MAP
+        end
+
+        # Format differences for display
+        # @param differences [ComparisonResult, Array] ComparisonResult object or legacy Array
+        # @param format [Symbol] Format type (:xml, :html, :json, :yaml)
+        # @return [String] Formatted output
+        def format(differences, _format)
+          # Handle both ComparisonResult (production) and Array (low-level tests)
+          if differences.respond_to?(:equivalent?)
+            # ComparisonResult object
+            return success_message if differences.equivalent?
+
+            diffs_array = differences.differences
+          else
+            # Legacy Array
+            return success_message if differences.empty?
+
+            diffs_array = differences
+          end
+
+          output = []
+          output << colorize("Visual Diff:", :cyan, :bold)
+
+          # Group differences by path for tree building
+          tree = build_diff_tree(diffs_array)
+
+          # Render tree
+          output << render_tree(tree)
+
+          output.join("\n")
+        end
+
+        # Factory method to create format-specific formatter
+        def self.for_format(format, use_color: true, visualization_map: nil)
+          case format
+          when :xml, :html
+            require_relative "xml_formatter"
+            XmlFormatter.new(use_color: use_color,
+                             visualization_map: visualization_map)
+          when :json
+            require_relative "json_formatter"
+            JsonFormatter.new(use_color: use_color,
+                              visualization_map: visualization_map)
+          when :yaml
+            require_relative "yaml_formatter"
+            YamlFormatter.new(use_color: use_color,
+                              visualization_map: visualization_map)
+          else
+            new(use_color: use_color, visualization_map: visualization_map)
+          end
+        end
+
+        private
+
+        # Generate success message
+        def success_message
+          emoji = @use_color ? "✅ " : ""
+          message = "Files are semantically equivalent"
+          colorize("#{emoji}#{message}\n", :green, :bold)
+        end
+
+        # Build a tree structure from differences
+        def build_diff_tree(differences)
+          tree = {}
+
+          differences.each do |diff|
+            # Handle both DiffNode and Hash formats
+            if diff.is_a?(Hash) && diff.key?(:path)
+              # Ruby object difference (Hash format)
+              add_to_tree(tree, diff[:path], diff)
+            elsif diff.is_a?(Canon::Diff::DiffNode)
+              # DiffNode format - extract path from nodes
+              path = extract_dom_path_from_diffnode(diff)
+              add_to_tree(tree, path, diff)
+            else
+              # Legacy DOM difference (Hash format) - extract path from node
+              path = extract_dom_path(diff)
+              add_to_tree(tree, path, diff)
+            end
+          end
+
+          tree
+        end
+
+        # Add a difference to the tree structure
+        def add_to_tree(tree, path, diff)
+          parts = path.to_s.split(/[.\[\]]/).reject(&:empty?)
+          current = tree
+
+          parts.each_with_index do |part, index|
+            current[part] ||= {}
+            if index == parts.length - 1
+              current[part][:__diff__] = diff
+            else
+              current = current[part]
+            end
+          end
+        end
+
+        # Extract path from DOM node difference
+        def extract_dom_path(diff)
+          node = diff[:node1] || diff[:node2]
+          return "" unless node
+
+          parts = []
+          current = node
+
+          while current.respond_to?(:name)
+            parts.unshift(current.name) if current.name
+            current = current.parent if current.respond_to?(:parent)
+          end
+
+          parts.join(".")
+        end
+
+        # Extract path from DiffNode object
+        def extract_dom_path_from_diffnode(diff_node)
+          # Extract path from node1 or node2 in the DiffNode
+          node = diff_node.node1 || diff_node.node2
+          return diff_node.dimension.to_s unless node
+
+          parts = []
+          current = node
+
+          while current.respond_to?(:name)
+            parts.unshift(current.name) if current.name
+            current = current.parent if current.respond_to?(:parent)
+          end
+
+          parts.empty? ? diff_node.dimension.to_s : parts.join(".")
+        end
+
+        # Render tree structure with box-drawing characters
+        def render_tree(tree, prefix: "", is_last: true)
+          output = []
+
+          sorted_keys = tree.keys.reject { |k| k == :__diff__ }
+          begin
+            sorted_keys = sorted_keys.sort_by(&:to_s)
+          rescue ArgumentError
+            # If sorting fails, just use the keys as-is
+          end
+
+          sorted_keys.each_with_index do |key, index|
+            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)
+            else
+              # Render intermediate path
+              output << colorize("#{prefix}#{connector}#{key}:", :cyan)
+              # Recurse into subtree
+              if value.is_a?(Hash)
+                output << render_tree(value, prefix: prefix + continuation,
+                                             is_last: is_last_item)
+              end
+            end
+          end
+
+          output.join("\n")
+        end
+
+        # Render a single diff node - to be overridden by subclasses
+        def render_diff_node(key, diff, prefix, connector)
+          raise NotImplementedError,
+                "Subclasses must implement render_diff_node"
+        end
+
+        # Colorize text if color is enabled
+        def colorize(text, *colors)
+          return text unless @use_color
+
+          require "paint"
+          "\e[0m#{Paint[text, *colors]}"
+        end
+      end
+    end
+  end
+end