canon 0.1.3 → 0.1.5

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

@@ -0,0 +1,305 @@
+# frozen_string_literal: true
+
+require_relative "base_formatter"
+
+module Canon
+  class DiffFormatter
+    module ByObject
+      # JSON tree formatter for by-object diffs
+      # Handles Ruby object differences (hashes and arrays)
+      class JsonFormatter < BaseFormatter
+        # Render a diff node for JSON/Ruby object differences
+        #
+        # @param key [String] Hash key or array index
+        # @param diff [Hash] Difference information
+        # @param prefix [String] Tree prefix for indentation
+        # @param connector [String] Box-drawing connector character
+        # @return [String] Formatted diff node
+        def render_diff_node(key, diff, prefix, connector)
+          output = []
+
+          # Show full path if available (path in cyan, no color on tree structure)
+          path_display = if diff[:path] && !diff[:path].empty?
+                           colorize(diff[:path].to_s, :cyan, :bold)
+                         else
+                           colorize(key.to_s, :cyan)
+                         end
+
+          output << "#{prefix}#{connector}#{path_display}:"
+
+          # Determine continuation for nested values
+          continuation = connector.start_with?("├") ? "│   " : "    "
+          value_prefix = prefix + continuation
+
+          diff_code = diff[:diff_code] || diff[:diff1]
+
+          case diff_code
+          when Comparison::MISSING_HASH_KEY
+            render_missing_key(diff, value_prefix, output)
+          when Comparison::UNEQUAL_PRIMITIVES
+            render_unequal_primitives(diff, value_prefix, output)
+          when Comparison::UNEQUAL_HASH_VALUES
+            render_unequal_hash_values(diff, value_prefix, output)
+          when Comparison::UNEQUAL_ARRAY_ELEMENTS
+            render_unequal_array_elements(diff, value_prefix, output)
+          when Comparison::UNEQUAL_ARRAY_LENGTHS
+            render_unequal_array_lengths(diff, value_prefix, output)
+          when Comparison::UNEQUAL_TYPES
+            render_unequal_types(diff, value_prefix, output)
+          else
+            # Fallback for unknown diff types
+            render_fallback(diff, value_prefix, output)
+          end
+
+          output.join("\n")
+        end
+
+        private
+
+        # Render missing hash key
+        def render_missing_key(diff, prefix, output)
+          if diff[:value1].nil?
+            # Key added in file2
+            if diff[:value2].is_a?(Hash) && !diff[:value2].empty?
+              output.concat(render_added_hash(diff[:value2], prefix))
+            else
+              value_str = format_value_for_diff(diff[:value2])
+              output << "#{prefix}└── + #{colorize(value_str, :green)}"
+            end
+          elsif diff[:value1].is_a?(Hash) && !diff[:value1].empty?
+            # Key removed in file2
+            output.concat(render_removed_hash(diff[:value1], prefix))
+          else
+            value_str = format_value_for_diff(diff[:value1])
+            output << "#{prefix}└── - #{colorize(value_str, :red)}"
+          end
+        end
+
+        # Render unequal primitives
+        def render_unequal_primitives(diff, prefix, output)
+          output.concat(render_value_diff(diff[:value1], diff[:value2],
+                                          prefix))
+        end
+
+        # Render unequal hash values
+        def render_unequal_hash_values(diff, prefix, output)
+          output.concat(render_value_diff(diff[:value1], diff[:value2],
+                                          prefix))
+        end
+
+        # Render unequal array elements
+        def render_unequal_array_elements(diff, prefix, output)
+          output.concat(render_value_diff(diff[:value1], diff[:value2],
+                                          prefix))
+        end
+
+        # Render unequal array lengths
+        def render_unequal_array_lengths(diff, prefix, output)
+          output.concat(render_value_diff(diff[:value1], diff[:value2],
+                                          prefix))
+        end
+
+        # Render unequal types
+        def render_unequal_types(diff, prefix, output)
+          output << "#{prefix}├── - #{colorize(
+            "#{diff[:value1].class.name}: #{format_value_for_diff(diff[:value1])}",
+            :red,
+          )}"
+          output << "#{prefix}└── + #{colorize(
+            "#{diff[:value2].class.name}: #{format_value_for_diff(diff[:value2])}",
+            :green,
+          )}"
+        end
+
+        # Render fallback for unknown diff types
+        def render_fallback(diff, prefix, output)
+          if diff[:value1] && diff[:value2]
+            output.concat(render_value_diff(diff[:value1], diff[:value2],
+                                            prefix))
+          elsif diff[:value1]
+            value_str = format_value_for_diff(diff[:value1])
+            output << "#{prefix}└── - #{colorize(value_str, :red)}"
+          elsif diff[:value2]
+            value_str = format_value_for_diff(diff[:value2])
+            output << "#{prefix}└── + #{colorize(value_str, :green)}"
+          else
+            output << "#{prefix}└── [UNKNOWN CHANGE]"
+          end
+        end
+
+        # Render an added hash with nested structure
+        def render_added_hash(hash, prefix)
+          output = []
+          sorted_keys = hash.keys.sort_by(&:to_s)
+
+          sorted_keys.each_with_index do |key, index|
+            is_last = (index == sorted_keys.length - 1)
+            connector = is_last ? "└──" : "├──"
+            continuation = is_last ? "    " : "│   "
+
+            value = hash[key]
+            if value.is_a?(Hash) && !value.empty?
+              # Nested hash - recurse
+              output << "#{prefix}#{connector} + #{colorize(key.to_s, :green)}:"
+              output.concat(render_added_hash(value, prefix + continuation))
+            else
+              # Leaf value
+              value_str = format_value_for_diff(value)
+              output << "#{prefix}#{connector} + #{colorize(key.to_s,
+                                                            :green)}: #{colorize(
+                                                              value_str, :green
+                                                            )}"
+            end
+          end
+
+          output
+        end
+
+        # Render a removed hash with nested structure
+        def render_removed_hash(hash, prefix)
+          output = []
+          sorted_keys = hash.keys.sort_by(&:to_s)
+
+          sorted_keys.each_with_index do |key, index|
+            is_last = (index == sorted_keys.length - 1)
+            connector = is_last ? "└──" : "├──"
+            continuation = is_last ? "    " : "│   "
+
+            value = hash[key]
+            if value.is_a?(Hash) && !value.empty?
+              # Nested hash - recurse
+              output << "#{prefix}#{connector} - #{colorize(key.to_s, :red)}:"
+              output.concat(render_removed_hash(value, prefix + continuation))
+            else
+              # Leaf value
+              value_str = format_value_for_diff(value)
+              output << "#{prefix}#{connector} - #{colorize(key.to_s,
+                                                            :red)}: #{colorize(
+                                                              value_str, :red
+                                                            )}"
+            end
+          end
+
+          output
+        end
+
+        # Render a detailed diff for two values
+        def render_value_diff(val1, val2, prefix)
+          output = []
+
+          # Handle arrays - show element-by-element comparison
+          if val1.is_a?(Array) && val2.is_a?(Array)
+            output.concat(render_array_diff(val1, val2, prefix))
+          elsif val1.is_a?(Hash) && val2.is_a?(Hash)
+            # For hashes, show summary (detailed comparison happens recursively)
+            val1_str = format_value_for_diff(val1)
+            val2_str = format_value_for_diff(val2)
+            output << "#{prefix}├── - #{colorize(val1_str, :red)}"
+            output << "#{prefix}└── + #{colorize(val2_str, :green)}"
+          else
+            # Primitives - show actual values
+            val1_str = format_value_for_diff(val1)
+            val2_str = format_value_for_diff(val2)
+            output << "#{prefix}├── - #{colorize(val1_str, :red)}"
+            output << "#{prefix}└── + #{colorize(val2_str, :green)}"
+          end
+
+          output
+        end
+
+        # Render array diff with element-by-element comparison
+        def render_array_diff(arr1, arr2, prefix)
+          output = []
+          max_len = [arr1.length, arr2.length].max
+          changes = []
+
+          (0...max_len).each do |i|
+            elem1 = i < arr1.length ? arr1[i] : nil
+            elem2 = i < arr2.length ? arr2[i] : nil
+
+            if elem1.nil?
+              # Element added
+              elem_str = format_value_for_diff(elem2)
+              changes << { type: :add, index: i, value: elem_str }
+            elsif elem2.nil?
+              # Element removed
+              elem_str = format_value_for_diff(elem1)
+              changes << { type: :remove, index: i, value: elem_str }
+            elsif elem1 != elem2
+              # Element changed
+              elem1_str = format_value_for_diff(elem1)
+              elem2_str = format_value_for_diff(elem2)
+              changes << { type: :change, index: i, old: elem1_str,
+                           new: elem2_str }
+            end
+            # Skip if elements are equal
+          end
+
+          # Render changes with proper connectors
+          changes.each_with_index do |change, idx|
+            is_last = (idx == changes.length - 1)
+            connector = is_last ? "└──" : "├──"
+
+            case change[:type]
+            when :add
+              output << "#{prefix}#{connector} [#{change[:index]}] + #{colorize(
+                change[:value], :green
+              )}"
+            when :remove
+              output << "#{prefix}#{connector} [#{change[:index]}] - #{colorize(
+                change[:value], :red
+              )}"
+            when :change
+              output << "#{prefix}├── [#{change[:index]}] - #{colorize(
+                change[:old], :red
+              )}"
+              output << if is_last
+                          "#{prefix}└── [#{change[:index]}] + #{colorize(
+                            change[:new], :green
+                          )}"
+                        else
+                          "#{prefix}├── [#{change[:index]}] + #{colorize(
+                            change[:new], :green
+                          )}"
+                        end
+            end
+          end
+
+          output
+        end
+
+        # Format a value for diff display
+        def format_value_for_diff(value)
+          case value
+          when String
+            "\"#{value}\""
+          when Numeric, TrueClass, FalseClass
+            value.to_s
+          when NilClass
+            "nil"
+          when Array
+            if value.empty?
+              "[]"
+            elsif value.all? do |v|
+              v.is_a?(String) || v.is_a?(Numeric) || v.is_a?(TrueClass) || v.is_a?(FalseClass) || v.nil?
+            end
+              # Simple array - show inline
+              "[#{value.map { |v| format_value_for_diff(v) }.join(', ')}]"
+            else
+              # Complex array - show summary
+              "{Array with #{value.length} elements}"
+            end
+          when Hash
+            if value.empty?
+              "{}"
+            else
+              "{Hash with #{value.keys.length} keys: #{value.keys.take(3).map(&:to_s).join(', ')}#{value.keys.length > 3 ? '...' : ''}}"
+            end
+          else
+            value.inspect
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,248 @@
+# frozen_string_literal: true
+
+require_relative "base_formatter"
+
+module Canon
+  class DiffFormatter
+    module ByObject
+      # XML/HTML tree formatter for by-object diffs
+      # Handles DOM node differences with proper path extraction
+      class XmlFormatter < BaseFormatter
+        # Render a diff node for XML/HTML DOM differences
+        #
+        # @param key [String] Node name or path segment
+        # @param diff [Hash] Difference information
+        # @param prefix [String] Tree prefix for indentation
+        # @param connector [String] Box-drawing connector character
+        # @return [String] Formatted diff node
+        def render_diff_node(key, diff, prefix, connector)
+          output = []
+
+          # Show full path if available (path in cyan, no color on tree structure)
+          path_display = if diff.is_a?(Hash) && diff[:path] && !diff[:path].empty?
+                           colorize(diff[:path].to_s, :cyan, :bold)
+                         else
+                           colorize(key.to_s, :cyan)
+                         end
+
+          output << "#{prefix}#{connector}#{path_display}:"
+
+          # Determine continuation for nested values
+          continuation = connector.start_with?("├") ? "│   " : "    "
+          value_prefix = prefix + continuation
+
+          # Handle both DiffNode and Hash formats
+          if diff.is_a?(Canon::Diff::DiffNode)
+            # DiffNode format - render based on dimension
+            render_diffnode(diff, value_prefix, output)
+          else
+            # Hash format - use diff codes
+            diff_code = diff[:diff_code] || diff[:diff1]
+
+            case diff_code
+            when Comparison::UNEQUAL_ELEMENTS
+              render_unequal_elements(diff, value_prefix, output)
+            when Comparison::UNEQUAL_TEXT_CONTENTS
+              render_unequal_text(diff, value_prefix, output)
+            when Comparison::UNEQUAL_ATTRIBUTES
+              render_unequal_attributes(diff, value_prefix, output)
+            when Comparison::MISSING_ATTRIBUTE
+              render_missing_attribute(diff, value_prefix, output)
+            when Comparison::UNEQUAL_COMMENTS
+              render_unequal_comments(diff, value_prefix, output)
+            when Comparison::MISSING_NODE
+              render_missing_node(diff, value_prefix, output)
+            else
+              # Fallback for unknown diff types
+              render_fallback(diff, value_prefix, output)
+            end
+          end
+
+          output.join("\n")
+        end
+
+        # Add a difference to the tree structure
+        # Handles DOM nodes by extracting their path
+        #
+        # @param tree [Hash] Tree structure to add to
+        # @param path [String, Array] Path to the difference
+        # @param diff [Hash, DiffNode] Difference information
+        def add_to_tree(tree, path, diff)
+          # For DOM differences (Hash format), extract path from node
+          if diff.is_a?(Hash) && !diff.key?(:path) && (diff[:node1] || diff[:node2])
+            path = extract_dom_path(diff)
+          end
+
+          super(tree, path, diff)
+        end
+
+        private
+
+        # Render DiffNode object
+        def render_diffnode(diff_node, prefix, output)
+          # Extract nodes for display
+          node1 = diff_node.node1
+          node2 = diff_node.node2
+
+          # Display based on dimension
+          case diff_node.dimension
+          when :text_content
+            if node1 && node2
+              text1 = extract_text(node1)
+              text2 = extract_text(node2)
+              output << "#{prefix}├── - #{colorize(format_text_inline(text1),
+                                                   :red)}"
+              output << "#{prefix}└── + #{colorize(format_text_inline(text2),
+                                                   :green)}"
+            else
+              output << "#{prefix}└── #{colorize(
+                "[#{diff_node.dimension}: #{diff_node.reason}]", :yellow
+              )}"
+            end
+          when :structural_whitespace, :attribute_whitespace, :attribute_values
+            output << "#{prefix}└── #{colorize(
+              "[#{diff_node.dimension}: #{diff_node.reason}]", :yellow
+            )}"
+          else
+            # Fallback
+            output << "#{prefix}└── #{colorize(
+              "[#{diff_node.dimension}: #{diff_node.reason}]", :cyan
+            )}"
+          end
+        end
+
+        # Render unequal elements
+        def render_unequal_elements(diff, prefix, output)
+          node1 = diff[:node1]
+          node2 = diff[:node2]
+          output << "#{prefix}├── - #{colorize("<#{node1.name}>", :red)}"
+          output << "#{prefix}└── + #{colorize("<#{node2.name}>", :green)}"
+        end
+
+        # Render unequal text contents
+        def render_unequal_text(diff, prefix, output)
+          node1 = diff[:node1]
+          node2 = diff[:node2]
+
+          text1 = extract_text(node1)
+          text2 = extract_text(node2)
+
+          # Show parent element if available
+          if node1.respond_to?(:parent) && node1.parent.respond_to?(:name)
+            output << "#{prefix}    #{colorize(
+              "Element: <#{node1.parent.name}>", :blue
+            )}"
+          end
+
+          output << "#{prefix}├── - #{colorize(format_text_inline(text1),
+                                               :red)}"
+          output << "#{prefix}└── + #{colorize(format_text_inline(text2),
+                                               :green)}"
+        end
+
+        # Render unequal attributes
+        def render_unequal_attributes(diff, prefix, output)
+          node1 = diff[:node1]
+          output << "#{prefix}└── #{colorize(
+            "Element: <#{node1.name}> [attributes differ]", :yellow
+          )}"
+        end
+
+        # Render missing attribute
+        def render_missing_attribute(diff, prefix, output)
+          node1 = diff[:node1]
+          output << "#{prefix}└── #{colorize(
+            "Element: <#{node1.name}> [attribute mismatch]", :yellow
+          )}"
+        end
+
+        # Render unequal comments
+        def render_unequal_comments(diff, prefix, output)
+          node1 = diff[:node1]
+          node2 = diff[:node2]
+
+          content1 = extract_text(node1)
+          content2 = extract_text(node2)
+
+          output << "#{prefix}├── - #{colorize(
+            "<!-- #{format_text_inline(content1)} -->", :red
+          )}"
+          output << "#{prefix}└── + #{colorize(
+            "<!-- #{format_text_inline(content2)} -->", :green
+          )}"
+        end
+
+        # Render missing node
+        def render_missing_node(diff, prefix, output)
+          output << if diff[:node1] && !diff[:node2]
+                      "#{prefix}└── - #{colorize('[node deleted]', :red)}"
+                    elsif diff[:node2] && !diff[:node1]
+                      "#{prefix}└── + #{colorize('[node inserted]', :green)}"
+                    else
+                      "#{prefix}└── #{colorize('[node mismatch]', :yellow)}"
+                    end
+        end
+
+        # Render fallback for unknown diff types
+        def render_fallback(diff, prefix, output)
+          if diff[:node1] && diff[:node2]
+            output << "#{prefix}├── - #{colorize('[file1 node]', :red)}"
+            output << "#{prefix}└── + #{colorize('[file2 node]', :green)}"
+          elsif diff[:node1]
+            output << "#{prefix}└── - #{colorize('[file1 only]', :red)}"
+          elsif diff[:node2]
+            output << "#{prefix}└── + #{colorize('[file2 only]', :green)}"
+          else
+            output << "#{prefix}└── #{colorize('[unknown change]', :yellow)}"
+          end
+        end
+
+        # Extract DOM path from a difference
+        #
+        # @param diff [Hash] Difference with node1 or node2
+        # @return [String] Path string
+        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 text from a node
+        #
+        # @param node [Object] Node with content or text
+        # @return [String] Text content
+        def extract_text(node)
+          if node.respond_to?(:content)
+            node.content.to_s
+          elsif node.respond_to?(:text)
+            node.text.to_s
+          else
+            ""
+          end
+        end
+
+        # Format text for inline display (truncate if too long)
+        #
+        # @param text [String] Text to format
+        # @return [String] Formatted text
+        def format_text_inline(text)
+          # Truncate long text
+          if text.length > 60
+            "\"#{text[0..57]}...\""
+          else
+            "\"#{text}\""
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative "json_formatter"
+
+module Canon
+  class DiffFormatter
+    module ByObject
+      # YAML tree formatter for by-object diffs
+      # Inherits from JsonFormatter since YAML and JSON share the same
+      # Ruby object structure (hashes and arrays)
+      class YamlFormatter < JsonFormatter
+        # YAML uses the same rendering logic as JSON since both formats
+        # represent Ruby objects (hashes and arrays) with the same structure
+      end
+    end
+  end
+end