canon 0.2.8 → 0.2.9

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_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/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

data/lib/canon/diff/path_builder.rb

@@ -54,10 +54,10 @@ module Canon
         while current && depth < max_depth
           segments.unshift(segment_for_node(current))
 
-          # Move to parent if available
-          break unless current.respond_to?(:parent)
+          parent = node_parent(current)
+          break unless parent
 
-          current = current.parent
+          current = parent
           depth += 1
         end
 
@@ -71,27 +71,16 @@ module Canon
       # @param tree_node [Object] Node (TreeNode, Canon::Xml::Node, or Nokogiri)
       # @return [String] Path segment with ordinal index
       def self.segment_for_node(tree_node)
-        # Handle both TreeNodes (with label) and raw nodes (with name)
-        label = if tree_node.respond_to?(:label)
-                  tree_node.label
-                elsif tree_node.respond_to?(:name)
-                  tree_node.name
-                else
-                  "unknown"
-                end
+        label = node_label(tree_node)
 
         # Get ordinal index (position among siblings with same label)
         index = ordinal_index(tree_node)
 
         # For text nodes, use parent element name for clarity
         # e.g., instead of "/p/#text[0]" use "/p/text()[0]"
-        if ["text",
-            "#text"].include?(label) && tree_node.respond_to?(:parent) && tree_node.parent
-          parent_name = if tree_node.parent.respond_to?(:label)
-                          tree_node.parent.label
-                        elsif tree_node.parent.respond_to?(:name)
-                          tree_node.parent.name
-                        end
+        parent = node_parent(tree_node)
+        if ["text", "#text"].include?(label) && parent
+          parent_name = node_label(parent)
           if parent_name && parent_name != "#document" && parent_name != "#document-fragment"
             return "#{parent_name}/text()[#{index}]"
           end
@@ -106,35 +95,21 @@ module Canon
       # @param tree_node [Object] Node (TreeNode, Canon::Xml::Node, or Nokogiri)
       # @return [Integer] Zero-based ordinal index
       def self.ordinal_index(tree_node)
-        # Defensive: return 0 if no parent or doesn't respond to parent
-        return 0 unless tree_node.respond_to?(:parent)
-        return 0 unless tree_node.parent
+        parent = node_parent(tree_node)
+        return 0 unless parent
 
-        # Check if parent has children
-        return 0 unless tree_node.parent.respond_to?(:children)
-
-        siblings = tree_node.parent.children
+        siblings = node_children(parent)
         return 0 unless siblings
 
         # Convert to array if it's a NodeSet (Nokogiri) or similar
         siblings = siblings.to_a unless siblings.is_a?(Array)
 
-        # Get the label/name for comparison
-        my_label = if tree_node.respond_to?(:label)
-                     tree_node.label
-                   elsif tree_node.respond_to?(:name)
-                     tree_node.name
-                   end
-
+        my_label = node_label(tree_node)
         return 0 unless my_label
 
         # Count siblings with same label that appear before this node
         same_label_siblings = siblings.select do |s|
-          sibling_label = if s.respond_to?(:label)
-                            s.label
-                          elsif s.respond_to?(:name)
-                            s.name
-                          end
+          sibling_label = node_label(s)
           sibling_label == my_label
         end
 
@@ -152,6 +127,18 @@ module Canon
         segments = build_segments(tree_node)
         segments.join(" → ")
       end
+
+      def self.node_label(node)
+        Canon::Comparison::NodeInspector.name(node) || "unknown"
+      end
+
+      def self.node_parent(node)
+        Canon::Comparison::NodeInspector.parent(node)
+      end
+
+      def self.node_children(node)
+        Canon::Comparison::NodeInspector.children(node)
+      end
     end
   end
 end

data/lib/canon/diff/source_locator.rb

@@ -86,15 +86,12 @@ module Canon
       end
 
       class << self
-        private
-
         # Binary search for the line containing a character offset.
         #
         # @param char_offset [Integer] the character offset
         # @param line_map [Array<Hash>] the line offset map
         # @return [Integer, nil] the 0-based line index, or nil
         def find_line_for_offset(char_offset, line_map)
-          # Use bsearch for efficiency on large files
           line_map.bsearch_index do |entry|
             entry[:end_offset] > char_offset
           end