canon 0.3.37 → 0.3.39

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fc8ab08578b3b1ceed40cb8f14ee8e83fdb116d26214a4a546789108950802dc
-  data.tar.gz: 435c4f9300160c8b502b8441096b2eea9aec0e182f025e84789f8f0fd492451d
+  metadata.gz: 6b65514ddc21b35416e7856a21f17f084cde6f6176a0f84dd8ee03a3ec7c8604
+  data.tar.gz: e6390a45d84dc78708aa3f043f053c41bba8b68c30170b11a58282581365c09d
 SHA512:
-  metadata.gz: a9c49d99613a801415eec95e663caa577319e9c4ce63546c1708c0599c891289e225c415279131c2652f83e9cec17b225c15f0bbc620da1a1237cc321eb2d381
-  data.tar.gz: fa8e1ea33c6527b7a215c0b8e097f4266d3db0cc00e865bc39c883b8b3de8a8683533beb66bccf1538d89059aeb348a716c5c1d9fb2b4eefd14d257b23cc993c
+  metadata.gz: 338db190efc246cb7a23f06b4a6f3dc620e969e3029cc2384f52bf8b082f6903dd21883b29316bcff676bb36f446e1fcad8cab434d8590f40b57a32a6d56baca
+  data.tar.gz: 602303bc515970ac9085e1a5184d8684604b80c5047d65cc3bf6bb6aa2854fdce1bd9eb3a61b4ee8e0f0c74f3f347d63d62133c9e8df93b51d146eca67807da9

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/version.rb

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

data/lib/canon/xml/digest_gate.rb

@@ -78,7 +78,7 @@ module Canon
         return nil unless root
 
         skeleton = doc.children.filter_map do |child|
-          next if child.equal?(root)
+          next if Canon::XmlParsing.same_engine_node?(child, root)
 
           case child
           when Moxml::Comment, Moxml::ProcessingInstruction then child.to_s

data/lib/canon/xml/tree_builder.rb

@@ -149,7 +149,7 @@ module Canon
       def add_document_children(root, children, document_element,
                                 skip_types = [])
         children.each do |child|
-          next if child.equal?(document_element)
+          next if Canon::XmlParsing.same_engine_node?(child, document_element)
           next if skip_types.any? { |type| child.is_a?(type) }
 
           node = yield child

data/lib/canon/xml_parsing.rb

@@ -63,6 +63,33 @@ module Canon
         end
       end
 
+      # Same underlying engine node? Wrapper identity first (correct
+      # everywhere wrappers are unified). Fallback: moxml 0.5.36-0.5.39
+      # wrap Document#root and Document#children entries in DIFFERENT
+      # wrapper classes for one node (NativeNode vs the FFI Element —
+      # moxml#216), so identity fails exactly where consumers exclude
+      # the document element from children; the shared C pointer
+      # address is the stable identity. Inert once wrappers unify.
+      def same_engine_node?(left, right)
+        return true if left.equal?(right)
+        return false unless defined?(::Moxml::Node) &&
+          left.is_a?(::Moxml::Node) && right.is_a?(::Moxml::Node)
+
+        address_left = moxml_node_address(left)
+        address_right = moxml_node_address(right)
+        !address_left.nil? && address_left == address_right
+      end
+
+      def moxml_node_address(wrapper)
+        native = wrapper.native
+        case native
+        when ::Leptris::XML::NativeNode then native.address
+        when ::Leptris::XML::Node then native.c_ptr.address
+        end
+      rescue StandardError
+        nil
+      end
+
       # --- Type checks (any recognized engine node) ---
 
       def document?(obj)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: canon
 version: !ruby/object:Gem::Version
-  version: 0.3.37
+  version: 0.3.39
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-09-14 00:00:00.000000000 Z
+date: 2026-09-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: diff-lcs
@@ -44,14 +44,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.5.0
+        version: 0.5.41
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.5.0
+        version: 0.5.41
 - !ruby/object:Gem::Dependency
   name: nokogiri
   requirement: !ruby/object:Gem::Requirement