canon 0.2.8 → 0.2.11

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

data/lib/canon/diff/xml_serialization_formatter.rb

@@ -4,59 +4,25 @@ module Canon
   module Diff
     # Detects and classifies XML serialization-level formatting differences.
     #
-    # Serialization-level formatting differences are differences in XML syntax
-    # that do not affect the semantic content of the document. These differences
-    # arise from different valid ways to serialize the same semantic content.
-    #
-    # These differences are ALWAYS non-normative (formatting-only) regardless
-    # of match options, because they are purely syntactic variations.
-    #
-    # Examples:
-    # - Self-closing vs explicit closing tags: <tag/> vs <tag></tag>
-    # - Attribute quote style: attr="value" vs attr='value' (parser-normalized)
-    # - Whitespace within tags: <tag a="1" b="2"> vs <tag a="1"  b="2"> (parser-normalized)
-    #
-    # Note: Some serialization differences are normalized away by XML parsers
-    # (attribute quotes, tag spacing). This class focuses on differences that
-    # survive parsing and comparison, such as self-closing vs explicit closing.
+    # Serialization formatting differences are ALWAYS non-normative (formatting-only)
+    # regardless of match options, because they are purely syntactic variations.
     class XmlSerializationFormatter
-      # Detect if a diff node represents an XML serialization formatting difference.
-      #
-      # Serialization formatting differences are ALWAYS non-normative because they
-      # represent different valid serializations of the same semantic content.
-      #
-      # @param diff_node [DiffNode] The diff node to check
-      # @return [Boolean] true if this is a serialization formatting difference
+      NI = Canon::Comparison::NodeInspector
+
       def self.serialization_formatting?(diff_node)
-        # Currently only handles text_content dimension
-        # Future: add detection for other dimensions
         return false unless diff_node.dimension == :text_content
 
         empty_text_content_serialization_diff?(diff_node)
       end
 
-      # Check if a text_content difference is from XML serialization format.
-      #
-      # Specifically detects self-closing tags (<tag/>) vs explicit closing tags
-      # (<tag></tag>), which create different text node structures:
-      # - Self-closing: no text node (nil)
-      # - Explicit closing: empty or whitespace-only text node ("", " ", "\n", etc.)
-      #
-      # Per XML standards, these forms are semantically equivalent.
-      #
-      # @param diff_node [DiffNode] The diff node to check
-      # @return [Boolean] true if this is a serialization formatting difference
       def self.empty_text_content_serialization_diff?(diff_node)
         return false unless diff_node.dimension == :text_content
 
         node1 = diff_node.node1
         node2 = diff_node.node2
 
-        # Both nodes are nil - no actual difference, not a serialization formatting diff
         return false if node1.nil? && node2.nil?
 
-        # Only one is nil (e.g., one doc has self-closing, other has text)
-        # If the non-nil one is blank, it's still serialization formatting
         if node1.nil? || node2.nil?
           non_nil = node1 || node2
           return false unless text_node?(non_nil)
@@ -65,74 +31,32 @@ module Canon
           return blank?(text)
         end
 
-        # Both must be text nodes
         return false unless text_node?(node1) && text_node?(node2)
 
         text1 = extract_text_content(node1)
         text2 = extract_text_content(node2)
 
-        # Check if both texts are blank/whitespace-only
-        # This indicates self-closing vs explicit closing tag syntax
         blank?(text1) && blank?(text2)
       end
 
-      # Check if a value is blank (nil or whitespace-only)
-      # @param value [String, nil] Value to check
-      # @return [Boolean] true if blank
       def self.blank?(value)
-        value.nil? ||
-          (value.respond_to?(:empty?) && value.empty?) ||
-          (value.respond_to?(:strip) && value.strip.empty?)
+        value.nil? || value.to_s.strip.empty?
       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 self.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
+        NI.text_node?(node)
       end
 
-      # Extract text content from a node
-      # @param node [Object] The node to extract text from
-      # @return [String, nil] The text content or nil
       def self.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
+        NI.text_content(node)
       rescue StandardError
         nil
       end
-
-      private_class_method :blank?, :text_node?, :extract_text_content,
-                           :empty_text_content_serialization_diff?
     end
   end
 end

data/lib/canon/diff_formatter/by_line/base_formatter.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require "diff/lcs"
-require "diff/lcs/hunk"
+require "diff/lcs" unless RUBY_ENGINE == "opal"
+require "diff/lcs/hunk" unless RUBY_ENGINE == "opal"
 require_relative "../debug_output"
 require_relative "../theme"
 
@@ -233,7 +233,7 @@ module Canon
         # @return [Rainbow::Presenter] Colorized presenter
         def apply_color(presenter, color)
           valid_colors = normalize_color_for_rainbow(color)
-          valid_colors.each { |c| presenter = presenter.send(c) }
+          valid_colors.each { |c| presenter = presenter.public_send(c) }
           presenter
         end
 
@@ -385,7 +385,7 @@ module Canon
           rainbow = Rainbow.new
           rainbow.enabled = true
           presenter = rainbow.wrap(text)
-          valid_colors.each { |c| presenter = presenter.send(c) }
+          valid_colors.each { |c| presenter = presenter.public_send(c) }
           presenter.to_s
         end
 
@@ -675,13 +675,13 @@ module Canon
             # Handle Rainbow color methods - :bright_blue -> .blue.bright, etc.
             if color.to_s.start_with?("bright_")
               base_color = color.to_s.sub(/^bright_/, "").to_sym
-              presenter = presenter.send(base_color).bright
+              presenter = presenter.public_send(base_color).bright
             elsif color.to_s.start_with?("light_")
               # Rainbow doesn't have light_ versions, treat as white on bg
               base_color = color.to_s.sub(/^light_/, "").to_sym
-              presenter = presenter.send(base_color)
+              presenter = presenter.public_send(base_color)
             else
-              presenter = presenter.send(color)
+              presenter = presenter.public_send(color)
             end
 
             presenter.to_s

data/lib/canon/diff_formatter/by_line/json_formatter.rb

@@ -253,7 +253,7 @@ module Canon
 
           if color && @use_color
             require "rainbow"
-            Rainbow(visual).send(color).bright.to_s
+            Rainbow(visual).public_send(color).bright.to_s
           else
             visual
           end

data/lib/canon/diff_formatter/by_line/simple_formatter.rb

@@ -151,7 +151,7 @@ module Canon
           # Apply color if provided and color is enabled
           if color && @use_color
             require "rainbow"
-            Rainbow(visual).send(color).bright.to_s
+            Rainbow(visual).public_send(color).bright.to_s
           else
             visual
           end

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

@@ -1205,11 +1205,11 @@ informative: false, formatting: false)
             # Apply effect if specified (map :strikethrough to :cross_out for Rainbow)
             if effect
               rainbow_effect = effect == :strikethrough ? :cross_out : effect
-              presenter = presenter.send(rainbow_effect)
+              presenter = presenter.public_send(rainbow_effect)
             end
 
             # Apply color if specified
-            presenter = presenter.send(color) if color
+            presenter = presenter.public_send(color) if color
 
             presenter.to_s
           else

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

@@ -261,7 +261,7 @@ module Canon
 
           if color && @use_color
             require "rainbow"
-            Rainbow(visual).send(color).bright.to_s
+            Rainbow(visual).public_send(color).bright.to_s
           else
             visual
           end

data/lib/canon/diff_formatter/by_line_formatter.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "paint"
+require "paint" unless RUBY_ENGINE == "opal"
 
 module Canon
   class DiffFormatter

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

@@ -26,7 +26,7 @@ show_diffs: :all, theme: nil)
         # @return [String] Formatted output
         def format(differences, _format)
           # Handle both ComparisonResult (production) and Array (low-level tests)
-          if differences.respond_to?(:equivalent?)
+          if differences.is_a?(Canon::Comparison::ComparisonResult)
             # ComparisonResult object
             return success_message if differences.equivalent?
 
@@ -130,15 +130,11 @@ show_diffs: :all, theme: nil)
           return differences if @show_diffs.nil? || @show_diffs == :all
 
           differences.select do |diff|
-            # Handle both DiffNode objects and legacy Hash format
-            is_normative = if diff.respond_to?(:normative?)
-                             diff.normative?
-                           elsif diff.is_a?(Hash) && diff.key?(:normative)
-                             diff[:normative]
-                           else
-                             # Default to normative if unknown
-                             true
-                           end
+            is_normative = begin
+              diff.normative?
+            rescue NoMethodError
+              diff.is_a?(Hash) && diff.key?(:normative) ? diff[:normative] : true
+            end
 
             case @show_diffs
             when :normative
@@ -207,9 +203,9 @@ show_diffs: :all, theme: nil)
           parts = []
           current = node
 
-          while current.respond_to?(:name)
+          while Canon::XmlParsing.xml_node?(current) || current.is_a?(Canon::Xml::Node)
             parts.unshift(current.name) if current.name
-            current = current.parent if current.respond_to?(:parent)
+            current = current.parent
           end
 
           parts.join(".")
@@ -274,9 +270,12 @@ show_diffs: :all, theme: nil)
 
             if diffs && !diffs.empty?
               # Render all differences at this path
+              has_children = value.is_a?(Hash) &&
+                (value.keys - [:__diffs__]).any?
+
               diffs.each_with_index do |diff, diff_idx|
-                # Use proper connector for each diff
-                current_connector = if diff_idx == diffs.length - 1
+                is_last_diff = diff_idx == diffs.length - 1
+                current_connector = if is_last_diff && !has_children
                                       connector
                                     else
                                       is_last_item ? "├── " : "├── "
@@ -286,6 +285,13 @@ show_diffs: :all, theme: nil)
                 output << line
                 @line_count += line.count("\n") + 1
               end
+
+              # Recurse into child diffs at this path
+              if has_children
+                subtree = render_tree(value, prefix: prefix + continuation,
+                                             is_last: is_last_item)
+                output << subtree
+              end
             else
               # Render intermediate path
               line = colorize("#{prefix}#{connector}#{key}:",
@@ -328,13 +334,13 @@ show_diffs: :all, theme: nil)
             # Handle bright_ colors: :bright_blue -> .blue.bright
             if c.to_s.start_with?("bright_")
               base = c.to_s.sub(/^bright_/, "").to_sym
-              presenter = presenter.send(base).bright
+              presenter = presenter.public_send(base).bright
             elsif c.to_s.start_with?("light_")
               # Rainbow doesn't have light_ versions
               base = c.to_s.sub(/^light_/, "").to_sym
-              presenter = presenter.send(base)
+              presenter = presenter.public_send(base)
             else
-              presenter = presenter.send(c)
+              presenter = presenter.public_send(c)
             end
           end
           presenter.to_s

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

@@ -136,7 +136,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 +159,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]
@@ -171,7 +289,8 @@ module Canon
           text2 = extract_text(node2)
 
           # Show parent element if available
-          if node1.respond_to?(:parent) && node1.parent.respond_to?(:name)
+          if (Canon::XmlParsing.xml_node?(node1) || node1.is_a?(Canon::Xml::Node)) &&
+              node1.parent
             output << "#{prefix}    #{colorize(
               "Element: <#{node1.parent.name}>",
               theme_color(:informative, :content) || :blue,
@@ -274,9 +393,9 @@ module Canon
           parts = []
           current = node
 
-          while current.respond_to?(:name)
+          while Canon::XmlParsing.xml_node?(current) || current.is_a?(Canon::Xml::Node)
             parts.unshift(current.name) if current.name
-            current = current.parent if current.respond_to?(:parent)
+            current = current.parent
           end
 
           parts.join(".")
@@ -287,13 +406,10 @@ module Canon
         # @param node [Object] Node with content or text
         # @return [String] Text content
         def extract_text(node)
-          if node.respond_to?(:value)
-            # CommentNode and similar nodes use .value
-            node.value.to_s
-          elsif node.respond_to?(:content)
-            node.content.to_s
-          elsif node.respond_to?(:text)
-            node.text.to_s
+          if node.is_a?(Canon::Xml::Node)
+            node.text_content.to_s
+          elsif Canon::XmlParsing.xml_node?(node)
+            Canon::XmlParsing.text_content(node).to_s
           else
             ""
           end

data/lib/canon/diff_formatter/by_object_formatter.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "paint"
+require "paint" unless RUBY_ENGINE == "opal"
 
 module Canon
   class DiffFormatter
@@ -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