canon 0.2.8 → 0.2.11

data/lib/canon/comparison.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require "moxml"
-require "nokogiri"
+require "nokogiri" if Canon::XmlBackend.nokogiri?
 require_relative "xml/whitespace_normalizer"
 require_relative "comparison/xml_comparator"
 require_relative "comparison/html_comparator"
@@ -284,7 +284,7 @@ module Canon
         (custom + presets).sort.uniq
       end
 
-      private
+      # --- Internal methods (public for testability) ---
 
       # Perform semantic tree diff comparison
       def semantic_diff(obj1, obj2, opts = {})
@@ -316,7 +316,8 @@ module Canon
 
         # Get global config options if not defined in opts
         # This is needed because semantic_diff doesn't go through dom_diff's config handling
-        if !(opts[:match_profile] || opts[:global_options]) && Canon::Config.instance.respond_to?(format1)
+        if !(opts[:match_profile] || opts[:global_options]) && %i[xml html json
+                                                                  yaml string].include?(format1)
           format_config = Canon::Config.instance.public_send(format1)
           if format_config.match.profile
             opts[:match_profile] =
@@ -333,7 +334,8 @@ module Canon
 
         # Also read diff options from config (e.g., max_node_count for large documents)
         # This is independent of match options and needs to be passed to TreeDiffIntegrator
-        if !match_opts_hash[:max_node_count] && Canon::Config.instance.respond_to?(format1)
+        if !match_opts_hash[:max_node_count] && %i[xml html json yaml
+                                                   string].include?(format1)
           diff_max_node = Canon::Config.instance.public_send(format1).diff.max_node_count
           if diff_max_node > 10_000
             match_opts_hash[:max_node_count] =
@@ -564,43 +566,39 @@ module Canon
 
         case format
         when :xml
-          # Delegate to XmlComparator's parse_node - returns Canon::Xml::Node
-          # Adapter now handles Canon::Xml::Node directly
+          # Delegate to XmlComparator's parse - returns Canon::Xml::Node
           doc1 = parse_with_cache(obj1, format, preprocessing) do |doc|
-            XmlComparator.send(:parse_node, doc, preprocessing)
+            XmlComparator.parse(doc, preprocessing)
           end
           doc2 = parse_with_cache(obj2, format, preprocessing) do |doc|
-            XmlComparator.send(:parse_node, doc, preprocessing)
+            XmlComparator.parse(doc, preprocessing)
           end
           [doc1, doc2]
         when :html, :html4, :html5
-          # Delegate to HtmlComparator's parse_node_for_semantic for Canon::Xml::Node
           [
             parse_with_cache(obj1, format, preprocessing) do |doc|
-              HtmlComparator.send(:parse_node_for_semantic, doc, preprocessing)
+              HtmlComparator.parse(doc, preprocessing)
             end,
             parse_with_cache(obj2, format, preprocessing) do |doc|
-              HtmlComparator.send(:parse_node_for_semantic, doc, preprocessing)
+              HtmlComparator.parse(doc, preprocessing)
             end,
           ]
         when :json
-          # Delegate to JsonComparator's parse_json
           [
             parse_with_cache(obj1, format, :none) do |doc|
-              JsonComparator.send(:parse_json, doc)
+              JsonComparator.parse(doc)
             end,
             parse_with_cache(obj2, format, :none) do |doc|
-              JsonComparator.send(:parse_json, doc)
+              JsonComparator.parse(doc)
             end,
           ]
         when :yaml
-          # Delegate to YamlComparator's parse_yaml
           [
             parse_with_cache(obj1, format, :none) do |doc|
-              YamlComparator.send(:parse_yaml, doc)
+              YamlComparator.parse(doc)
             end,
             parse_with_cache(obj2, format, :none) do |doc|
-              YamlComparator.send(:parse_yaml, doc)
+              YamlComparator.parse(doc)
             end,
           ]
         else
@@ -651,12 +649,10 @@ module Canon
           obj
         when Nokogiri::XML::Document, Nokogiri::HTML::Document,
              Nokogiri::XML::DocumentFragment, Nokogiri::HTML::DocumentFragment
-          obj.respond_to?(:to_html) ? obj.to_html : obj.to_xml
+          obj.to_html
         else
-          if obj.respond_to?(:to_html)
-            obj.to_html
-          elsif obj.respond_to?(:to_xml)
-            obj.to_xml
+          if Canon::XmlParsing.xml_node?(obj) || obj.is_a?(Canon::Xml::Node)
+            Canon::XmlParsing.serialize(obj)
           else
             obj.to_s
           end
@@ -667,7 +663,11 @@ module Canon
       def serialize_document(doc, format)
         case format
         when :xml, :html, :html4, :html5
-          doc.respond_to?(:to_html) ? doc.to_html : doc.to_xml
+          if Canon::XmlParsing.xml_node?(doc) || doc.is_a?(Canon::Xml::Node)
+            Canon::XmlParsing.serialize(doc)
+          else
+            doc.to_s
+          end
         when :json
           require "json"
           JSON.pretty_generate(doc)
@@ -750,7 +750,7 @@ module Canon
 
         # get match_profile if it is not defined in options
         # but defined in config
-        if Canon::Config.instance.respond_to?(comparison_format)
+        if %i[xml html json yaml string].include?(comparison_format)
           format_config = Canon::Config.instance.public_send(comparison_format)
           if opts[:global_profile].nil? && format_config.match.profile
             # Config-sourced profile has *global* priority (applied before

data/lib/canon/config/profile_loader.rb

@@ -32,6 +32,19 @@ module Canon
           @cache = nil
         end
 
+        # Deep merge two hashes. Arrays are replaced (not concatenated).
+        def deep_merge(base, overlay)
+          result = base.dup
+          overlay.each do |key, value|
+            result[key] = if result[key].is_a?(Hash) && value.is_a?(Hash)
+                            deep_merge(result[key], value)
+                          else
+                            value
+                          end
+          end
+          result
+        end
+
         private
 
         def cache
@@ -116,19 +129,6 @@ module Canon
           content = File.read(path)
           YAML.safe_load(content, permitted_classes: [Symbol]) || {}
         end
-
-        # Deep merge two hashes. Arrays are replaced (not concatenated).
-        def deep_merge(base, overlay)
-          result = base.dup
-          overlay.each do |key, value|
-            result[key] = if result[key].is_a?(Hash) && value.is_a?(Hash)
-                            deep_merge(result[key], value)
-                          else
-                            value
-                          end
-          end
-          result
-        end
       end
     end
   end

data/lib/canon/config.rb

@@ -25,15 +25,19 @@ module Canon
 
       # Delegate to instance
       def method_missing(method, ...)
-        if @instance.respond_to?(method)
-          @instance.send(method, ...)
+        if %i[xml html json yaml string profile profile= diff_mode diff_mode=
+              use_color use_color= xml_match_profile xml_match_profile=
+              html_match_profile html_match_profile= reset!].include?(method)
+          @instance.public_send(method, ...)
         else
           super
         end
       end
 
       def respond_to_missing?(method, include_private = false)
-        @instance.respond_to?(method) || super
+        %i[xml html json yaml string profile profile= diff_mode diff_mode=
+           use_color use_color= xml_match_profile xml_match_profile=
+           html_match_profile html_match_profile= reset!].include?(method) || super
       end
     end
 
@@ -700,6 +704,24 @@ module Canon
         @resolver.set_programmatic(:theme, value)
       end
 
+      # Theme inheritance (custom theme with base + overrides)
+      def theme_inheritance
+        @resolver.resolve(:theme_inheritance)
+      end
+
+      def theme_inheritance=(value)
+        @resolver.set_programmatic(:theme_inheritance, value)
+      end
+
+      # Full custom theme hash
+      def custom_theme
+        @resolver.resolve(:custom_theme)
+      end
+
+      def custom_theme=(value)
+        @resolver.set_programmatic(:custom_theme, value)
+      end
+
       # File size limit in bytes (default 5MB)
       def max_file_size
         @resolver.resolve(:max_file_size)
@@ -806,6 +828,8 @@ module Canon
           max_node_count: 10_000,        # Maximum nodes in tree
           max_diff_lines: 10_000,        # Maximum diff output lines
           theme: :dark, # Default theme
+          theme_inheritance: nil,        # Custom theme with base + overrides
+          custom_theme: nil,             # Full custom theme hash
         }
 
         env = format ? EnvProvider.load_diff_for_format(format) : {}
@@ -846,8 +870,8 @@ module Canon
       formats = data["formats"] || {}
 
       format_configs.each do |fmt_key, fmt_cfg|
-        fmt_data = ProfileLoader.send(:deep_merge, shared,
-                                      formats[fmt_key.to_s] || {})
+        fmt_data = ProfileLoader.deep_merge(shared,
+                                            formats[fmt_key.to_s] || {})
         fmt_cfg.apply_profile_data(fmt_data)
       end
     end

data/lib/canon/diff/diff_classifier.rb

@@ -22,7 +22,7 @@ module Canon
         @match_options = match_options
         # Use the compare_profile from ResolvedMatchOptions if available (e.g., HtmlCompareProfile)
         # Otherwise create a base CompareProfile
-        @profile = if match_options.respond_to?(:compare_profile) && match_options.compare_profile
+        @profile = if match_options.is_a?(Canon::Comparison::ResolvedMatchOptions) && match_options.compare_profile
                      match_options.compare_profile
                    else
                      Canon::Comparison::CompareProfile.new(match_options)
@@ -65,7 +65,7 @@ module Canon
         # (since the dimension affects equivalence), which would prevent formatting
         # detection from being applied.
         if diff_node.dimension == :text_content &&
-            profile.send(:behavior_for, :text_content) == :normalize &&
+            profile.behavior_for(:text_content) == :normalize &&
             !inside_preserve_element?(diff_node) &&
             formatting_only_diff?(diff_node)
           diff_node.formatting = true
@@ -184,16 +184,12 @@ module Canon
         end
 
         # HTML: non-breaking space (U+00A0) is never insignificant
-        text = if node.respond_to?(:content)
-                 node.content
-               elsif node.respond_to?(:value)
-                 node.value
-               end
+        text = Canon::Comparison::NodeInspector.text_content(node)
         if text && Canon::Comparison::WhitespaceSensitivity.contains_nbsp?(text)
           return true
         end
 
-        return false unless node.respond_to?(:parent)
+        return false unless Canon::XmlParsing.element?(node) || node.is_a?(Canon::Xml::Node)
 
         parent = node.parent
         return false unless parent
@@ -223,49 +219,19 @@ module Canon
       end
 
       # Extract text content from a node for formatting comparison
-      # @param node [Object] The node to extract text from
-      # @return [String, nil] The text content or nil
       def extract_text_content(node)
         return nil if node.nil?
 
-        case node
-        when Canon::Xml::Nodes::TextNode
-          node.value
-        when Canon::Xml::Node
-          node.text_content
-        when Nokogiri::XML::Node
-          node.content.to_s
-        when Moxml::Node
-          node.content.to_s
-        when String
-          node
-        else
-          node.to_s
-        end
+        Canon::Comparison::NodeInspector.text_content(node)
       rescue StandardError
         nil
       end
 
-      # Check if a node is a text node
-      # @param node [Object] The node to check
-      # @return [Boolean] true if the node is a text node
       def text_node?(node)
         return false if node.nil?
+        return true if node.is_a?(String)
 
-        case node
-        when Canon::Xml::Nodes::TextNode
-          true
-        when Canon::Xml::Node
-          node.node_type == :text
-        when Nokogiri::XML::Node
-          node.node_type == Nokogiri::XML::Node::TEXT_NODE
-        when Moxml::Node
-          node.text?
-        when String
-          true
-        else
-          false
-        end
+        Canon::Comparison::NodeInspector.text_node?(node)
       end
     end
   end

data/lib/canon/diff/diff_line.rb

@@ -130,7 +130,7 @@ module Canon
           content == other.content &&
           type == other.type &&
           diff_node == other.diff_node &&
-          @formatting == other.instance_variable_get(:@formatting)
+          formatting? == other.formatting?
       end
     end
   end

data/lib/canon/diff/diff_line_builder.rb

@@ -843,6 +843,8 @@ new_line_ranges)
         index
       end
 
+      public :build_line_index
+
       # Sort char ranges by start_col for consistent rendering.
       def sort_ranges(ranges)
         (ranges || []).sort_by(&:start_col)

data/lib/canon/diff/diff_node_enricher.rb

@@ -1047,8 +1047,8 @@ module Canon
         end
 
         # search_start now points inside the innermost element
-        line_idx = SourceLocator.send(:find_line_for_offset, search_start,
-                                      line_map)
+        line_idx = SourceLocator.find_line_for_offset(search_start,
+                                                      line_map)
         return nil unless line_idx
 
         col = search_start - line_map[line_idx][:start_offset]
@@ -1133,8 +1133,8 @@ range_start, range_end)
         # Walk up ancestors to find one with an "id" attribute
         ancestors = []
         current = node
-        while current.respond_to?(:parent)
-          ancestors << current if current.respond_to?(:name)
+        while current.is_a?(Canon::Xml::Node)
+          ancestors << current
           current = current.parent
         end
 
@@ -1143,14 +1143,14 @@ range_start, range_end)
         anchor_name = nil
         anchor_id = nil
         ancestors.each do |anc|
-          next unless anc.respond_to?(:attribute_nodes) && anc.attribute_nodes
+          next unless anc.attribute_nodes
 
           anc.attribute_nodes.each do |attr|
-            next unless attr.respond_to?(:name) && attr.name == "id"
+            next unless attr.name == "id"
 
             anchor = anc
             anchor_name = anc.name
-            anchor_id = attr.respond_to?(:value) ? attr.value : nil
+            anchor_id = attr.value
             break
           end
           break if anchor
@@ -1219,8 +1219,8 @@ range_start, range_end)
               # Search for value inside leaf element
               value_pos = text.index(value, leaf_tag_end + 1)
               if value_pos && value_pos < leaf_close
-                line_idx = SourceLocator.send(:find_line_for_offset, value_pos,
-                                              line_map)
+                line_idx = SourceLocator.find_line_for_offset(value_pos,
+                                                              line_map)
                 return nil unless line_idx
 
                 col = value_pos - line_map[line_idx][:start_offset]
@@ -1234,8 +1234,8 @@ range_start, range_end)
         # Direct search: value might be directly in the anchor's content
         value_pos = text.index(value, anchor_tag_end + 1)
         if value_pos && value_pos < anchor_close
-          line_idx = SourceLocator.send(:find_line_for_offset, value_pos,
-                                        line_map)
+          line_idx = SourceLocator.find_line_for_offset(value_pos,
+                                                        line_map)
           return nil unless line_idx
 
           col = value_pos - line_map[line_idx][:start_offset]
@@ -1255,10 +1255,10 @@ range_start, range_end)
       # @param line_map [Array<Hash>] pre-built line offset map
       # @return [Hash, nil] location hash with :char_offset, :line_number, :col or nil
       def locate_textnode_parent(textnode, value, text, line_map)
-        return nil unless textnode.respond_to?(:parent) && textnode.parent
+        return nil unless textnode.is_a?(Canon::Xml::Node) && textnode.parent
 
         parent = textnode.parent
-        return nil unless parent.respond_to?(:name) && parent.name
+        return nil unless parent.name
 
         parent_name = parent.name
         parent_attrs = element_attribute_signature(parent)
@@ -1286,8 +1286,8 @@ range_start, range_end)
             # Search for value within this element
             value_pos = text.index(value, anchor_tag_end + 1)
             if value_pos && value_pos < anchor_close
-              line_idx = SourceLocator.send(:find_line_for_offset, value_pos,
-                                            line_map)
+              line_idx = SourceLocator.find_line_for_offset(value_pos,
+                                                            line_map)
               return nil unless line_idx
 
               col = value_pos - line_map[line_idx][:start_offset]
@@ -1310,10 +1310,10 @@ range_start, range_end)
       # @param line_map [Array<Hash>] pre-built line offset map
       # @return [Hash, nil] location hash with :char_offset, :line_number, :col or nil
       def locate_element_in_text2(textnode, text, line_map)
-        return nil unless textnode.respond_to?(:parent) && textnode.parent
+        return nil unless textnode.is_a?(Canon::Xml::Node) && textnode.parent
 
         parent = textnode.parent
-        return nil unless parent.respond_to?(:name) && parent.name
+        return nil unless parent.name
 
         parent_name = parent.name
         parent_attrs = element_attribute_signature(parent)
@@ -1340,8 +1340,8 @@ range_start, range_end)
 
             if is_self_closing
               # Self-closing element - return position of <
-              line_idx = SourceLocator.send(:find_line_for_offset, anchor_pos,
-                                            line_map)
+              line_idx = SourceLocator.find_line_for_offset(anchor_pos,
+                                                            line_map)
               return nil unless line_idx
 
               col = anchor_pos - line_map[line_idx][:start_offset]
@@ -1349,8 +1349,8 @@ range_start, range_end)
                        col: col }
             else
               # Regular element - return position of >
-              line_idx = SourceLocator.send(:find_line_for_offset, tag_end_pos,
-                                            line_map)
+              line_idx = SourceLocator.find_line_for_offset(tag_end_pos,
+                                                            line_map)
               return nil unless line_idx
 
               col = tag_end_pos - line_map[line_idx][:start_offset]
@@ -1368,10 +1368,8 @@ range_start, range_end)
       # Build a string representation of an element's attributes for matching.
       def element_attribute_signature(element)
         sig = {}
-        if element.respond_to?(:attribute_nodes) && element.attribute_nodes
+        if element.is_a?(Canon::Xml::Node) && element.attribute_nodes
           element.attribute_nodes.each do |attr|
-            next unless attr.respond_to?(:name) && attr.respond_to?(:value)
-
             sig[attr.name] = attr.value
           end
         end

data/lib/canon/diff/diff_node_mapper.rb

@@ -323,7 +323,7 @@ module Canon
       # @param line2 [String] New line content (for +/!)
       # @return [Boolean] true if formatting-only
       def formatting?(node, line1, line2)
-        return true if node.respond_to?(:formatting?) && node.formatting?
+        return true if node.is_a?(Canon::Diff::DiffNode) && node.formatting?
         return false if node
         return true if comment_only_line?(line1) || comment_only_line?(line2)
 
@@ -394,14 +394,14 @@ module Canon
                            end
 
           nodes_to_check.any? do |node|
-            # Check if the node itself has the matching name
-            if node.respond_to?(:name) && node.name == line_element_name
-              true
-            # Check if the node's parent has the matching name (for TextNode diffs)
-            elsif node.respond_to?(:parent) && node.parent.respond_to?(:name) && node.parent.name == line_element_name # rubocop:disable Style/IfWithBooleanLiteralBranches
+            next false unless node
+
+            node_name = Canon::Comparison::NodeInspector.name(node)
+            if node_name == line_element_name
               true
             else
-              false
+              parent = Canon::Comparison::NodeInspector.parent(node)
+              parent && Canon::Comparison::NodeInspector.name(parent) == line_element_name
             end
           end
         end
@@ -453,6 +453,8 @@ module Canon
         comment_lines
       end
 
+      public :build_comment_lines
+
       # Find a comment DiffNode for a line that falls within a comment range.
       # Matches by checking if the DiffNode's source node has name "comment".
       #
@@ -463,7 +465,7 @@ module Canon
         @comment_diff_nodes&.find do |diff_node|
           nodes_to_check = [diff_node.node1, diff_node.node2].compact
           nodes_to_check.any? do |node|
-            node.respond_to?(:name) && node.name == "comment"
+            Canon::Comparison::NodeInspector.name(node) == "comment"
           end
         end
       end

data/lib/canon/diff/formatting_detector.rb

@@ -297,8 +297,9 @@ module Canon
         [close_idx + 1, "<#{sorted}#{suffix}"]
       end
 
-      private_class_method :normalize_for_comparison, :blank?,
-                           :decode_xml_entities, :normalize_attribute_order,
+      public_class_method :normalize_for_comparison, :blank?
+
+      private_class_method :decode_xml_entities, :normalize_attribute_order,
                            :sort_tag_attributes, :tokenize_tag_content,
                            :process_tag, :process_processing_instruction,
                            :process_comment, :process_regular_tag

data/lib/canon/diff/node_serializer.rb

@@ -51,16 +51,16 @@ module Canon
           return node.children.map { |child| serialize(child) }.join
         end
 
-        # Handle Nokogiri nodes
-        if node.respond_to?(:to_html)
-          return node.to_html
+        # Handle Nokogiri/moxml nodes
+        if Canon::XmlParsing.xml_node?(node)
+          return Canon::XmlParsing.serialize(node)
         end
 
-        if node.respond_to?(:to_xml)
-          return node.to_xml
+        # Handle tree diff nodes and other objects with serialization
+        if node.is_a?(Canon::TreeDiff::Core::TreeNode)
+          return serialize_treenode(node)
         end
 
-        # Fallback to string
         node.to_s
       end
 
@@ -105,23 +105,20 @@ module Canon
           return attrs
         end
 
-        # Handle Nokogiri elements
-        if node.respond_to?(:attributes) && node.attributes.is_a?(Hash)
+        # Handle Nokogiri/moxml elements via XmlParsing
+        if Canon::XmlParsing.element?(node)
           attrs = {}
-          node.attributes.each do |name, attr|
-            # Nokogiri attributes have different structure
-            value = if attr.respond_to?(:value)
-                      attr.value
-                    elsif attr.is_a?(String)
-                      attr
-                    else
-                      attr.to_s
-                    end
-            attrs[name] = value
+          Canon::XmlParsing.attributes(node).each do |attr|
+            attrs[attr.name] = attr.value
           end
           return attrs
         end
 
+        # Handle other elements with attributes method
+        if node.is_a?(Canon::Xml::Node)
+          return {}
+        end
+
         # Handle TreeNode attributes (already a hash)
         if node.is_a?(Hash)
           return node
@@ -143,10 +140,9 @@ module Canon
           return node.name
         end
 
-        # Handle Nokogiri elements
-        if node.respond_to?(:name)
-          return node.name.to_s
-        end
+        # Handle Nokogiri/moxml elements
+        name = Canon::XmlParsing.name(node)
+        return name.to_s if name
 
         ""
       end
@@ -164,16 +160,13 @@ module Canon
           return node.value.to_s
         end
 
-        # Handle Nokogiri text nodes
-        if node.respond_to?(:text)
-          return node.text.to_s
+        # Handle Canon::Xml::Node
+        if node.is_a?(Canon::Xml::Node)
+          return node.text_content.to_s
         end
 
-        if node.respond_to?(:content)
-          return node.content.to_s
-        end
-
-        ""
+        # Handle Nokogiri/moxml nodes
+        Canon::XmlParsing.text_content(node).to_s
       end
 
       # Serialize attributes to string format