canon 0.2.8 → 0.2.9

data/lib/canon/comparison/whitespace_sensitivity.rb

@@ -3,41 +3,6 @@
 module Canon
   module Comparison
     # Whitespace sensitivity utilities for element-level control
-    #
-    # This module provides three-way classification of whitespace behaviour
-    # at the element level:
-    #
-    # * **:preserve** — every whitespace character is significant. `" "` ≠ `"\n"`.
-    #   Configured via +preserve_whitespace_elements+ (HTML default: pre, code,
-    #   textarea, script, style; XML default: none).
-    #
-    # * **:collapse** — presence ≠ absence, but all whitespace forms are
-    #   equivalent: `" "` == `"\n  "`. Configured via +collapse_whitespace_elements+
-    #   (HTML default: p, li, dt, dd, td, th, h1-h6, caption, figcaption, label,
-    #   legend, summary, blockquote, address; XML default: none).
-    #
-    # * **:strip** — all whitespace is structural formatting noise and is
-    #   dropped. Default for XML; HTML elements not in the above lists.
-    #
-    # Classification is **ancestor-based**: the closest matching ancestor
-    # determines the class. The strip blacklist (+strip_whitespace_elements+)
-    # overrides any sensitive ancestor.
-    #
-    # == Priority Order
-    #
-    # 1. respect_xml_space: false → User config only (ignore xml:space)
-    # 2. Ancestor walk (strip blacklist wins; then preserve; then collapse)
-    # 3. xml:space="preserve" → preserve
-    # 4. xml:space="default" → use configured behaviour
-    # 5. Format defaults (HTML: collapse for most elements; XML: strip)
-    #
-    # == Usage
-    #
-    #   WhitespaceSensitivity.classify_element(element, match_opts)
-    #   => :preserve, :collapse, or :strip
-    #
-    #   WhitespaceSensitivity.element_sensitive?(node, opts)
-    #   => true if whitespace should be preserved (preserve or collapse)
     module WhitespaceSensitivity
       # HTML mixed-content "leaf block" elements where whitespace presence
       # matters but all forms are equivalent (CSS block whitespace collapsing).
@@ -61,80 +26,52 @@ module Canon
 
       class << self
         # Classify the whitespace behaviour for an element using ancestor walk.
-        #
-        # @param element [Object] The element node to classify
-        # @param match_opts [Hash] Resolved match options
-        # @return [Symbol] :preserve, :collapse, or :strip
         def classify_element(element, match_opts)
           return :strip unless element
-          return :strip unless element.respond_to?(:name)
+          return :strip unless node_name(element)
 
           preserve_set  = resolved_preserve_elements_set(match_opts)
           collapse_set  = resolved_collapse_elements_set(match_opts)
           strip_set = resolved_strip_elements_set(match_opts)
 
-          # Ancestor walk: start at the element itself, walk up.
-          # Strip blacklist wins over any sensitive ancestor.
           walk_ancestor_classification(element, preserve_set, collapse_set,
-                                       strip_set, match_opts)
+                                       strip_set)
         end
 
         # Check if an element is whitespace-sensitive based on configuration.
-        # Returns true for :preserve or :collapse classification.
-        #
-        # @param node [Object] The element node to check
-        # @param opts [Hash] Comparison options containing match_opts
-        # @return [Boolean] true if whitespace should be preserved for this element
         def element_sensitive?(node, opts)
           match_opts = opts[:match_opts]
           return false unless match_opts
           return false unless text_node_parent?(node)
 
-          parent = node.parent
+          parent = node_parent(node)
 
-          # 1. Check if we should ignore xml:space (user override)
           unless respect_xml_space?(match_opts)
             return user_config_sensitive?(parent, match_opts)
           end
 
-          # 2. Check xml:space="preserve" (document declaration)
           return true if xml_space_preserve?(parent)
-
-          # 3. Check xml:space="default" (use configured behavior)
           return false if xml_space_default?(parent)
 
-          # 4. Three-way classification (ancestor-based)
           classification = classify_element(parent, match_opts)
           %i[preserve collapse].include?(classification)
         end
 
         # Check if whitespace-only text node should be filtered
-        #
-        # @param node [Object] The text node to check
-        # @param opts [Hash] Comparison options
-        # @return [Boolean] true if node should be preserved (not filtered)
         def preserve_whitespace_node?(node, opts)
-          return false unless node.respond_to?(:parent)
-          return false unless node.parent
+          parent = node_parent(node)
+          return false unless parent
 
           element_sensitive?(node, opts)
         end
 
         # Return the whitespace class for a text node used during comparison.
-        #
-        # :preserve   → preserve all whitespace character-by-character
-        # :collapse   → preserve presence (normalize to single space)
-        # :strip      → drop whitespace-only text nodes
-        #
-        # @param node [Object] Text node to classify
-        # @param opts [Hash] Comparison options containing match_opts
-        # @return [Symbol] :preserve, :collapse, or :strip
         def classify_text_node(node, opts)
           match_opts = opts[:match_opts]
           return :strip unless match_opts
           return :strip unless text_node_parent?(node)
 
-          parent = node.parent
+          parent = node_parent(node)
 
           unless respect_xml_space?(match_opts)
             return user_config_sensitive?(parent,
@@ -148,15 +85,6 @@ module Canon
         end
 
         # Check if structural whitespace is preserved (not stripped) for an element.
-        #
-        # Uses the same priority chain as element_sensitive? / classify_text_node:
-        #   1. xml:space="preserve" → always preserved
-        #   2. xml:space="default"  → use configured behaviour
-        #   3. ancestor-walk classification (strip = dropped)
-        #
-        # @param element [Object] Element node to check
-        # @param match_opts [Hash] Resolved match options
-        # @return [Boolean] true if whitespace is preserved (not stripped)
         def whitespace_preserved?(element, match_opts)
           if respect_xml_space?(match_opts)
             return true  if xml_space_preserve?(element)
@@ -167,27 +95,14 @@ module Canon
           %i[preserve collapse].include?(classification)
         end
 
-        # Get resolved list of preserve whitespace element names (strings).
-        #
-        # @param match_opts [Hash] Resolved match options
-        # @return [Array<String>] Preserve element names
         def resolved_preserve_elements(match_opts)
           resolved_preserve_elements_set(match_opts).to_a
         end
 
-        # Get resolved list of collapse whitespace element names (strings).
-        #
-        # @param match_opts [Hash] Resolved match options
-        # @return [Array<String>] Collapse element names
         def resolved_collapse_elements(match_opts)
           resolved_collapse_elements_set(match_opts).to_a
         end
 
-        # Get format-specific default preserve (exact-whitespace) elements.
-        # This is the SINGLE SOURCE OF TRUTH for default preserve-whitespace elements.
-        #
-        # @param match_opts [Hash] Resolved match options
-        # @return [Array<Symbol>] Default preserve element names
         def format_default_preserve_elements(match_opts)
           format = match_opts[:format] || :xml
           case format
@@ -198,10 +113,6 @@ module Canon
           end
         end
 
-        # Get format-specific default collapse elements.
-        #
-        # @param match_opts [Hash] Resolved match options
-        # @return [Array<Symbol>] Default collapse element names
         def format_default_collapse_elements(match_opts)
           format = match_opts[:format] || :xml
           case format
@@ -212,61 +123,32 @@ module Canon
           end
         end
 
-        # Check if an element is in the default sensitive list for its format
-        #
-        # @param element_name [String, Symbol] The element name to check
-        # @param match_opts [Hash] Resolved match options
-        # @return [Boolean] true if element is in default sensitive list
         def default_sensitive_element?(element_name, match_opts)
           format_default_preserve_elements(match_opts)
             .include?(element_name.to_sym)
         end
 
-        # Check if a whitespace-only text node sits between two inline element
+        # Check if whitespace-only text node sits between two inline element
         # siblings, making the whitespace semantically significant.
-        #
-        # In HTML rendering, a space between <span>A</span> <span>B</span>
-        # produces visible output.  Stripping such nodes produces false
-        # equivalence.
-        #
-        # Works with any parent type (element, DocumentFragment, RootNode)
-        # since the check is about sibling context, not parent type.
-        #
-        # @param text_node [Object] Text node (Nokogiri or Canon::Xml::Node)
-        # @return [Boolean] true if whitespace is between inline siblings
         def inline_whitespace_significant?(text_node)
-          return false unless text_node.respond_to?(:parent)
-
-          parent = text_node.parent
+          parent = NodeInspector.parent(text_node)
           return false unless parent
-          return false unless parent.respond_to?(:children)
 
-          siblings = parent.children
+          siblings = NodeInspector.children(parent)
           idx = siblings.index(text_node)
           return false unless idx
 
-          # Look at the IMMEDIATE non-whitespace-text neighbour on each
-          # side. Whitespace at a block boundary is collapsed per CSS,
-          # so both immediate neighbours must be inline for the
-          # whitespace to be significant. Walking all siblings (the
-          # earlier behaviour) misclassified whitespace at a block
-          # boundary as significant whenever any inline element existed
-          # elsewhere among the siblings.
           prev_neighbour = nearest_non_whitespace_sibling(siblings, idx, -1)
           next_neighbour = nearest_non_whitespace_sibling(siblings, idx,  1)
 
           inline_element?(prev_neighbour) && inline_element?(next_neighbour)
         end
 
-        # Walk outward from +idx+ in +direction+ (+1 forward, -1 back),
-        # skipping whitespace-only text nodes, and return the first
-        # non-whitespace sibling found.  Returns nil if none.
         def nearest_non_whitespace_sibling(siblings, idx, direction)
           i = idx + direction
           while i >= 0 && i < siblings.length
             s = siblings[i]
-            unless s.respond_to?(:text?) && s.text? &&
-                s.respond_to?(:content) && s.content.to_s.strip.empty?
+            unless whitespace_text_node?(s)
               return s
             end
 
@@ -275,19 +157,32 @@ module Canon
           nil
         end
 
-        # Check if text content contains a non-breaking space (U+00A0).
-        # NBSP is NOT collapsible whitespace in HTML — it always renders as
-        # a visible space and must never be stripped.
-        #
-        # @param text [String] Text content to check
-        # @return [Boolean] true if text contains U+00A0
         def contains_nbsp?(text)
-          text.to_s.include?("\u00A0")
+          text.to_s.include?(" ")
         end
 
         private
 
-        # Build the Set of preserve whitespace element names (strings).
+        def whitespace_text_node?(node)
+          NodeInspector.whitespace_only_text?(node)
+        end
+
+        def node_name(node)
+          NodeInspector.name(node)
+        end
+
+        def node_parent(node)
+          NodeInspector.parent(node)
+        end
+
+        def node_children(node)
+          NodeInspector.children(node)
+        end
+
+        def element?(node)
+          NodeInspector.element_node?(node)
+        end
+
         def resolved_preserve_elements_set(match_opts)
           set = Set.new(format_default_preserve_elements(match_opts).map(&:to_s))
 
@@ -295,12 +190,10 @@ module Canon
             set |= match_opts[:preserve_whitespace_elements].map(&:to_s)
           end
 
-          # Remove blacklisted elements
           strip_set = resolved_strip_elements_set(match_opts)
           set.reject { |e| strip_set.include?(e) }.to_set
         end
 
-        # Build the Set of collapse whitespace element names (strings).
         def resolved_collapse_elements_set(match_opts)
           set = Set.new(format_default_collapse_elements(match_opts).map(&:to_s))
 
@@ -308,49 +201,36 @@ module Canon
             set |= match_opts[:collapse_whitespace_elements].map(&:to_s)
           end
 
-          # Remove blacklisted elements
           strip_set = resolved_strip_elements_set(match_opts)
           set.reject { |e| strip_set.include?(e) }.to_set
         end
 
-        # Build the Set of strip (blacklist) element names (strings).
         def resolved_strip_elements_set(match_opts)
           raw = match_opts[:strip_whitespace_elements]
           Set.new((raw || []).map(&:to_s))
         end
 
-        # Perform the ancestor walk classification.
-        # The element itself is checked first, then its ancestors.
-        # Strip blacklist wins over any sensitive ancestor.
         def walk_ancestor_classification(element, preserve_set, collapse_set,
-                                         strip_set, _match_opts)
+                                         strip_set)
           current = element
-          while current.respond_to?(:name)
-            name = current.name.to_s
+          while current
+            name = node_name(current)
+            break unless name
 
-            return :strip    if strip_set.include?(name)
-            return :preserve if preserve_set.include?(name)
-            return :collapse if collapse_set.include?(name)
+            return :strip    if strip_set.include?(name.to_s)
+            return :preserve if preserve_set.include?(name.to_s)
+            return :collapse if collapse_set.include?(name.to_s)
 
-            # Walk up
-            break unless current.respond_to?(:parent)
-
-            parent = current.parent
+            parent = node_parent(current)
             break if parent.nil?
-            break unless parent.respond_to?(:name)
-            break if parent == current # guard infinite loop
+            break if parent == current
 
             current = parent
           end
 
-          # No matching ancestor — whitespace sensitivity is always opt-in.
-          # Elements not in any list are strip regardless of format.
-          # (HTML_COLLAPSE_ELEMENTS are already merged into the collapse_set
-          #  by resolved_collapse_elements_set, so they are found during the walk.)
           :strip
         end
 
-        # Check if we should respect xml:space attribute
         def respect_xml_space?(match_opts)
           if match_opts.key?(:respect_xml_space)
             match_opts[:respect_xml_space]
@@ -359,7 +239,6 @@ module Canon
           end
         end
 
-        # Check if xml:space="preserve" is set
         def xml_space_preserve?(element)
           if element.is_a?(Canon::Xml::Nodes::ElementNode)
             element.attribute_nodes.any? do |attr|
@@ -367,14 +246,12 @@ module Canon
                 attr.namespace_uri == "http://www.w3.org/XML/1998/namespace" &&
                 attr.value == "preserve"
             end
-          elsif element.respond_to?(:[])
-            element["xml:space"] == "preserve"
           else
-            false
+            Canon::XmlParsing.attribute_value(element,
+                                              "xml:space") == "preserve"
           end
         end
 
-        # Check if xml:space="default" is set
         def xml_space_default?(element)
           if element.is_a?(Canon::Xml::Nodes::ElementNode)
             element.attribute_nodes.any? do |attr|
@@ -382,55 +259,40 @@ module Canon
                 attr.namespace_uri == "http://www.w3.org/XML/1998/namespace" &&
                 attr.value == "default"
             end
-          elsif element.respond_to?(:[])
-            element["xml:space"] == "default"
           else
-            false
+            Canon::XmlParsing.attribute_value(element, "xml:space") == "default"
           end
         end
 
-        # Check sensitivity based on user configuration (binary, no ancestor)
         def user_config_sensitive?(element, match_opts)
           list = match_opts[:preserve_whitespace_elements]
           return false unless list
 
-          list.map(&:to_s).include?(element.name.to_s)
+          name = node_name(element)
+          return false unless name
+
+          list.map(&:to_s).include?(name.to_s)
         end
 
-        # Check if node has a parent that's an element (not document root)
         def text_node_parent?(node)
-          return false unless node.respond_to?(:parent)
-          return false unless node.parent
-
-          parent = node.parent
-          return true if parent.respond_to?(:element?) && parent.element?
+          parent = node_parent(node)
+          return false unless parent
 
-          # Nokogiri compatibility
-          parent.respond_to?(:node_type) && parent.node_type == :element
+          element?(parent)
         end
 
-        # Get the parent element of a text node, or nil.
-        # Works with both Nokogiri and Canon::Xml::Node types.
         def parent_element_of(text_node)
-          return nil unless text_node.respond_to?(:parent)
-
-          parent = text_node.parent
+          parent = node_parent(text_node)
           return nil unless parent
 
-          if parent.is_a?(Canon::Xml::Nodes::ElementNode)
-            parent
-          elsif parent.respond_to?(:element?) && parent.element?
-            parent
-          elsif parent.respond_to?(:node_type) && parent.node_type == :element
-            parent
-          end
+          parent if element?(parent)
         end
 
-        # Check if a node is an HTML inline element.
         def inline_element?(node)
-          return false unless node.respond_to?(:name)
+          name = node_name(node)
+          return false unless name
 
-          INLINE_ELEMENTS.include?(node.name.to_s.downcase)
+          INLINE_ELEMENTS.include?(name.to_s.downcase)
         end
       end
     end

data/lib/canon/comparison/xml_comparator/attribute_filter.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "../match_options"
+require_relative "../../xml/namespace_helper"
 
 module Canon
   module Comparison
@@ -91,13 +92,11 @@ module Canon
         # @return [Array<String, String>] Normalized [name, value] pair
         def self.normalize_attribute_pair(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
+            value = val.is_a?(String) ? val : val.value
           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
+            name = key.name
+            value = key.value
           end
 
           [name, value]
@@ -123,12 +122,8 @@ module Canon
           end
         end
 
-        # Check if an attribute name is a namespace declaration
-        #
-        # @param attr_name [String] Attribute name
-        # @return [Boolean] true if it's a namespace declaration
         def self.namespace_declaration?(attr_name)
-          attr_name == "xmlns" || attr_name.start_with?("xmlns:")
+          Canon::Xml::NamespaceHelper.namespace_declaration?(attr_name)
         end
       end
     end

data/lib/canon/comparison/xml_comparator/child_comparison.rb

@@ -83,10 +83,10 @@ module Canon
 
             # Create temporary RootNode wrappers
             temp_root1 = Canon::Xml::Nodes::RootNode.new
-            temp_root1.instance_variable_set(:@children, children1.dup)
+            temp_root1.children = children1.dup
 
             temp_root2 = Canon::Xml::Nodes::RootNode.new
-            temp_root2.instance_variable_set(:@children, children2.dup)
+            temp_root2.children = children2.dup
 
             matcher = Canon::Xml::ElementMatcher.new
             matches = matcher.match_trees(temp_root1, temp_root2)
@@ -282,7 +282,7 @@ module Canon
             end
 
             smaller_set_names = smaller_set.filter_map do |c|
-              next nil unless c.is_a?(Canon::Xml::Node) || c.is_a?(Nokogiri::XML::Node)
+              next nil unless c.is_a?(Canon::Xml::Node) || Canon::XmlParsing.xml_node?(c)
               # Exclude generic node-type names (e.g. "#text") that are
               # shared by all text nodes and cannot be used for matching.
               next nil if c.name.start_with?("#")
@@ -298,7 +298,7 @@ module Canon
                 # consider it a mismatch
                 mismatch_children << larger_set[i]
               elsif (larger_set[i].is_a?(Canon::Xml::Node) ||
-                     larger_set[i].is_a?(Nokogiri::XML::Node)) &&
+                     Canon::XmlParsing.xml_node?(larger_set[i])) &&
                   !larger_set[i].name.start_with?("#") &&
                   !smaller_set_names.include?(larger_set[i].name)
                 # If the name of the node is not found in the smaller set,

data/lib/canon/comparison/xml_comparator/diff_node_builder.rb

@@ -53,7 +53,7 @@ module Canon
         # For deleted/inserted nodes, include namespace information if available
         if dimension == :text_content && (node1.nil? || node2.nil?)
           node = node1 || node2
-          if node.is_a?(Canon::Xml::Node) || node.is_a?(Nokogiri::XML::Node)
+          if node.is_a?(Canon::Xml::Node) || Canon::XmlParsing.xml_node?(node)
             ns = node.namespace_uri
             ns_info = if ns.nil? || ns.empty?
                         ""
@@ -100,8 +100,8 @@ module Canon
         elsif dimension == :element_structure &&
             diff1 == Canon::Comparison::UNEQUAL_ELEMENTS &&
             diff2 == Canon::Comparison::UNEQUAL_ELEMENTS &&
-            (node1.is_a?(Canon::Xml::Node) || node1.is_a?(Nokogiri::XML::Node)) &&
-            (node2.is_a?(Canon::Xml::Node) || node2.is_a?(Nokogiri::XML::Node)) &&
+            (node1.is_a?(Canon::Xml::Node) || Canon::XmlParsing.xml_node?(node1)) &&
+            (node2.is_a?(Canon::Xml::Node) || Canon::XmlParsing.xml_node?(node2)) &&
             node1.name && node2.name && node1.name != node2.name
           "different element name (<#{node1.name}> vs <#{node2.name}>)"
         else
@@ -198,12 +198,14 @@ module Canon
           node.value
         when Canon::Xml::Node
           node.text_content
-        when Nokogiri::XML::Node
-          node.content.to_s
-        when String
-          node
         else
-          node.to_s
+          if Canon::XmlBackend.nokogiri? && node.is_a?(Nokogiri::XML::Node)
+            node.content.to_s
+          elsif Canon::XmlParsing.xml_node?(node)
+            Canon::XmlParsing.text_content(node)
+          else
+            node.to_s
+          end
         end
       rescue StandardError
         nil

data/lib/canon/comparison/xml_comparator/namespace_comparator.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "../../xml/namespace_helper"
+
 module Canon
   module Comparison
     module XmlComparatorHelpers
@@ -41,20 +43,20 @@ module Canon
         def self.extract_declarations(node)
           declarations = {}
 
-          # Handle Canon::Xml::Node (uses namespace_nodes)
-          if node.respond_to?(:namespace_nodes)
-            return extract_from_namespace_nodes(node.namespace_nodes,
-                                                declarations)
-          end
+          if node.is_a?(Canon::Xml::Node)
+            if node.namespace_nodes
+              return extract_from_namespace_nodes(node.namespace_nodes,
+                                                  declarations)
+            end
 
-          # Handle Nokogiri/Moxml nodes (use attributes)
-          raw_attrs = node.respond_to?(:attribute_nodes) ? node.attribute_nodes : node.attributes
+            raw_attrs = node.attribute_nodes
+          else
+            raw_attrs = node.attributes
+          end
 
-          # Handle Canon::Xml::Node attribute format (array of AttributeNode)
           if raw_attrs.is_a?(Array)
             extract_from_array_attributes(raw_attrs, declarations)
           else
-            # Handle Nokogiri and Moxml attribute formats (Hash-like)
             extract_from_hash_attributes(raw_attrs, declarations)
           end
 
@@ -105,23 +107,11 @@ module Canon
         # @return [Hash] Declarations hash
         def self.extract_from_hash_attributes(raw_attrs, declarations)
           raw_attrs.each do |key, val|
-            # Normalize key and value
-            name = if key.is_a?(String)
-                     # Nokogiri format: key=name (String), val=attr object
-                     key
-                   else
-                     # Moxml format: key=attr object, val=nil
-                     key.respond_to?(:name) ? key.name : key.to_s
-                   end
+            name = key.is_a?(String) ? key : key.name
 
             if namespace_declaration?(name)
-              value = if val.respond_to?(:value)
-                        val.value
-                      else
-                        val.to_s
-                      end
+              value = val.is_a?(String) ? val : val.value
 
-              # Extract prefix: "xmlns" -> "", "xmlns:xmi" -> "xmi"
               prefix = name == "xmlns" ? "" : name.split(":", 2)[1]
               declarations[prefix] = value
             end
@@ -130,12 +120,8 @@ module Canon
           declarations
         end
 
-        # Check if an attribute name is a namespace declaration
-        #
-        # @param attr_name [String] Attribute name
-        # @return [Boolean] true if it's a namespace declaration
         def self.namespace_declaration?(attr_name)
-          attr_name == "xmlns" || attr_name.start_with?("xmlns:")
+          Canon::Xml::NamespaceHelper.namespace_declaration?(attr_name)
         end
 
         # Add a namespace declaration difference