canon 0.3.36 → 0.3.38

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 53129bc040b25503b792d4c1afa96498715cd05363d462afb87aa004dbe37004
-  data.tar.gz: de9d2c032c3b20e73f6737bcd0d092130dd9622851cca6c9353d6c10ea7da0f8
+  metadata.gz: dc55555287eb70fb4fc5201029aea89c2af55d8a9df26549d1d17b639a6de5de
+  data.tar.gz: 59ac3ba881495f29ee1355eda305da05d03d62a5611aa738404bf029f66d1721
 SHA512:
-  metadata.gz: 2471eebf546ec921fa8d307a02363b9d1112ef5111fd0f0edd57d1894a3e04e7039965fede0a4b4f8e02fa05540dad05324e6dc1e052676512407a7965c0ea83
-  data.tar.gz: a58130908f35634360d689eba9e27d48845f955c9cd44eae6eab771e0bfb0b84af35cd97db05137eb1563baa3449a1591237fc3eac01a74ef839df5c3811e386
+  metadata.gz: 6b2d535b82b40ece128bea902b603b1b43c06c7bf4f40535f651e3b43c24674345de4e0c0767380fd6fc50d2986dc80ecf0e2c1b2d5286a7dd02524d65641920
+  data.tar.gz: '09af782d9c914502a54ca9b961448c89502bb20c3cffa93ec9268b7afc72099bcea2dcc2f7f8e36ccbf7fd6a6f8e3320ced5b7edfd67f7d70d0f5f95e7cf8d85'

data/lib/canon/comparison/ruby_object_comparator.rb

@@ -29,9 +29,7 @@ module Canon
         # difference exists (strict key_order compares insertion
         # order, which keys == keys preserves). Most object pairs in
         # similar documents hit this and skip the path-building walk.
-        if obj1 == obj2 && (!obj1.is_a?(Hash) || obj1.keys == obj2.keys)
-          return Comparison::EQUIVALENT
-        end
+        return Comparison::EQUIVALENT if deep_equal?(obj1, obj2)
 
         case obj1
         when Hash
@@ -68,8 +66,16 @@ module Canon
         # Sort keys if order should be ignored (based on match options)
         match_opts = opts[:match_opts]
         if match_opts && match_opts[:key_order] != :strict
-          keys1 = keys1.sort_by(&:to_s)
-          keys2 = keys2.sort_by(&:to_s)
+          # Identical key arrays: one sort replaces two (the sorted
+          # forms are trivially equal, and the set algebra below
+          # degenerates — missing/extra empty, common = the sorted
+          # keys themselves).
+          if keys1 == keys2
+            keys1 = keys2 = keys1.sort_by(&:to_s)
+          else
+            keys1 = keys1.sort_by(&:to_s)
+            keys2 = keys2.sort_by(&:to_s)
+          end
         elsif match_opts && match_opts[:key_order] == :strict
           # Strict mode: key order matters
           # Check if keys are in same order
@@ -85,8 +91,8 @@ module Canon
         end
 
         # Check for missing keys
-        missing_in_second = keys1 - keys2
-        missing_in_first = keys2 - keys1
+        missing_in_second = keys1 == keys2 ? EMPTY_KEYS : keys1 - keys2
+        missing_in_first = keys1 == keys2 ? EMPTY_KEYS : keys2 - keys1
 
         missing_in_second.each do |key|
           key_path = path.empty? ? key.to_s : "#{path}.#{key}"
@@ -102,13 +108,19 @@ module Canon
 
         has_missing_keys = !missing_in_first.empty? || !missing_in_second.empty?
 
-        # Compare common keys
-        common_keys = keys1 & keys2
+        # Compare common keys. The path string is built lazily: deep-equal
+        # pairs (the overwhelming majority in similar documents) answer
+        # equivalent without ever needing it.
+        common_keys = keys1 == keys2 ? keys1 : keys1 & keys2
         all_equivalent = true
         common_keys.each do |key|
+          value1 = hash1[key]
+          value2 = hash2[key]
+          next if deep_equal?(value1, value2)
+
           key_path = path.empty? ? key.to_s : "#{path}.#{key}"
-          result = compare_objects(hash1[key], hash2[key], opts,
-                                   differences, key_path)
+          result = compare_objects(value1, value2, opts, differences,
+                                   key_path)
           all_equivalent = false unless result == Comparison::EQUIVALENT
         end
 
@@ -138,6 +150,8 @@ module Canon
         all_equivalent = true
         arr1.each_with_index do |elem1, index|
           elem2 = arr2[index]
+          next if deep_equal?(elem1, elem2)
+
           elem_path = "#{path}[#{index}]"
           result = compare_objects(elem1, elem2, opts, differences,
                                    elem_path)
@@ -166,6 +180,16 @@ module Canon
         end
       end
 
+      # Deep-equal with identical key order — compare_objects returns
+      # EQUIVALENT without consulting the path for such pairs, which
+      # is what makes lazy path construction in the hash/array walks
+      # behavior-identical.
+      def self.deep_equal?(obj1, obj2)
+        obj1 == obj2 && (!obj1.is_a?(Hash) || obj1.keys == obj2.keys)
+      end
+
+      EMPTY_KEYS = [].freeze
+
       # Add a Ruby object difference
       #
       # @param path [String] Path to the difference

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

@@ -75,6 +75,17 @@ module Canon
           # Use ElementMatcher for semantic comparison
           def use_element_matcher_comparison(children1, children2, parent_node, comparator,
                                              opts, child_opts, diff_children, differences)
+            # FAST PATH: positionally paired children — compare pairwise
+            # with zero MatchResult allocation. Same pairing the matcher
+            # would emit; pos1==pos2 so position_changed? never fires.
+            if Canon::Xml::ElementMatcher.positionally_paired?(children1,
+                                                               children2)
+              return compare_positionally_paired(
+                children1, children2, comparator, opts, child_opts,
+                diff_children, differences
+              )
+            end
+
             # Single-level matching: the comparator itself descends via
             # compare_nodes below, so nested matches would be discarded.
             matches = Canon::Xml::ElementMatcher.new
@@ -92,6 +103,24 @@ module Canon
                             opts, child_opts, diff_children, differences)
           end
 
+          # Pairwise compare when ElementMatcher.positionally_paired?
+          # has already proved the pairing. No MatchResult objects.
+          def compare_positionally_paired(children1, children2, comparator,
+                                          _opts, child_opts, diff_children,
+                                          differences)
+            all_equivalent = true
+            i = 0
+            while i < children1.length
+              result = comparator.compare_nodes(
+                children1[i], children2[i],
+                child_opts, child_opts, diff_children, differences
+              )
+              all_equivalent = false unless result == Comparison::EQUIVALENT
+              i += 1
+            end
+            all_equivalent ? Comparison::EQUIVALENT : Comparison::UNEQUAL_ELEMENTS
+          end
+
           # Process ElementMatcher results
           def process_matches(matches, _children1, _children2, _parent_node, comparator,
                              opts, child_opts, diff_children, differences)

data/lib/canon/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Canon
-  VERSION = "0.3.36"
+  VERSION = "0.3.38"
 end

data/lib/canon/xml/digest_gate.rb

@@ -26,12 +26,12 @@ module Canon
         return false unless Canon::XmlBackend.moxml? &&
           Canon::XmlParsing.moxml_adapter_name == :leptris
 
-        # Node#digest is the 1.9.144 surface; feature-detect it on a
-        # throwaway document rather than probing the class.
+        # moxml Node#digest (moxml#173) wraps leptris Node#digest;
+        # feature-detect on a throwaway document.
         doc = Canon::XmlParsing.moxml_context.parse("<r/>", readonly: true,
                                                             strict: false)
         root = doc.root
-        digestable = !root.native.digest(drop_ws: true).nil?
+        digestable = !root.digest(drop_ws_text: true).nil?
         doc.free
         digestable
       rescue StandardError
@@ -85,7 +85,13 @@ module Canon
           when Moxml::Text then child.content.strip.empty? ? nil : child.to_s
           end
         end
-        [root.native.digest(drop_ws: true), skeleton]
+        digest = root.digest(drop_ws_text: true)
+        # nil digest means the adapter has no Merkle support — never
+        # treat two nils as equal (that would false-positive under
+        # Opal / non-leptris backends where every tree digests nil).
+        return nil if digest.nil?
+
+        [digest, skeleton]
       ensure
         doc&.free
       end

data/lib/canon/xml/element_matcher.rb

@@ -54,6 +54,7 @@ module Canon
     class ElementMatcher
       # Default attributes used to identify elements
       DEFAULT_IDENTITY_ATTRS = %w[id ref name key class].freeze
+      EMPTY_PATH = [].freeze
 
       # Represents the result of matching an element across two DOM trees
       #
@@ -145,6 +146,21 @@ module Canon
         @matches
       end
 
+      # Public: true when both lists pair positionally (equal length,
+      # equal name/ns/identity at every index). ChildComparison uses
+      # this to skip MatchResult allocation on the common same-structure
+      # path.
+      def self.positionally_paired?(elems1, elems2)
+        return false if elems1.length != elems2.length || elems1.empty?
+
+        new.paired_positionally?(elems1, elems2)
+      end
+
+      # Instance form of .positionally_paired?
+      def paired_positionally?(elems1, elems2)
+        pairwise_corresponding?(elems1, elems2)
+      end
+
       private
 
       # Match children recursively
@@ -295,7 +311,11 @@ module Canon
       def record_positional_matches(elems1, elems2, path, recursive:)
         elems1.each_index do |i|
           elem1 = elems1[i]
-          elem_path = element_path(path, elem1)
+          # match_children_only never reads path; keep a shared empty
+          # for the non-recursive entry so we do not allocate one
+          # [name] array per element. Recursive match_trees still
+          # builds real paths for its public API.
+          elem_path = recursive || !path.empty? ? element_path(path, elem1) : EMPTY_PATH
           @matches << MatchResult.new(
             status: :matched,
             elem1: elem1,

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: canon
 version: !ruby/object:Gem::Version
-  version: 0.3.36
+  version: 0.3.38
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-09-13 00:00:00.000000000 Z
+date: 2026-09-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: diff-lcs