canon 0.1.6 → 0.1.7

data/lib/canon/diff_formatter/diff_detail_formatter.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "paint"
+require_relative "../xml/namespace_helper"
 
 module Canon
   class DiffFormatter
@@ -16,6 +17,14 @@ module Canon
         def format_report(differences, use_color: true)
           return "" if differences.empty?
 
+          # Group differences by normative status
+          normative = differences.select do |diff|
+            diff.respond_to?(:normative?) ? diff.normative? : true
+          end
+          informative = differences.select do |diff|
+            diff.respond_to?(:normative?) && !diff.normative?
+          end
+
           output = []
           output << ""
           output << colorize("=" * 70, :cyan, use_color, bold: true)
@@ -24,10 +33,33 @@ module Canon
           )
           output << colorize("=" * 70, :cyan, use_color, bold: true)
 
-          differences.each_with_index do |diff, i|
+          # Show normative differences first
+          if normative.any?
             output << ""
-            output << format_single_diff(diff, i + 1, differences.length,
-                                         use_color)
+            output << colorize(
+              "┌─ NORMATIVE DIFFERENCES (#{normative.length}) ─┐", :green, use_color, bold: true
+            )
+
+            normative.each_with_index do |diff, i|
+              output << ""
+              output << format_single_diff(diff, i + 1, normative.length,
+                                           use_color, section: "NORMATIVE")
+            end
+          end
+
+          # Show informative differences second
+          if informative.any?
+            output << ""
+            output << ""
+            output << colorize(
+              "┌─ INFORMATIVE DIFFERENCES (#{informative.length}) ─┐", :yellow, use_color, bold: true
+            )
+
+            informative.each_with_index do |diff, i|
+              output << ""
+              output << format_single_diff(diff, i + 1, informative.length,
+                                           use_color, section: "INFORMATIVE")
+            end
           end
 
           output << ""
@@ -40,15 +72,15 @@ module Canon
         private
 
         # Format a single difference with dimension-specific details
-        def format_single_diff(diff, number, total, use_color)
+        def format_single_diff(diff, number, total, use_color, section: nil)
           output = []
 
           # Header - handle both DiffNode and Hash
-          status = if diff.respond_to?(:normative?)
-                     diff.normative? ? "NORMATIVE" : "INFORMATIVE"
-                   else
-                     "NORMATIVE" # Hash diffs are always normative
-                   end
+          status = section || (if diff.respond_to?(:normative?)
+                                 diff.normative? ? "NORMATIVE" : "INFORMATIVE"
+                               else
+                                 "NORMATIVE" # Hash diffs are always normative
+                               end)
           status_color = status == "NORMATIVE" ? :green : :yellow
           output << colorize("🔍 DIFFERENCE ##{number}/#{total} [#{status}]",
                              status_color, use_color, bold: true)
@@ -182,10 +214,18 @@ module Canon
           dimension = diff.respond_to?(:dimension) ? diff.dimension : nil
 
           case dimension
+          when :element_structure
+            format_element_structure_details(diff, use_color)
           when :attribute_presence
             format_attribute_presence_details(diff, use_color)
           when :attribute_values
             format_attribute_values_details(diff, use_color)
+          when :attribute_order
+            format_attribute_order_details(diff, use_color)
+          when :namespace_uri
+            format_namespace_uri_details(diff, use_color)
+          when :namespace_declarations
+            format_namespace_declarations_details(diff, use_color)
           when :text_content
             format_text_content_details(diff, use_color)
           when :structural_whitespace
@@ -197,6 +237,225 @@ module Canon
           end
         end
 
+        # Format namespace_uri dimension details
+        def format_namespace_uri_details(diff, use_color)
+          node1 = diff.node1
+          node2 = diff.node2
+
+          # Use NamespaceHelper for consistent formatting
+          ns1_display = Canon::Xml::NamespaceHelper.format_namespace(
+            node1.respond_to?(:namespace_uri) ? node1.namespace_uri : nil,
+          )
+          ns2_display = Canon::Xml::NamespaceHelper.format_namespace(
+            node2.respond_to?(:namespace_uri) ? node2.namespace_uri : nil,
+          )
+
+          element_name = if node1.respond_to?(:name)
+                           node1.name
+                         else
+                           node2.respond_to?(:name) ? node2.name : "element"
+                         end
+
+          detail1 = "<#{element_name}> #{colorize(ns1_display, :cyan,
+                                                  use_color)}"
+          detail2 = "<#{element_name}> #{colorize(ns2_display, :cyan,
+                                                  use_color)}"
+
+          changes = "Namespace differs: #{colorize(ns1_display, :red,
+                                                   use_color)} → #{colorize(
+                                                     ns2_display, :green, use_color
+                                                   )}"
+
+          [detail1, detail2, changes]
+        end
+
+        # Format namespace_declarations dimension details
+        def format_namespace_declarations_details(diff, use_color)
+          node1 = diff.node1
+          node2 = diff.node2
+
+          # Extract namespace declarations from both nodes
+          ns_decls1 = extract_namespace_declarations_from_node(node1)
+          ns_decls2 = extract_namespace_declarations_from_node(node2)
+
+          element_name = if node1.respond_to?(:name)
+                           node1.name
+                         else
+                           node2.respond_to?(:name) ? node2.name : "element"
+                         end
+
+          # Format namespace declarations for display
+          detail1 = if ns_decls1.empty?
+                      "<#{element_name}> #{colorize(
+                        '(no namespace declarations)', :red, use_color
+                      )}"
+                    else
+                      ns_str = ns_decls1.map do |prefix, uri|
+                        attr_name = prefix.empty? ? "xmlns" : "xmlns:#{prefix}"
+                        "#{attr_name}=\"#{uri}\""
+                      end.join(" ")
+                      "<#{element_name}> #{ns_str}"
+                    end
+
+          detail2 = if ns_decls2.empty?
+                      "<#{element_name}> #{colorize(
+                        '(no namespace declarations)', :green, use_color
+                      )}"
+                    else
+                      ns_str = ns_decls2.map do |prefix, uri|
+                        attr_name = prefix.empty? ? "xmlns" : "xmlns:#{prefix}"
+                        "#{attr_name}=\"#{uri}\""
+                      end.join(" ")
+                      "<#{element_name}> #{ns_str}"
+                    end
+
+          # Analyze changes
+          missing = ns_decls1.keys - ns_decls2.keys  # In node1 but not node2
+          extra = ns_decls2.keys - ns_decls1.keys    # In node2 but not node1
+          changed = ns_decls1.select do |prefix, uri|
+            ns_decls2[prefix] && ns_decls2[prefix] != uri
+          end.keys
+
+          # Format changes
+          changes_parts = []
+          if missing.any?
+            missing_str = missing.map do |prefix|
+              attr_name = prefix.empty? ? "xmlns" : "xmlns:#{prefix}"
+              colorize("-#{attr_name}=\"#{ns_decls1[prefix]}\"", :red,
+                       use_color)
+            end.join(", ")
+            changes_parts << "Removed: #{missing_str}"
+          end
+          if extra.any?
+            extra_str = extra.map do |prefix|
+              attr_name = prefix.empty? ? "xmlns" : "xmlns:#{prefix}"
+              colorize("+#{attr_name}=\"#{ns_decls2[prefix]}\"", :green,
+                       use_color)
+            end.join(", ")
+            changes_parts << "Added: #{extra_str}"
+          end
+          if changed.any?
+            changed_str = changed.map do |prefix|
+              attr_name = prefix.empty? ? "xmlns" : "xmlns:#{prefix}"
+              "#{colorize(attr_name, :cyan,
+                          use_color)}: \"#{ns_decls1[prefix]}\" → \"#{ns_decls2[prefix]}\""
+            end.join(", ")
+            changes_parts << "Changed: #{changed_str}"
+          end
+
+          changes = changes_parts.join(" | ")
+
+          [detail1, detail2, changes]
+        end
+
+        # Extract namespace declarations from a node (helper for formatter)
+        # @param node [Object] Node to extract namespace declarations from
+        # @return [Hash] Hash of prefix => URI mappings
+        def extract_namespace_declarations_from_node(node)
+          return {} if node.nil?
+
+          declarations = {}
+
+          # Handle Canon::Xml::Node (uses namespace_nodes)
+          if node.respond_to?(:namespace_nodes)
+            node.namespace_nodes.each do |ns|
+              # Skip the implicit xml namespace (always present)
+              next if ns.prefix == "xml" && ns.uri == "http://www.w3.org/XML/1998/namespace"
+
+              prefix = ns.prefix || ""
+              declarations[prefix] = ns.uri
+            end
+            return declarations
+          end
+
+          # Handle Nokogiri/Moxml nodes (use attributes)
+          # Get raw attributes
+          raw_attrs = if node.respond_to?(:attribute_nodes)
+                        node.attribute_nodes
+                      elsif node.respond_to?(:attributes)
+                        node.attributes
+                      else
+                        return {}
+                      end
+
+          # Handle Canon::Xml::Node attribute format (array of AttributeNode)
+          if raw_attrs.is_a?(Array)
+            raw_attrs.each do |attr|
+              name = attr.name
+              value = attr.value
+
+              if name == "xmlns" || name.start_with?("xmlns:")
+                # Extract prefix: "xmlns" -> "", "xmlns:xmi" -> "xmi"
+                prefix = name == "xmlns" ? "" : name.split(":", 2)[1]
+                declarations[prefix] = value
+              end
+            end
+          else
+            # Handle Nokogiri and Moxml attribute formats (Hash-like)
+            raw_attrs.each do |key, val|
+              if key.is_a?(String)
+                # Nokogiri format: key=name (String), val=attr object
+                name = key
+                value = val.respond_to?(:value) ? val.value : val.to_s
+              else
+                # Moxml format: key=attr object, val=nil
+                name = key.respond_to?(:name) ? key.name : key.to_s
+                value = key.respond_to?(:value) ? key.value : key.to_s
+              end
+
+              if name == "xmlns" || name.start_with?("xmlns:")
+                # Extract prefix: "xmlns" -> "", "xmlns:xmi" -> "xmi"
+                prefix = name == "xmlns" ? "" : name.split(":", 2)[1]
+                declarations[prefix] = value
+              end
+            end
+          end
+
+          declarations
+        end
+
+        # Format element_structure dimension details (INSERT/DELETE operations)
+        def format_element_structure_details(diff, use_color)
+          node1 = diff.node1
+          node2 = diff.node2
+
+          # Determine operation type
+          if node1.nil? && !node2.nil?
+            # INSERT operation - show content preview
+            node2.respond_to?(:name) ? node2.name : "element"
+            content_preview = extract_content_preview(node2, 50)
+            detail1 = colorize("(not present)", :red, use_color)
+            detail2 = content_preview
+            changes = "Element inserted"
+          elsif !node1.nil? && node2.nil?
+            # DELETE operation - show content preview
+            node1.respond_to?(:name) ? node1.name : "element"
+            content_preview = extract_content_preview(node1, 50)
+            detail1 = content_preview
+            detail2 = colorize("(not present)", :green, use_color)
+            changes = "Element deleted"
+          elsif !node1.nil? && !node2.nil?
+            # STRUCTURAL CHANGE (both nodes present) - show both previews
+            name1 = node1.respond_to?(:name) ? node1.name : "element"
+            name2 = node2.respond_to?(:name) ? node2.name : "element"
+            detail1 = extract_content_preview(node1, 50)
+            detail2 = extract_content_preview(node2, 50)
+
+            changes = if name1 == name2
+                        "Element structure changed"
+                      else
+                        "Element type changed: #{name1} → #{name2}"
+                      end
+          else
+            # Both nil (shouldn't happen)
+            detail1 = "(nil)"
+            detail2 = "(nil)"
+            changes = "Unknown structural change"
+          end
+
+          [detail1, detail2, changes]
+        end
+
         # Format attribute_presence dimension details
         def format_attribute_presence_details(diff, use_color)
           node1 = diff.node1
@@ -240,26 +499,42 @@ module Canon
           node1 = diff.node1
           node2 = diff.node2
 
-          # Find which attribute has different value
-          differing_attr = find_differing_attribute(node1, node2)
-
-          if differing_attr
-            val1 = get_attribute_value(node1, differing_attr)
-            val2 = get_attribute_value(node2, differing_attr)
-
-            detail1 = "<#{node1.name}> #{colorize(differing_attr, :cyan,
-                                                  use_color)}=\"#{escape_quotes(val1)}\""
-            detail2 = "<#{node2.name}> #{colorize(differing_attr, :cyan,
-                                                  use_color)}=\"#{escape_quotes(val2)}\""
+          # Find ALL attributes with different values
+          differing_attrs = find_all_differing_attributes(node1, node2)
+
+          if differing_attrs.any?
+            # Show element name with all differing attributes
+            attrs1_str = differing_attrs.map do |attr|
+              val1 = get_attribute_value(node1, attr)
+              "#{colorize(attr, :cyan, use_color)}=\"#{escape_quotes(val1)}\""
+            end.join(" ")
+
+            attrs2_str = differing_attrs.map do |attr|
+              val2 = get_attribute_value(node2, attr)
+              "#{colorize(attr, :cyan, use_color)}=\"#{escape_quotes(val2)}\""
+            end.join(" ")
+
+            detail1 = "<#{node1.name}> #{attrs1_str}"
+            detail2 = "<#{node2.name}> #{attrs2_str}"
+
+            # List all attribute changes
+            changes_parts = differing_attrs.map do |attr|
+              val1 = get_attribute_value(node1, attr)
+              val2 = get_attribute_value(node2, attr)
+
+              if val1.empty? && !val2.empty?
+                "#{colorize(attr, :cyan,
+                            use_color)}: (added) → \"#{escape_quotes(val2)}\""
+              elsif !val1.empty? && val2.empty?
+                "#{colorize(attr, :cyan,
+                            use_color)}: \"#{escape_quotes(val1)}\" → (removed)"
+              else
+                "#{colorize(attr, :cyan,
+                            use_color)}: \"#{escape_quotes(val1)}\" → \"#{escape_quotes(val2)}\""
+              end
+            end
 
-            # Analyze the difference
-            changes = if val1.strip == val2.strip && val1 != val2
-                        "Whitespace difference only"
-                      elsif val1.gsub(/\s+/, " ") == val2.gsub(/\s+/, " ")
-                        "Whitespace normalization difference"
-                      else
-                        "Value changed"
-                      end
+            changes = changes_parts.join("; ")
 
             [detail1, detail2, changes]
           else
@@ -268,7 +543,32 @@ module Canon
           end
         end
 
-        # Format text_content dimension details
+        # Format attribute_order dimension details
+        def format_attribute_order_details(diff, use_color)
+          node1 = diff.node1
+          node2 = diff.node2
+
+          # Get attribute names in order
+          attrs1 = get_attribute_names_in_order(node1)
+          attrs2 = get_attribute_names_in_order(node2)
+
+          # Format as ordered list
+          attrs1_str = "[#{attrs1.join(', ')}]"
+          attrs2_str = "[#{attrs2.join(', ')}]"
+
+          detail1 = "<#{node1.name}> attributes in order: #{colorize(
+            attrs1_str, :cyan, use_color
+          )}"
+          detail2 = "<#{node2.name}> attributes in order: #{colorize(
+            attrs2_str, :cyan, use_color
+          )}"
+
+          changes = "Attribute order changed: #{attrs1_str} → #{attrs2_str}"
+
+          [detail1, detail2, changes]
+        end
+
+        # Format text content dimension details
         def format_text_content_details(diff, use_color)
           node1 = diff.node1
           node2 = diff.node2
@@ -280,13 +580,46 @@ module Canon
           preview1 = truncate_text(text1, 100)
           preview2 = truncate_text(text2, 100)
 
-          element_name = node1.respond_to?(:name) ? node1.name : "(text)"
-
-          detail1 = "<#{element_name}> \"#{escape_quotes(preview1)}\""
-          detail2 = "<#{element_name}> \"#{escape_quotes(preview2)}\""
+          # Get element names - for text nodes, use parent element name
+          # When one node is nil, use the other's name for context
+          element_name1 = get_element_name_for_display(node1)
+          element_name2 = get_element_name_for_display(node2)
+
+          # If one shows nil-node, try to use the other's name for context
+          if element_name1.include?("nil") && !element_name2.include?("nil")
+            # Use node2's name as a hint for what node1 should be
+            element_name1 = element_name2
+          elsif element_name2.include?("nil") && !element_name1.include?("nil")
+            # Use node1's name as a hint for what node2 should be
+            element_name2 = element_name1
+          end
 
-          # Check if inside whitespace-preserving element
-          changes = if inside_preserve_element?(node1) || inside_preserve_element?(node2)
+          # Get namespace URIs
+          ns1 = get_namespace_uri_for_display(node1)
+          ns2 = get_namespace_uri_for_display(node2)
+
+          # Build namespace display strings using NamespaceHelper
+          ns1_info = if ns1 && !ns1.empty?
+                       " #{Canon::Xml::NamespaceHelper.format_namespace(ns1)}"
+                     else
+                       ""
+                     end
+
+          ns2_info = if ns2 && !ns2.empty?
+                       " #{Canon::Xml::NamespaceHelper.format_namespace(ns2)}"
+                     else
+                       ""
+                     end
+
+          detail1 = "<#{element_name1}>#{ns1_info} \"#{escape_quotes(preview1)}\""
+          detail2 = "<#{element_name2}>#{ns2_info} \"#{escape_quotes(preview2)}\""
+
+          # Check if diff contains namespace information in reason
+          # If so, display it prominently
+          changes = if diff.respond_to?(:reason) && diff.reason&.include?("namespace")
+                      diff.reason
+                    # Check if inside whitespace-preserving element
+                    elsif inside_preserve_element?(node1) || inside_preserve_element?(node2)
                       colorize("⚠️  Whitespace preserved", :yellow, use_color,
                                bold: true) +
                         " (inside <pre>, <code>, etc. - whitespace is significant)"
@@ -297,7 +630,7 @@ module Canon
           [detail1, detail2, changes]
         end
 
-        # Format structural_whitespace dimension details
+        # Format structural whitespace dimension details
         def format_structural_whitespace_details(diff, _use_color)
           node1 = diff.node1
           node2 = diff.node2
@@ -387,42 +720,142 @@ module Canon
 
         # Helper: Get attribute names from a node
         def get_attribute_names(node)
+          # Handle Canon::Xml::Nodes::ElementNode (uses attribute_nodes array)
+          if node.respond_to?(:attribute_nodes) && node.attribute_nodes.is_a?(Array)
+            return node.attribute_nodes.map(&:qname).sort
+          end
+
           return [] unless node.respond_to?(:attributes)
 
-          node.attributes.map do |key, _val|
-            if key.is_a?(String)
-              key
-            else
-              (key.respond_to?(:name) ? key.name : key.to_s)
-            end
-          end.sort
+          attrs = node.attributes
+
+          # Handle Moxml::Element (attributes is an Array)
+          if attrs.is_a?(Array)
+            attrs.map do |attr|
+              if attr.respond_to?(:qname)
+                attr.qname
+              elsif attr.respond_to?(:name)
+                attr.name
+              else
+                attr.to_s
+              end
+            end.sort
+          # Handle Nokogiri nodes (attributes is a Hash)
+          else
+            attrs.map do |key, val|
+              # Get the qualified name (with prefix if present)
+              if val.respond_to?(:namespace) && val.namespace&.prefix
+                "#{val.namespace.prefix}:#{val.name}"
+              else
+                val.respond_to?(:name) ? val.name : key.to_s
+              end
+            end.sort
+          end
         end
 
-        # Helper: Find which attribute has different value
-        def find_differing_attribute(node1, node2)
-          return nil unless node1.respond_to?(:attributes) && node2.respond_to?(:attributes)
+        # Helper: Find ALL attributes with different values
+        def find_all_differing_attributes(node1, node2)
+          return [] unless node1.respond_to?(:attributes) && node2.respond_to?(:attributes)
 
           attrs1 = get_attributes_hash(node1)
           attrs2 = get_attributes_hash(node2)
 
-          # Find first attribute with different value
-          common_keys = attrs1.keys & attrs2.keys
-          common_keys.find { |key| attrs1[key] != attrs2[key] }
+          # Find all attributes with different values
+          all_keys = (attrs1.keys + attrs2.keys).uniq
+          all_keys.reject do |key|
+            attrs1[key] == attrs2[key]
+          end
+        end
+
+        # Helper: Get attribute names in document order (not sorted)
+        def get_attribute_names_in_order(node)
+          # Handle Canon::Xml::Nodes::ElementNode (uses attribute_nodes array)
+          if node.respond_to?(:attribute_nodes) && node.attribute_nodes.is_a?(Array)
+            return node.attribute_nodes.map(&:qname)
+          end
+
+          return [] unless node.respond_to?(:attributes)
+
+          attrs = node.attributes
+
+          # Handle Moxml::Element (attributes is an Array)
+          if attrs.is_a?(Array)
+            attrs.map do |attr|
+              # Use qname for AttributeNode objects (includes prefix)
+              if attr.respond_to?(:qname)
+                attr.qname
+              elsif attr.respond_to?(:name)
+                attr.name
+              else
+                attr.to_s
+              end
+            end
+          # Handle Nokogiri nodes (attributes is a Hash)
+          else
+            attrs.map do |key, val|
+              # For Nokogiri attributes, get the full qualified name
+              if key.is_a?(String)
+                key
+              elsif val.respond_to?(:namespace) && val.namespace
+                # Construct qualified name if attribute has a namespace prefix
+                prefix = val.namespace.prefix
+                name = val.respond_to?(:name) ? val.name : key.to_s
+                prefix ? "#{prefix}:#{name}" : name
+              else
+                (key.respond_to?(:name) ? key.name : key.to_s)
+              end
+            end
+          end
         end
 
         # Helper: Get attributes as hash
         def get_attributes_hash(node)
+          # Handle Canon::Xml::Nodes::ElementNode (uses attribute_nodes array)
+          if node.respond_to?(:attribute_nodes) && node.attribute_nodes.is_a?(Array)
+            hash = {}
+            node.attribute_nodes.each do |attr|
+              hash[attr.qname] = attr.value
+            end
+            return hash
+          end
+
           return {} unless node.respond_to?(:attributes)
 
           hash = {}
-          node.attributes.each do |key, val|
-            name = if key.is_a?(String)
-                     key
-                   else
-                     (key.respond_to?(:name) ? key.name : key.to_s)
-                   end
-            value = val.respond_to?(:value) ? val.value : val.to_s
-            hash[name] = value
+          attrs = node.attributes
+
+          # Handle Moxml::Element (attributes is an Array of Moxml::Attribute)
+          if attrs.is_a?(Array)
+            attrs.each do |attr|
+              # Use qname for AttributeNode objects (includes prefix)
+              name = if attr.respond_to?(:qname)
+                       attr.qname
+                     elsif attr.respond_to?(:name)
+                       attr.name
+                     else
+                       attr.to_s
+                     end
+              value = if attr.respond_to?(:value)
+                        attr.value
+                      elsif attr.respond_to?(:native) && attr.native.respond_to?(:value)
+                        attr.native.value
+                      else
+                        attr.to_s
+                      end
+              hash[name] = value
+            end
+          # Handle Nokogiri nodes (attributes is a Hash)
+          else
+            attrs.each do |key, val|
+              # Get the qualified name (with prefix if present)
+              name = if val.respond_to?(:namespace) && val.namespace&.prefix
+                       "#{val.namespace.prefix}:#{val.name}"
+                     else
+                       val.respond_to?(:name) ? val.name : key.to_s
+                     end
+              value = val.respond_to?(:value) ? val.value : val.to_s
+              hash[name] = value
+            end
           end
           hash
         end
@@ -446,6 +879,139 @@ module Canon
           end
         end
 
+        # Helper: Get element name for display
+        # For text nodes, returns parent element name
+        # For element nodes, returns the node's own name
+        def get_element_name_for_display(node)
+          # Handle completely nil nodes
+          return "(nil-node)" if node.nil?
+
+          # Try to get name
+          node_name = if node.respond_to?(:name)
+                        begin
+                          node.name
+                        rescue StandardError
+                          nil
+                        end
+                      end
+
+          # Special check: if name is explicitly nil (not just empty), this might be a parsing issue
+          # Show node type information to help debug
+          if node_name.nil?
+            # Try to show what type of node this is
+            if node.respond_to?(:node_type)
+              type = begin
+                node.node_type
+              rescue StandardError
+                nil
+              end
+              return "(nil-name:#{type})" if type
+            end
+
+            # fallback to class name
+            class_info = node.class.name&.split("::")&.last || "UnknownClass"
+            return "(nil-name:#{class_info})"
+          end
+
+          # If we have a valid element name, return it
+          if !node_name.to_s.empty? && !["#text", "text", "#document",
+                                         "document"].include?(node_name.to_s)
+            return node_name.to_s
+          end
+
+          # Check if this is a text node
+          is_text_node = if node.respond_to?(:node_type)
+                           begin
+                             node.node_type == :text
+                           rescue StandardError
+                             false
+                           end
+                         elsif ["#text", "text"].include?(node_name.to_s)
+                           true
+                         elsif node.class.name
+                           node.class.name.include?("TextNode") ||
+                             node.class.name.include?("Text")
+                         else
+                           false
+                         end
+
+          # For text nodes or document nodes, try parent
+          if is_text_node || ["#text", "text", "#document",
+                              "document"].include?(node_name.to_s)
+            parent = if node.respond_to?(:parent)
+                       begin
+                         node.parent
+                       rescue StandardError
+                         nil
+                       end
+                     end
+
+            max_depth = 5
+            depth = 0
+
+            # Traverse up to find named parent element
+            while parent && depth < max_depth
+              parent_name = if parent.respond_to?(:name)
+                              begin
+                                parent.name
+                              rescue StandardError
+                                nil
+                              end
+                            end
+
+              if parent_name && !parent_name.to_s.empty? &&
+                  !["#text", "text", "#document",
+                    "document"].include?(parent_name.to_s)
+                return parent_name.to_s
+              end
+
+              parent = if parent.respond_to?(:parent)
+                         begin
+                           parent.parent
+                         rescue StandardError
+                           nil
+                         end
+                       end
+              depth += 1
+            end
+
+            # Still no name found
+            return "(text)" if is_text_node
+
+            return "(no-name)"
+          end
+
+          # Fallback
+          node_name.to_s
+        end
+
+        # Helper: Get namespace URI for display
+        # For text nodes, returns parent element's namespace URI
+        # For element nodes, returns the node's own namespace URI
+        def get_namespace_uri_for_display(node)
+          # Check if this is a text node
+          is_text_node = if node.respond_to?(:node_type)
+                           node.node_type == :text
+                         elsif node.class.name
+                           node.class.name.include?("TextNode") || node.class.name.include?("Text")
+                         else
+                           false
+                         end
+
+          if is_text_node
+            # For text nodes, get parent element's namespace
+            parent = node.respond_to?(:parent) ? node.parent : nil
+            if parent.respond_to?(:namespace_uri)
+              parent.namespace_uri
+            end
+          elsif node.respond_to?(:namespace_uri)
+            # For element nodes, use their own namespace
+            node.namespace_uri
+          else
+            nil
+          end
+        end
+
         # Helper: Truncate text to max length
         def truncate_text(text, max_length)
           return text if text.length <= max_length
@@ -535,6 +1101,57 @@ module Canon
           end
         end
 
+        # Helper: Extract content preview from a node
+        # Shows element name, attributes, and text content for clarity
+        def extract_content_preview(node, max_length = 50)
+          return "(nil)" if node.nil?
+
+          parts = []
+
+          # Add element name
+          if node.respond_to?(:name)
+            parts << "<#{node.name}>"
+          end
+
+          # Add key attributes (id, class, name, type)
+          if node.respond_to?(:attributes) && node.attributes&.any?
+            key_attrs = %w[id class name type]
+            attrs_hash = get_attributes_hash(node)
+
+            key_attr_strs = key_attrs.map do |key|
+              next unless attrs_hash.key?(key)
+
+              val = attrs_hash[key]
+              next if val.nil? || val.empty?
+
+              # Truncate long attribute values
+              val_preview = val.length > 20 ? "#{val[0..17]}..." : val
+              "#{key}=\"#{val_preview}\""
+            end.compact
+
+            parts << "[#{key_attr_strs.join(' ')}]" if key_attr_strs.any?
+          end
+
+          # Add text content preview
+          text = get_node_text(node)
+          if text && !text.empty?
+            text_preview = text.strip
+            # Only show text if meaningful (not just whitespace)
+            if text_preview.length.positive?
+              text_preview = text_preview.length > 40 ? "#{text_preview[0..37]}..." : text_preview
+              parts << "\"#{text_preview}\""
+            end
+          elsif node.respond_to?(:children) && node.children&.any?
+            # Show child count if no text but has children
+            parts << "(#{node.children.length} children)"
+          end
+
+          result = parts.join(" ")
+
+          # Truncate if still too long
+          result.length > max_length ? "#{result[0...max_length - 3]}..." : result
+        end
+
         # Helper: Colorize text
         def colorize(text, color, use_color, bold: false)
           return text unless use_color