canon 0.2.3 → 0.2.5

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "../node_inspector"
+
 module Canon
   module Comparison
     module XmlComparatorHelpers
@@ -27,7 +29,10 @@ module Canon
           # @param differences [Array] Array to collect differences
           # @return [Integer] Comparison result code
           def compare(node1, node2, comparator, opts, child_opts,
-diff_children, differences)
+                      diff_children, differences)
+            # FAST PATH: Object identity - same object means equivalent children
+            return Comparison::EQUIVALENT if node1.equal?(node2)
+
             # Apply side-specific pretty-print heuristic when either flag is set:
             # pretty_printed_expected → drop \n-starting whitespace nodes from node1
             # pretty_printed_received → drop \n-starting whitespace nodes from node2
@@ -37,12 +42,15 @@ diff_children, differences)
             opts1 = XmlNodeComparison.opts_for_side(opts, :expected)
             opts2 = XmlNodeComparison.opts_for_side(opts, :received)
 
-            children1 = comparator.send(:filter_children, node1.children, opts1)
-            children2 = comparator.send(:filter_children, node2.children, opts2)
+            children1 = comparator.filter_children(node1.children, opts1)
+            children2 = comparator.filter_children(node2.children, opts2)
 
             # Quick check: if both have no children, they're equivalent
             return Comparison::EQUIVALENT if children1.empty? && children2.empty?
 
+            # FAST PATH: Identical children arrays mean equivalent subtrees
+            return Comparison::EQUIVALENT if children1.equal?(children2)
+
             # Check if we can use ElementMatcher (requires Canon::Xml::DataModel nodes)
             if can_use_element_matcher?(children1, children2)
               use_element_matcher_comparison(children1, children2, node1, comparator,
@@ -91,9 +99,9 @@ diff_children, differences)
 
             # If no matches and children exist, they're all different
             if matches.empty? && (!children1.empty? || !children2.empty?)
-              comparator.send(:add_difference, parent_node, parent_node,
-                              Comparison::MISSING_NODE, Comparison::MISSING_NODE,
-                              :text_content, opts, differences)
+              comparator.add_difference(parent_node, parent_node,
+                                        Comparison::MISSING_NODE, Comparison::MISSING_NODE,
+                                        :text_content, opts, differences)
               return Comparison::UNEQUAL_ELEMENTS
             end
 
@@ -116,30 +124,30 @@ diff_children, differences)
 
                   # Only create DiffNode if element_position is not :ignore
                   if position_behavior != :ignore
-                    comparator.send(:add_difference, match.elem1, match.elem2,
-                                    "position #{match.pos1}", "position #{match.pos2}",
-                                    :element_position, opts, differences)
+                    comparator.add_difference(match.elem1, match.elem2,
+                                              "position #{match.pos1}", "position #{match.pos2}",
+                                              :element_position, opts, differences)
                     all_equivalent = false if position_behavior == :strict
                   end
                 end
 
                 # Compare the matched elements for content/attribute differences
-                result = comparator.send(:compare_nodes, match.elem1, match.elem2,
-                                         child_opts, child_opts, diff_children, differences)
+                result = comparator.compare_nodes(match.elem1, match.elem2,
+                                                  child_opts, child_opts, diff_children, differences)
                 all_equivalent = false unless result == Comparison::EQUIVALENT
 
               when :deleted
                 # Element present in first tree but not second
-                comparator.send(:add_difference, match.elem1, nil,
-                                Comparison::MISSING_NODE, Comparison::MISSING_NODE,
-                                :element_structure, opts, differences)
+                comparator.add_difference(match.elem1, nil,
+                                          Comparison::MISSING_NODE, Comparison::MISSING_NODE,
+                                          :element_structure, opts, differences)
                 all_equivalent = false
 
               when :inserted
                 # Element present in second tree but not first
-                comparator.send(:add_difference, nil, match.elem2,
-                                Comparison::MISSING_NODE, Comparison::MISSING_NODE,
-                                :element_structure, opts, differences)
+                comparator.add_difference(nil, match.elem2,
+                                          Comparison::MISSING_NODE, Comparison::MISSING_NODE,
+                                          :element_structure, opts, differences)
                 all_equivalent = false
               end
             end
@@ -147,9 +155,16 @@ diff_children, differences)
             all_equivalent ? Comparison::EQUIVALENT : Comparison::UNEQUAL_ELEMENTS
           end
 
-          # Use simple positional comparison for children
+          # Use simple positional comparison for children, with
+          # whitespace-asymmetry-aware re-alignment.  When positional
+          # +zip()+ would pair a whitespace-only text node on one side
+          # against a content node on the other, treat the whitespace
+          # node as a single-side gap: emit one +:whitespace_adjacency+
+          # diff anchored at the whitespace node and advance only the
+          # cursor carrying the whitespace, so the next iteration aligns
+          # content against content.  See lutaml/canon#137.
           def use_positional_comparison(
-            children1, children2, _parent_node, comparator,
+            children1, children2, parent_node, comparator,
             opts, child_opts, diff_children, differences
           )
             has_mismatch = false
@@ -157,53 +172,120 @@ diff_children, differences)
             # Length check
             unless children1.length == children2.length
               has_mismatch = true
-              dimension = determine_dimension_for_mismatch(
-                children1, children2, comparator
+
+              ws_asymmetric = asymmetric_whitespace_explains_length_diff?(
+                children1, children2
               )
 
-              mismatched_children, children1, children2 =
-                determine_mismatch_children(
+              if ws_asymmetric
+                dimension = nil
+                mismatched_children = []
+              else
+                dimension = determine_dimension_for_mismatch(
                   children1, children2, comparator
                 )
+                mismatched_children, children1, children2 =
+                  determine_mismatch_children(
+                    children1, children2, comparator
+                  )
+              end
 
               if mismatched_children.empty?
-                comparator.send(:add_difference, parent_node, parent_node,
-                                Comparison::MISSING_NODE, Comparison::MISSING_NODE,
-                                dimension, opts, differences)
+                unless ws_asymmetric
+                  comparator.add_difference(parent_node, parent_node,
+                                            Comparison::MISSING_NODE, Comparison::MISSING_NODE,
+                                            dimension, opts, differences)
+                end
               else
                 mismatched_children.each do |child|
-                  if children1.length > children2.length # rubocop:disable Metrics/BlockNesting
-                    comparator.send(:add_difference, child, nil,
-                                    Comparison::MISSING_NODE, Comparison::MISSING_NODE,
-                                    dimension, opts, differences)
+                  child_dim = comparator.determine_node_dimension(child)
+                  if children1.length > children2.length
+                    comparator.add_difference(child, nil,
+                                              Comparison::MISSING_NODE,
+                                              Comparison::MISSING_NODE,
+                                              child_dim, opts, differences)
                   else
-                    comparator.send(:add_difference, nil, child,
-                                    Comparison::MISSING_NODE, Comparison::MISSING_NODE,
-                                    dimension, opts, differences)
+                    comparator.add_difference(nil, child,
+                                              Comparison::MISSING_NODE,
+                                              Comparison::MISSING_NODE,
+                                              child_dim, opts, differences)
                   end
                 end
               end
-              # Continue comparing children to find deeper differences like attribute values
-              # Use zip to compare up to the shorter length
             end
 
-            # Compare children pairwise by position
             result = has_mismatch ? Comparison::UNEQUAL_ELEMENTS : Comparison::EQUIVALENT
-            children1.zip(children2).each do |child1, child2|
-              # Skip if one is nil (due to different lengths)
-              next if child1.nil? || child2.nil?
+            walk_result = walk_children_with_realignment(
+              children1, children2, comparator,
+              child_opts, diff_children, opts, differences
+            )
+            result = walk_result unless walk_result == Comparison::EQUIVALENT
+            result
+          end
 
-              child_result = comparator.send(:compare_nodes, child1, child2,
-                                             child_opts, child_opts, diff_children, differences)
+          # Two-cursor walk over paired children that re-aligns past
+          # asymmetric whitespace-only text nodes.  Returns the worst
+          # child result encountered.
+          def walk_children_with_realignment(
+            children1, children2, comparator,
+            child_opts, diff_children, opts, differences
+          )
+            result = Comparison::EQUIVALENT
+            i = 0
+            j = 0
+
+            while i < children1.length || j < children2.length
+              c1 = children1[i]
+              c2 = children2[j]
+
+              if c1.nil?
+                j += 1
+                next
+              elsif c2.nil?
+                i += 1
+                next
+              end
 
-              unless child_result == Comparison::EQUIVALENT
-                result = child_result
+              ws1 = NodeInspector.whitespace_only_text?(c1)
+              ws2 = NodeInspector.whitespace_only_text?(c2)
+
+              if ws1 && !ws2
+                comparator.add_difference(c1, c2,
+                                          Comparison::UNEQUAL_TEXT_CONTENTS,
+                                          Comparison::UNEQUAL_TEXT_CONTENTS,
+                                          :whitespace_adjacency, opts, differences)
+                result = Comparison::UNEQUAL_TEXT_CONTENTS
+                i += 1
+                next
+              elsif ws2 && !ws1
+                comparator.add_difference(c1, c2,
+                                          Comparison::UNEQUAL_TEXT_CONTENTS,
+                                          Comparison::UNEQUAL_TEXT_CONTENTS,
+                                          :whitespace_adjacency, opts, differences)
+                result = Comparison::UNEQUAL_TEXT_CONTENTS
+                j += 1
+                next
               end
+
+              child_result = comparator.compare_nodes(c1, c2,
+                                                      child_opts, child_opts,
+                                                      diff_children, differences)
+              result = child_result unless child_result == Comparison::EQUIVALENT
+              i += 1
+              j += 1
             end
 
             result
           end
 
+          # True when the length difference between the two child arrays
+          # is fully explained by asymmetric whitespace-only text nodes.
+          def asymmetric_whitespace_explains_length_diff?(children1, children2)
+            non_ws1 = children1.reject { |c| NodeInspector.whitespace_only_text?(c) }
+            non_ws2 = children2.reject { |c| NodeInspector.whitespace_only_text?(c) }
+            non_ws1.length == non_ws2.length
+          end
+
           # Determine dimension for length mismatch
           def determine_dimension_for_mismatch(children1, children2, comparator)
             dimension = :text_content # default
@@ -213,22 +295,17 @@ diff_children, differences)
             (0...max_len).each do |i|
               if i >= children1.length
                 # Extra child in children2
-                dimension = comparator.send(:determine_node_dimension,
-                                            children2[i])
+                dimension = comparator.determine_node_dimension(children2[i])
                 break
               elsif i >= children2.length
                 # Extra child in children1
-                dimension = comparator.send(:determine_node_dimension,
-                                            children1[i])
+                dimension = comparator.determine_node_dimension(children1[i])
                 break
-              elsif !comparator.send(:same_node_type?, children1[i],
-                                     children2[i])
+              elsif !comparator.same_node_type?(children1[i], children2[i])
                 # Different node types at same position
                 # Check both nodes - if either is a comment, use :comments dimension
-                dim1 = comparator.send(:determine_node_dimension,
-                                       children1[i])
-                dim2 = comparator.send(:determine_node_dimension,
-                                       children2[i])
+                dim1 = comparator.determine_node_dimension(children1[i])
+                dim2 = comparator.determine_node_dimension(children2[i])
                 dimension = [dim1, dim2].include?(:comments) ? :comments : dim1
                 break
               end
@@ -250,7 +327,7 @@ diff_children, differences)
             end
 
             smaller_set_names = smaller_set.filter_map do |c|
-              next nil unless c.respond_to?(:name)
+              next nil unless c.is_a?(Canon::Xml::Node) || c.is_a?(Nokogiri::XML::Node)
               # 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?("#")
@@ -265,7 +342,8 @@ diff_children, differences)
                 # If the smaller set has no child at this position,
                 # consider it a mismatch
                 mismatch_children << larger_set[i]
-              elsif larger_set[i].respond_to?(:name) &&
+              elsif (larger_set[i].is_a?(Canon::Xml::Node) ||
+                     larger_set[i].is_a?(Nokogiri::XML::Node)) &&
                   !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

@@ -4,6 +4,7 @@ require "set"
 require_relative "../../diff/diff_node"
 require_relative "../../diff/path_builder"
 require_relative "../../diff/node_serializer"
+require_relative "../node_inspector"
 
 module Canon
   module Comparison
@@ -52,14 +53,15 @@ module Canon
         # For deleted/inserted nodes, include namespace information if available
         if dimension == :text_content && (node1.nil? || node2.nil?)
           node = node1 || node2
-          if node.respond_to?(:name) && node.respond_to?(:namespace_uri)
+          if node.is_a?(Canon::Xml::Node) || node.is_a?(Nokogiri::XML::Node)
             ns = node.namespace_uri
             ns_info = if ns.nil? || ns.empty?
                         ""
                       else
                         " (namespace: #{ns})"
                       end
-            return "element '#{node.name}'#{ns_info}: #{diff1} vs #{diff2}"
+            label = Canon::Comparison.code_pair_label(diff1, diff2)
+            return "element '#{node.name}'#{ns_info}: #{label}"
           end
         end
 
@@ -87,8 +89,15 @@ module Canon
         # Default reason
         if diff1 == Canon::Comparison::MISSING_NODE && diff2 == Canon::Comparison::MISSING_NODE
           "element structure mismatch (children differ)"
+        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.name && node2.name && node1.name != node2.name
+          "different element name (<#{node1.name}> vs <#{node2.name}>)"
         else
-          "#{diff1} vs #{diff2}"
+          Canon::Comparison.code_pair_label(diff1, diff2)
         end
       end
 
@@ -176,26 +185,18 @@ module Canon
       def self.extract_text_content(node)
         return nil if node.nil?
 
-        # For Canon::Xml::Nodes::TextNode
-        return node.value if node.respond_to?(:value) && node.is_a?(Canon::Xml::Nodes::TextNode)
-
-        # For XML/HTML nodes with text_content method
-        return node.text_content if node.respond_to?(:text_content)
-
-        # For nodes with text method
-        return node.text if node.respond_to?(:text)
-
-        # For nodes with content method (Moxml::Text)
-        return node.content if node.respond_to?(:content)
-
-        # For nodes with value method (other types)
-        return node.value if node.respond_to?(:value)
-
-        # For simple text nodes or strings
-        return node.to_s if node.is_a?(String)
-
-        # For other node types, try to_s
-        node.to_s
+        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 String
+          node
+        else
+          node.to_s
+        end
       rescue StandardError
         nil
       end

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

@@ -14,15 +14,18 @@ module Canon
         # @param node [String, Object] Node to parse
         # @param preprocessing [Symbol] Preprocessing mode (:none, :normalize, :c14n, :format)
         # @param preserve_whitespace [Boolean] Whether to preserve whitespace-only text nodes
+        # @param parser [Symbol] Parser backend (:sax or :dom, default from config)
         # @return [Canon::Xml::Node] Parsed node
-        def self.parse(node, preprocessing = :none, preserve_whitespace: false)
+        def self.parse(node, preprocessing = :none, preserve_whitespace: false,
+                       parser: nil)
           # If already a Canon::Xml::Node, return as-is
           return node if node.is_a?(Canon::Xml::Node)
 
           # If it's a Nokogiri or Moxml node, convert to DataModel
           unless node.is_a?(String)
             return convert_from_node(node,
-                                     preserve_whitespace: preserve_whitespace)
+                                     preserve_whitespace: preserve_whitespace,
+                                     parser: parser)
           end
 
           # Normalize encoding before preprocessing (UTF-16 strings can't use strip, etc.)
@@ -31,9 +34,17 @@ module Canon
           # Apply preprocessing to XML string before parsing
           xml_string = apply_preprocessing(node, preprocessing).strip
 
-          # Use Canon::Xml::DataModel for parsing to get Canon::Xml::Node instances
-          Canon::Xml::DataModel.from_xml(xml_string,
+          # Select parser backend
+          resolved_parser = parser || resolve_parser_config
+
+          if resolved_parser == :sax
+            require_relative "../../xml/sax_builder"
+            Canon::Xml::SaxBuilder.parse(xml_string,
                                          preserve_whitespace: preserve_whitespace)
+          else
+            Canon::Xml::DataModel.from_xml(xml_string,
+                                           preserve_whitespace: preserve_whitespace)
+          end
         end
 
         # Apply preprocessing transformation to XML string
@@ -62,9 +73,18 @@ module Canon
         #
         # @param node [Object] Nokogiri or Moxml node
         # @param preserve_whitespace [Boolean] Whether to preserve whitespace-only text nodes
+        # @param parser [Symbol, nil] Parser backend override
         # @return [Canon::Xml::Node] Converted node
-        def self.convert_from_node(node, preserve_whitespace: false)
-          # Convert to XML string then parse through DataModel
+        def self.convert_from_node(node, preserve_whitespace: false,
+parser: nil)
+          # FAST PATH: Convert Nokogiri/Moxml nodes directly without string round-trip
+          if defined?(Nokogiri::XML::Node) && node.is_a?(Nokogiri::XML::Node)
+            return Canon::Xml::DataModel.build_from_nokogiri(
+              node, preserve_whitespace: preserve_whitespace
+            )
+          end
+
+          # SLOW PATH: Fallback to string serialization for unknown node types
           xml_str = if node.respond_to?(:to_xml)
                       node.to_xml
                     elsif node.respond_to?(:to_s)
@@ -73,8 +93,26 @@ module Canon
                       raise Canon::Error,
                             "Unable to convert node to string: #{node.class}"
                     end
-          Canon::Xml::DataModel.from_xml(xml_str,
+
+          resolved_parser = parser || resolve_parser_config
+
+          if resolved_parser == :sax
+            require_relative "../../xml/sax_builder"
+            Canon::Xml::SaxBuilder.parse(xml_str,
                                          preserve_whitespace: preserve_whitespace)
+          else
+            Canon::Xml::DataModel.from_xml(xml_str,
+                                           preserve_whitespace: preserve_whitespace)
+          end
+        end
+
+        # Resolve parser config from global config
+        #
+        # @return [Symbol] :sax or :dom
+        def self.resolve_parser_config
+          Canon::Config.instance.xml.diff.parser
+        rescue StandardError
+          :sax
         end
       end
     end