canon 0.2.9 → 0.2.12

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

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "base_formatter"
-
 module Canon
   class DiffFormatter
     module ByObject
@@ -136,7 +134,16 @@ module Canon
                 theme_color(:changed, :marker) || :yellow,
               )}"
             end
-          when :structural_whitespace, :attribute_whitespace, :attribute_values
+          when :attribute_values
+            render_attribute_values_diffnode(diff_node, node1, node2, prefix,
+                                             output)
+          when :attribute_presence
+            render_attribute_presence_diffnode(diff_node, node1, node2, prefix,
+                                               output)
+          when :attribute_order
+            render_attribute_order_diffnode(diff_node, node1, node2, prefix,
+                                            output)
+          when :structural_whitespace, :attribute_whitespace
             output << "#{prefix}└── #{colorize(
               "[#{diff_node.dimension}: #{diff_node.reason}]",
               theme_color(:changed, :marker) || :yellow,
@@ -150,6 +157,115 @@ module Canon
           end
         end
 
+        # Render attribute value DiffNode with per-attribute before/after
+        def render_attribute_values_diffnode(diff_node, node1, node2, prefix,
+                                             output)
+          attrs1 = diff_node.attributes_before ||
+            extract_attributes_hash(node1)
+          attrs2 = diff_node.attributes_after ||
+            extract_attributes_hash(node2)
+          element_name = if node1
+                           node1.name
+                         else
+                           (node2 ? node2.name : "?")
+                         end
+
+          output << "#{prefix}└── #{colorize(
+            "Element: <#{element_name}>",
+            theme_color(:changed, :marker) || :yellow,
+          )}"
+
+          differing = find_differing_attributes(attrs1, attrs2)
+          differing.each_with_index do |name, i|
+            connector = i < differing.size - 1 ? "├──" : "└──"
+            val1 = attrs1[name].to_s
+            val2 = attrs2[name].to_s
+            output << "#{prefix}    #{connector} " \
+                      "#{colorize("#{name}:", :cyan)} " \
+                      "#{colorize(val1,
+                                  theme_color(:removed, :content) || :red)} " \
+                      "→ " \
+                      "#{colorize(val2,
+                                  theme_color(:added, :content) || :green)}"
+          end
+        end
+
+        # Render attribute presence DiffNode with added/removed attributes
+        def render_attribute_presence_diffnode(diff_node, node1, node2, prefix,
+                                               output)
+          attrs1 = diff_node.attributes_before ||
+            extract_attributes_hash(node1)
+          attrs2 = diff_node.attributes_after ||
+            extract_attributes_hash(node2)
+          element_name = if node1
+                           node1.name
+                         else
+                           (node2 ? node2.name : "?")
+                         end
+
+          output << "#{prefix}└── #{colorize(
+            "Element: <#{element_name}>",
+            theme_color(:changed, :marker) || :yellow,
+          )}"
+
+          keys1 = attrs1.keys.to_set
+          keys2 = attrs2.keys.to_set
+          removed = (keys1 - keys2).sort
+          added = (keys2 - keys1).sort
+          items = removed.map { |k| [:removed, k, attrs1[k]] }
+          added.each { |k| items << [:added, k, attrs2[k]] }
+
+          items.each_with_index do |(type, name, val), i|
+            connector = i < items.size - 1 ? "├──" : "└──"
+            color = if type == :removed
+                      theme_color(:removed,
+                                  :content) || :red
+                    else
+                      theme_color(
+                        :added, :content
+                      ) || :green
+                    end
+            sign = type == :removed ? "-" : "+"
+            output << "#{prefix}    #{connector} " \
+                      "#{colorize("#{sign} #{name}=\"#{val}\"", color)}"
+          end
+        end
+
+        # Render attribute order DiffNode with before/after order
+        def render_attribute_order_diffnode(diff_node, node1, node2, prefix,
+                                            output)
+          attrs1 = diff_node.attributes_before ||
+            extract_attributes_hash(node1)
+          attrs2 = diff_node.attributes_after ||
+            extract_attributes_hash(node2)
+
+          order1 = attrs1.keys.join(", ")
+          order2 = attrs2.keys.join(", ")
+
+          output << "#{prefix}├── #{colorize(
+            "- [#{order1}]",
+            theme_color(:removed, :content) || :red,
+          )}"
+          output << "#{prefix}└── #{colorize(
+            "+ [#{order2}]",
+            theme_color(:added, :content) || :green,
+          )}"
+        end
+
+        # Extract attributes hash from a node
+        def extract_attributes_hash(node)
+          return {} unless node
+
+          Canon::Diff::NodeSerializer.extract_attributes(node) || {}
+        end
+
+        # Find attributes that differ between two attribute hashes
+        def find_differing_attributes(attrs1, attrs2)
+          (attrs1.keys | attrs2.keys).reject do |k|
+            attrs1[k.to_s] == attrs2[k.to_s]
+          end.sort
+        end
+
         # Render unequal elements
         def render_unequal_elements(diff, prefix, output)
           node1 = diff[:node1]

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

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "json_formatter"
-
 module Canon
   class DiffFormatter
     module ByObject

data/lib/canon/diff_formatter/by_object_formatter.rb

@@ -21,9 +21,6 @@ module Canon
       # @param format [Symbol] Document format (:xml, :json, :yaml)
       # @return [String] Formatted diff output
       def format(differences, format)
-        output = []
-        output << colorize("Visual Diff:", :cyan, :bold)
-
         diffs_array = if differences.is_a?(Canon::Comparison::ComparisonResult)
                         differences.differences
                       else
@@ -37,8 +34,7 @@ module Canon
           show_diffs: @show_diffs,
         )
 
-        output << formatter.format(diffs_array, format)
-        output.join("\n")
+        formatter.format(diffs_array, format)
       end
 
       private

data/lib/canon/diff_formatter/debug_output.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "diff_detail_formatter"
-
 module Canon
   class DiffFormatter
     # Verbose diff output helper for CANON_VERBOSE mode

data/lib/canon/diff_formatter/diff_detail_formatter/dimension_formatter.rb

@@ -53,9 +53,6 @@ expand_difference: false)
         # @param use_color [Boolean] Whether to use colors
         # @return [Array] Tuple of [detail1, detail2, changes]
         def self.format_namespace_uri_details(diff, use_color)
-          require_relative "color_helper"
-          require_relative "node_utils"
-
           node1 = extract_node1(diff)
           node2 = extract_node2(diff)
 
@@ -87,10 +84,6 @@ expand_difference: false)
         # @param use_color [Boolean] Whether to use colors
         # @return [Array] Tuple of [detail1, detail2, changes]
         def self.format_namespace_declarations_details(diff, use_color)
-          require_relative "color_helper"
-          require_relative "node_utils"
-          require_relative "text_utils"
-
           node1 = extract_node1(diff)
           node2 = extract_node2(diff)
 
@@ -174,9 +167,6 @@ expand_difference: false)
         # @param use_color [Boolean] Whether to use colors
         # @return [Array] Tuple of [detail1, detail2, changes]
         def self.format_element_structure_details(diff, use_color)
-          require_relative "color_helper"
-          require_relative "node_utils"
-
           node1 = extract_node1(diff)
           node2 = extract_node2(diff)
 
@@ -236,9 +226,6 @@ expand_difference: false)
         # @param use_color [Boolean] Whether to use colors
         # @return [Array] Tuple of [detail1, detail2, changes]
         def self.format_attribute_presence_details(diff, use_color)
-          require_relative "color_helper"
-          require_relative "node_utils"
-
           node1 = extract_node1(diff)
           node2 = extract_node2(diff)
 
@@ -291,9 +278,6 @@ expand_difference: false)
         # @param use_color [Boolean] Whether to use colors
         # @return [Array] Tuple of [detail1, detail2, changes]
         def self.format_attribute_values_details(diff, use_color)
-          require_relative "color_helper"
-          require_relative "node_utils"
-
           node1 = extract_node1(diff)
           node2 = extract_node2(diff)
 
@@ -330,9 +314,6 @@ expand_difference: false)
         # @param use_color [Boolean] Whether to use colors
         # @return [Array] Tuple of [detail1, detail2, changes]
         def self.format_attribute_order_details(diff, use_color)
-          require_relative "color_helper"
-          require_relative "node_utils"
-
           node1 = extract_node1(diff)
           node2 = extract_node2(diff)
 
@@ -361,10 +342,6 @@ expand_difference: false)
         # @param compact [Boolean] Whether to serialize element nodes as compact XML
         # @return [Array] Tuple of [detail1, detail2, changes]
         def self.format_text_content_details(diff, use_color, compact: false)
-          require_relative "color_helper"
-          require_relative "node_utils"
-          require_relative "text_utils"
-
           node1 = extract_node1(diff)
           node2 = extract_node2(diff)
 
@@ -465,10 +442,6 @@ expand_difference: false)
         # @param use_color [Boolean] Whether to apply ANSI colours
         # @return [Array<String>] Tuple of [detail1, detail2, changes]
         def self.format_text_content_one_sided(node1, node2, use_color)
-          require_relative "color_helper"
-          require_relative "node_utils"
-          require_relative "text_utils"
-
           present = node1 || node2
 
           # Defensive: if a one-sided text-content diff carries an
@@ -515,10 +488,6 @@ expand_difference: false)
         # @param use_color [Boolean] Whether to use colors
         # @return [Array] Tuple of [detail1, detail2, changes]
         def self.format_whitespace_adjacency_details(diff, use_color)
-          require_relative "color_helper"
-          require_relative "node_utils"
-          require_relative "text_utils"
-
           node1 = extract_node1(diff)
           node2 = extract_node2(diff)
 
@@ -568,10 +537,6 @@ expand_difference: false)
         # @param use_color [Boolean] Whether to use colors
         # @return [Array] Tuple of [detail1, detail2, changes]
         def self.format_structural_whitespace_details(diff, use_color)
-          require_relative "color_helper"
-          require_relative "node_utils"
-          require_relative "text_utils"
-
           node1 = extract_node1(diff)
           node2 = extract_node2(diff)
 
@@ -594,9 +559,6 @@ expand_difference: false)
         # @param use_color [Boolean] Whether to use colors
         # @return [Array] Tuple of [detail1, detail2, changes]
         def self.format_comments_details(diff, use_color)
-          require_relative "color_helper"
-          require_relative "node_utils"
-
           node1 = extract_node1(diff)
           node2 = extract_node2(diff)
 
@@ -619,8 +581,6 @@ expand_difference: false)
         # @param use_color [Boolean] Whether to use colors
         # @return [Array] Tuple of [detail1, detail2, changes]
         def self.format_hash_diff_details(diff, use_color)
-          require_relative "color_helper"
-
           detail1 = if diff.is_a?(Hash) && diff[:value1]
                       ColorHelper.colorize(format_json_value(diff[:value1]),
                                            :red, use_color)
@@ -653,9 +613,6 @@ expand_difference: false)
         # @param compact [Boolean] Whether to serialize element nodes as compact XML
         # @return [Array] Tuple of [detail1, detail2, changes]
         def self.format_fallback_details(diff, use_color, compact: false)
-          require_relative "color_helper"
-          require_relative "node_utils"
-
           node1 = extract_node1(diff)
           node2 = extract_node2(diff)
 
@@ -707,7 +664,7 @@ expand_difference: false)
         # @param diff [DiffNode, Hash] Difference node
         # @return [Symbol] Dimension
         def self.extract_dimension(diff)
-          if diff.respond_to?(:dimension)
+          if diff.is_a?(Canon::Diff::DiffNode)
             diff.dimension
           elsif diff.is_a?(Hash)
             diff[:dimension] || diff[:diff_code] || :unknown
@@ -721,7 +678,7 @@ expand_difference: false)
         # @param diff [DiffNode, Hash] Difference node
         # @return [Object] Node1
         def self.extract_node1(diff)
-          if diff.respond_to?(:node1)
+          if diff.is_a?(Canon::Diff::DiffNode)
             diff.node1
           elsif diff.is_a?(Hash)
             diff[:node1]
@@ -733,7 +690,7 @@ expand_difference: false)
         # @param diff [DiffNode, Hash] Difference node
         # @return [Object] Node2
         def self.extract_node2(diff)
-          if diff.respond_to?(:node2)
+          if diff.is_a?(Canon::Diff::DiffNode)
             diff.node2
           elsif diff.is_a?(Hash)
             diff[:node2]
@@ -749,8 +706,7 @@ expand_difference: false)
 
           declarations = {}
 
-          # Handle Canon::Xml::Node (uses namespace_nodes)
-          if node.respond_to?(:namespace_nodes)
+          if node.is_a?(Canon::Xml::Node)
             node.namespace_nodes.each do |ns|
               next if ns.prefix == "xml" && ns.uri == "http://www.w3.org/XML/1998/namespace"
 
@@ -760,30 +716,28 @@ expand_difference: false)
             return declarations
           end
 
-          # Handle Nokogiri/Moxml nodes (use attributes)
-          raw_attrs = node.respond_to?(:attribute_nodes) ? node.attribute_nodes : node.attributes
+          # Handle Nokogiri/Moxml nodes (use attribute_nodes or attributes).
+          raw_attrs = if node.is_a?(Nokogiri::XML::Node)
+                        node.attribute_nodes
+                      else
+                        node.attributes
+                      end
 
           if raw_attrs.is_a?(Array)
             raw_attrs.each do |attr|
-              name = attr.respond_to?(:name) ? attr.name : attr.to_s
-              value = attr.respond_to?(:value) ? attr.value : attr.to_s
+              name = attr.is_a?(Nokogiri::XML::Attr) ? attr.name : attr.to_s
+              value = attr.is_a?(Nokogiri::XML::Attr) ? attr.value : attr.to_s
 
               if namespace_declaration?(name)
                 prefix = name == "xmlns" ? "" : name.split(":", 2)[1]
                 declarations[prefix] = value
               end
             end
-          elsif raw_attrs.respond_to?(:each)
+          elsif raw_attrs.is_a?(Hash)
             raw_attrs.each do |key, val|
-              name = if key.is_a?(String)
-                       key
-                     else
-                       (key.respond_to?(:name) ? key.name : key.to_s)
-                     end
-              value = if val.respond_to?(:value)
+              name = hash_key_to_name(key)
+              value = if val.is_a?(Nokogiri::XML::Attr)
                         val.value
-                      elsif val.respond_to?(:content)
-                        val.content
                       else
                         val.to_s
                       end
@@ -805,6 +759,18 @@ expand_difference: false)
         def self.namespace_declaration?(name)
           name == "xmlns" || name.to_s.start_with?("xmlns:")
         end
+
+        # Coerce a hash key (from a backend-supplied attribute hash) into a
+        # plain String attribute name.
+        #
+        # @param key [String, Nokogiri::XML::Attr, Object]
+        # @return [String]
+        def self.hash_key_to_name(key)
+          return key if key.is_a?(String)
+          return key.name if key.is_a?(Nokogiri::XML::Attr)
+
+          key.to_s
+        end
       end
     end
   end

data/lib/canon/diff_formatter/diff_detail_formatter/location_extractor.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "../../xml/namespace_helper"
-
 module Canon
   class DiffFormatter
     module DiffDetailFormatterHelpers
@@ -17,12 +15,12 @@ module Canon
           return "" unless diff
 
           # Prefer pre-computed path if available (populated by MetadataEnricher)
-          if diff.respond_to?(:path) && !diff.path.nil? && !diff.path.empty?
-            return "Location: #{diff.path}"
+          if diff.is_a?(Canon::Diff::DiffNode) && diff.path && !diff.path.empty?
+            return diff.path
           end
 
           # Fall back to extracting from nodes
-          node = if diff.respond_to?(:node1)
+          node = if diff.is_a?(Canon::Diff::DiffNode)
                    diff.node1 || diff.node2
                  elsif diff.is_a?(Hash)
                    diff[:node1] || diff[:node2]
@@ -30,8 +28,7 @@ module Canon
 
           return "" unless node
 
-          xpath = extract_xpath(node)
-          xpath.empty? ? "" : "Location: #{xpath}"
+          extract_xpath(node)
         end
 
         # Extract XPath from a node
@@ -66,24 +63,26 @@ module Canon
           current = node
 
           while current
-            break unless current.respond_to?(:name)
-
-            name = current.name
+            name = case current
+                   when Canon::Xml::Node, Nokogiri::XML::Node
+                     current.name
+                   else
+                     break
+                   end
             break if name.nil? || name.empty?
 
-            # Calculate position among siblings
             index = calculate_sibling_index(current, name)
             parts.unshift("#{name}[#{index}]")
 
-            # Move to parent
-            current = if current.respond_to?(:parent)
+            current = case current
+                      when Canon::Xml::Node, Nokogiri::XML::Node
                         current.parent
-                      elsif current.respond_to?(:parent_node)
-                        current.parent_node
+                      else
+                        break
                       end
 
-            # Stop at document root
-            break if current.respond_to?(:document) && current == current.document
+            break if current.is_a?(Nokogiri::XML::Document) ||
+              current.is_a?(Canon::Xml::Nodes::RootNode)
           end
 
           parts.empty? ? "" : "/#{parts.join('/')}"
@@ -95,24 +94,22 @@ module Canon
         # @param name [String] Node name
         # @return [Integer] 1-based index
         def self.calculate_sibling_index(node, name)
-          return 1 unless node.respond_to?(:parent) || node.respond_to?(:parent_node)
-
-          parent = if node.respond_to?(:parent)
+          parent = case node
+                   when Canon::Xml::Node, Nokogiri::XML::Node
                      node.parent
-                   elsif node.respond_to?(:parent_node)
-                     node.parent_node
                    end
 
           return 1 unless parent
 
-          # Get siblings with same name
-          siblings = if parent.respond_to?(:children)
+          siblings = case parent
+                     when Canon::Xml::Node, Nokogiri::XML::Node
                        parent.children.select do |n|
-                         n.respond_to?(:name) && n.name == name
-                       end
-                     elsif parent.respond_to?(:child_nodes)
-                       parent.child_nodes.select do |n|
-                         n.respond_to?(:name) && n.name == name
+                         case n
+                         when Canon::Xml::Node, Nokogiri::XML::Node
+                           n.name == name
+                         else
+                           false
+                         end
                        end
                      else
                        [node]

data/lib/canon/diff_formatter/diff_detail_formatter/node_utils.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "cgi"
-require_relative "../../xml/namespace_helper"
 
 module Canon
   class DiffFormatter
@@ -94,7 +93,7 @@ module Canon
         def self.get_namespace_uri_for_display(node)
           return "" unless node
 
-          Canon::Comparison::Canon::Comparison::NodeInspector.namespace_uri(node).to_s
+          Canon::Comparison::NodeInspector.namespace_uri(node).to_s
         end
 
         # --- Display helpers ---

data/lib/canon/diff_formatter/diff_detail_formatter/text_utils.rb

@@ -45,13 +45,7 @@ module Canon
         def self.extract_content_preview(node, max_length = 50)
           return "" unless node
 
-          text = if node.respond_to?(:text)
-                   node.text
-                 elsif node.respond_to?(:content)
-                   node.content
-                 else
-                   node.to_s
-                 end
+          text = Canon::Comparison::NodeInspector.text_content(node).to_s
 
           return "" if text.nil? || text.empty?
 

data/lib/canon/diff_formatter/diff_detail_formatter.rb

@@ -1,13 +1,6 @@
 # frozen_string_literal: true
 
 require "rainbow" unless RUBY_ENGINE == "opal"
-require_relative "../xml/namespace_helper"
-# DiffDetailFormatter helper modules
-require_relative "diff_detail_formatter/text_utils"
-require_relative "diff_detail_formatter/color_helper"
-require_relative "diff_detail_formatter/location_extractor"
-require_relative "diff_detail_formatter/node_utils"
-require_relative "diff_detail_formatter/dimension_formatter"
 
 module Canon
   class DiffFormatter

data/lib/canon/diff_formatter/diff_detail_formatter_helpers.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Canon
+  class DiffFormatter
+    # Helper modules consumed by {DiffDetailFormatter} to format per-dimension
+    # difference details. Files live under `diff_detail_formatter/` but the
+    # constants live under this namespace.
+    #
+    # Children are autoloaded — never `require_relative` them.
+    module DiffDetailFormatterHelpers
+      autoload :ColorHelper,
+               "canon/diff_formatter/diff_detail_formatter/color_helper"
+      autoload :DimensionFormatter,
+               "canon/diff_formatter/diff_detail_formatter/dimension_formatter"
+      autoload :LocationExtractor,
+               "canon/diff_formatter/diff_detail_formatter/location_extractor"
+      autoload :NodeUtils,
+               "canon/diff_formatter/diff_detail_formatter/node_utils"
+      autoload :TextUtils,
+               "canon/diff_formatter/diff_detail_formatter/text_utils"
+    end
+  end
+end

data/lib/canon/diff_formatter.rb

@@ -1,15 +1,7 @@
 # frozen_string_literal: true
 
 require "paint" unless RUBY_ENGINE == "opal"
-require "yaml"
-require_relative "comparison"
-require_relative "diff/diff_block"
-require_relative "diff/diff_context"
-require_relative "diff/diff_report"
-require_relative "diff_formatter/debug_output"
-require_relative "diff_formatter/by_line_formatter"
-require_relative "diff_formatter/by_object_formatter"
-require_relative "diff_formatter/pretty_diff_formatter"
+require "yaml" unless RUBY_ENGINE == "opal"
 
 module Canon
   # Formatter for displaying semantic differences with color support
@@ -65,6 +57,16 @@ module Canon
   #   )
   #
   class DiffFormatter
+    autoload :ByLineFormatter, "canon/diff_formatter/by_line_formatter"
+    autoload :ByObjectFormatter, "canon/diff_formatter/by_object_formatter"
+    autoload :DebugOutput, "canon/diff_formatter/debug_output"
+    autoload :DiffDetailFormatter, "canon/diff_formatter/diff_detail_formatter"
+    autoload :DiffDetailFormatterHelpers,
+             "canon/diff_formatter/diff_detail_formatter_helpers"
+    autoload :Legend, "canon/diff_formatter/legend"
+    autoload :PrettyDiffFormatter, "canon/diff_formatter/pretty_diff_formatter"
+    autoload :Theme, "canon/diff_formatter/theme"
+
     # Namespace for by-object mode formatters
     module ByObject
       autoload :BaseFormatter, "canon/diff_formatter/by_object/base_formatter"
@@ -76,6 +78,7 @@ module Canon
     # Namespace for by-line mode formatters
     module ByLine
       autoload :BaseFormatter, "canon/diff_formatter/by_line/base_formatter"
+      autoload :HtmlFormatter, "canon/diff_formatter/by_line/html_formatter"
       autoload :SimpleFormatter, "canon/diff_formatter/by_line/simple_formatter"
       autoload :XmlFormatter, "canon/diff_formatter/by_line/xml_formatter"
       autoload :JsonFormatter, "canon/diff_formatter/by_line/json_formatter"
@@ -135,16 +138,17 @@ module Canon
     end
 
     # Default character visualization map (loaded from YAML)
-    DEFAULT_VISUALIZATION_MAP = character_map_data[:visualization_map].freeze
-
-    # Character category map (loaded from YAML)
-    CHARACTER_CATEGORY_MAP = character_map_data[:category_map].freeze
-
-    # Category display names (loaded from YAML)
-    CHARACTER_CATEGORY_NAMES = character_map_data[:category_names].freeze
-
-    # Character metadata including names (loaded from YAML)
-    CHARACTER_METADATA = character_map_data[:character_metadata].freeze
+    if RUBY_ENGINE == "opal"
+      DEFAULT_VISUALIZATION_MAP = {}.freeze
+      CHARACTER_CATEGORY_MAP = {}.freeze
+      CHARACTER_CATEGORY_NAMES = {}.freeze
+      CHARACTER_METADATA = {}.freeze
+    else
+      DEFAULT_VISUALIZATION_MAP = character_map_data[:visualization_map].freeze
+      CHARACTER_CATEGORY_MAP = character_map_data[:category_map].freeze
+      CHARACTER_CATEGORY_NAMES = character_map_data[:category_names].freeze
+      CHARACTER_METADATA = character_map_data[:character_metadata].freeze
+    end
 
     # Map difference codes to human-readable descriptions
     DIFF_DESCRIPTIONS = {
@@ -419,7 +423,6 @@ module Canon
       # 2. Semantic Diff Report (ALWAYS if diffs exist)
       if comparison_result.is_a?(Canon::Comparison::ComparisonResult) &&
           comparison_result.differences.any?
-        require_relative "diff_formatter/diff_detail_formatter"
         output << DiffDetailFormatter.format_report(
           comparison_result.differences,
           use_color: @use_color,
@@ -757,6 +760,9 @@ module Canon
       output.join("\n")
     end
 
+    public :format_line_numbered_inputs, :format_raw_inputs,
+           :format_preprocessed_inputs
+
     # Build the final visualization map from various customization options
     #
     # @param visualization_map [Hash, nil] Complete custom visualization map

data/lib/canon/formatters/html4_formatter.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "html_formatter_base"
-
 module Canon
   module Formatters
     # HTML4 formatter using Nokogiri::HTML parser