canon 0.2.8 → 0.2.11

data/lib/canon/diff_formatter/debug_output.rb

@@ -283,22 +283,8 @@ module Canon
             content = node.value.to_s
             preview = content.length > 30 ? "#{content[0..27]}..." : content
             "<!--#{preview}-->"
-          elsif node.respond_to?(:name)
+          elsif Canon::XmlParsing.xml_node?(node) || node.is_a?(Canon::Xml::Node)
             "<#{node.name}>"
-          elsif node.respond_to?(:content)
-            content = node.content.to_s
-            if content.length > 30
-              "\"#{content[0..27]}...\""
-            else
-              "\"#{content || ''}\""
-            end
-          elsif node.respond_to?(:text)
-            text = node.text.to_s
-            if text.length > 30
-              "\"#{text[0..27]}...\""
-            else
-              "\"#{text || ''}\""
-            end
           else
             node.class.name
           end
@@ -311,14 +297,16 @@ module Canon
 
           # For attribute differences, show which attributes differ
           if diff.dimension == :attribute_whitespace &&
-              node1.respond_to?(:attributes) && node2.respond_to?(:attributes)
+              (Canon::XmlParsing.xml_node?(node1) || node1.is_a?(Canon::Xml::Node)) &&
+              (Canon::XmlParsing.xml_node?(node2) || node2.is_a?(Canon::Xml::Node))
             attrs1 = format_attributes(node1)
             attrs2 = format_attributes(node2)
             return ["<#{node1.name}> #{attrs1}", "<#{node2.name}> #{attrs2}"]
           end
 
           # For element differences, show element names
-          if node1.respond_to?(:name) && node2.respond_to?(:name)
+          if (Canon::XmlParsing.xml_node?(node1) || node1.is_a?(Canon::Xml::Node)) &&
+              (Canon::XmlParsing.xml_node?(node2) || node2.is_a?(Canon::Xml::Node))
             if node1.name == node2.name
               # Same element name, different content
             end
@@ -340,7 +328,7 @@ module Canon
         end
 
         def format_attributes(node)
-          return "" unless node.respond_to?(:attributes)
+          return "" unless Canon::XmlParsing.xml_node?(node) || node.is_a?(Canon::Xml::Node)
 
           attrs = node.attributes
           return "" if attrs.empty?
@@ -350,9 +338,9 @@ module Canon
             name = if key.is_a?(String)
                      key
                    else
-                     (key.respond_to?(:name) ? key.name : key.to_s)
+                     key.name
                    end
-            value = val.respond_to?(:value) ? val.value : val.to_s
+            value = val.is_a?(String) ? val : val.value
             "#{name}=\"#{value}\""
           end.sort
 
@@ -365,10 +353,10 @@ module Canon
         end
 
         def get_node_content(node)
-          if node.respond_to?(:content)
-            node.content.to_s
-          elsif node.respond_to?(:text)
-            node.text.to_s
+          if Canon::XmlParsing.xml_node?(node)
+            Canon::XmlParsing.text_content(node).to_s
+          elsif node.is_a?(Canon::Xml::Node)
+            node.text_content.to_s
           else
             ""
           end

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "rainbow"
+require "rainbow" unless RUBY_ENGINE == "opal"
 
 module Canon
   class DiffFormatter
@@ -19,7 +19,7 @@ module Canon
         def self.colorize(text, color, use_color, bold: false)
           return text unless use_color
 
-          presenter = Rainbow(text).send(color)
+          presenter = Rainbow(text).public_send(color)
           presenter = presenter.bright if bold
           presenter.to_s
         end

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

@@ -707,7 +707,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 +721,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 +733,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]

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

@@ -17,12 +17,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 +30,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 +65,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 +96,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]