canon 0.2.7 → 0.2.9

data/lib/canon/comparison/xml_node_comparison.rb

@@ -27,8 +27,8 @@ module Canon
       def self.compare_nodes(node1, node2, opts, child_opts, diff_children,
 differences)
         # Handle DocumentFragment nodes - compare their children instead
-        if node1.is_a?(Nokogiri::XML::DocumentFragment) &&
-            node2.is_a?(Nokogiri::XML::DocumentFragment)
+        if Canon::XmlParsing.document_fragment?(node1) &&
+            Canon::XmlParsing.document_fragment?(node2)
           return compare_document_fragments(node1, node2, opts, child_opts,
                                             diff_children, differences)
         end
@@ -285,10 +285,14 @@ diff_children, differences)
         return false if node1.class != node2.class
 
         case node1
-        when Canon::Xml::Node, Nokogiri::XML::Node
+        when Canon::Xml::Node
           node1.node_type == node2.node_type
         else
-          true
+          if Canon::XmlBackend.nokogiri?
+            node1.is_a?(Nokogiri::XML::Node) && node1.node_type == node2.node_type
+          else
+            Canon::XmlParsing.xml_node?(node1) && Canon::XmlParsing.node_type(node1) == Canon::XmlParsing.node_type(node2)
+          end
         end
       end
 
@@ -305,7 +309,7 @@ diff_children, differences)
       def self.comment_node?(node, check_children: false)
         return true if NodeInspector.comment_node?(node)
 
-        if check_children && node.is_a?(Nokogiri::XML::Element) && !node.children.empty?
+        if check_children && Canon::XmlParsing.element?(node) && !Canon::XmlParsing.children(node).empty?
           node.children.any? { |child| NodeInspector.comment_node?(child) }
         else
           false
@@ -360,24 +364,20 @@ diff_children, differences)
       # Dispatch by legacy Nokogiri/Moxml node type
       def self.dispatch_legacy_node_type(node1, node2, opts, child_opts,
 diff_children, differences)
-        # Import XmlComparator to use its comparison methods
         require_relative "xml_comparator"
 
-        case node1
-        when Nokogiri::XML::Document
+        if Canon::XmlParsing.document?(node1)
           XmlComparator.compare_document_nodes(node1, node2, opts, child_opts,
                                                diff_children, differences)
-        when Nokogiri::XML::Node
-          if node1.element?
+        elsif Canon::XmlParsing.xml_node?(node1)
+          if Canon::XmlParsing.element?(node1)
             XmlComparator.compare_element_nodes(node1, node2, opts, child_opts,
                                                 diff_children, differences)
-          elsif node1.text?
+          elsif Canon::XmlParsing.text_node?(node1) || Canon::XmlParsing.cdata?(node1)
             XmlComparator.compare_text_nodes(node1, node2, opts, differences)
-          elsif node1.comment?
+          elsif Canon::XmlParsing.comment?(node1)
             XmlComparator.compare_comment_nodes(node1, node2, opts, differences)
-          elsif node1.cdata?
-            XmlComparator.compare_text_nodes(node1, node2, opts, differences)
-          elsif node1.processing_instruction?
+          elsif Canon::XmlParsing.processing_instruction?(node1)
             XmlComparator.compare_processing_instruction_nodes(node1, node2,
                                                                opts, differences)
           else

data/lib/canon/comparison/yaml_comparator.rb

@@ -27,6 +27,14 @@ module Canon
       }.freeze
 
       class << self
+        # Parse YAML from string or return as-is
+        #
+        # @param obj [String, Hash, Array] YAML string or parsed object
+        # @return [Object] Parsed YAML object
+        def parse(obj)
+          parse_yaml(obj)
+        end
+
         # Compare two YAML objects for equivalence
         #
         # @param yaml1 [String, Hash, Array] First YAML

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"
@@ -104,6 +104,8 @@ module Canon
   # - diff_code: Type of difference
   #
   module Comparison
+    autoload :ChildRealignment, "canon/comparison/child_realignment"
+
     # Comparison result constants
     EQUIVALENT = 1
     MISSING_ATTRIBUTE = 2
@@ -314,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] =
@@ -331,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] =
@@ -562,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
@@ -649,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
@@ -665,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)
@@ -748,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
@@ -74,7 +74,7 @@ module Canon
         end
 
         # :whitespace_adjacency is a report-only re-label of an
-        # asymmetric whitespace mismatch emitted by ChildComparison's
+        # asymmetric whitespace mismatch emitted by ChildRealignment's
         # two-cursor walk.  Equivalence behaviour is unchanged — the
         # underlying mismatch is normative regardless of match options.
         if diff_node.dimension == :whitespace_adjacency
@@ -83,6 +83,14 @@ module Canon
           return diff_node
         end
 
+        # :comments diffs from asymmetric comment nodes intentionally
+        # fall through to profile.normative_dimension? below.  Unlike
+        # :whitespace_adjacency (always normative), the classification
+        # of comment diffs respects the :comments match option:
+        # :strict → normative, :ignore → informative.  This is by
+        # design — callers can control whether asymmetric comments
+        # affect equivalence via the match profile.
+
         # THIRD: Determine if this dimension is normative based on CompareProfile
         # This respects the policy settings (strict/normalize/ignore)
         is_normative = profile.normative_dimension?(diff_node.dimension)
@@ -176,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
@@ -215,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