canon 0.3.35 → 0.3.37

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 746a0b0b72cc9111986fb3aab9b8c5de994d71b30a011983665b5a24130b092c
-  data.tar.gz: e9e5a262b99c0e44c2f11385e911faaf5216b52f32bc027d1a0ae82f0bae985e
+  metadata.gz: fc8ab08578b3b1ceed40cb8f14ee8e83fdb116d26214a4a546789108950802dc
+  data.tar.gz: 435c4f9300160c8b502b8441096b2eea9aec0e182f025e84789f8f0fd492451d
 SHA512:
-  metadata.gz: 9edbbe4c9eb6adb6218b2d282f1ac030fa4642ece72cedae34b54ea6cbac987acfd46bebbf1277da017b4bfcf511be98f41c64951fee9d7034d1410f8414a38b
-  data.tar.gz: 23d088e8fb394d5f36553b64f9e05955f788ca85615147878d6116552ed2ac3b297ebdc739604de009c754a5a8600a57cad97668c6c325a018635d6c6010df04
+  metadata.gz: a9c49d99613a801415eec95e663caa577319e9c4ce63546c1708c0599c891289e225c415279131c2652f83e9cec17b225c15f0bbc620da1a1237cc321eb2d381
+  data.tar.gz: fa8e1ea33c6527b7a215c0b8e097f4266d3db0cc00e865bc39c883b8b3de8a8683533beb66bccf1538d89059aeb348a716c5c1d9fb2b4eefd14d257b23cc993c

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/diff/diff_node_enricher.rb

@@ -613,13 +613,17 @@ module Canon
         # occurrence. Shorter strings match too many places in the document.
         min_locate_length = 3
 
-        # Element added (only in text2)
+        # Element added (only in text2). Index-aware first — see the
+        # removed branch note (identical-sibling anchor bug).
         if before.nil?
-          loc = if after.length < min_locate_length && path
-                  locate_via_parent_element(path, @text2, @line_map2)
-                else
-                  SourceLocator.locate(after, @text2, @line_map2)
+          loc = if path
+                  locate_element_at_index(after, @text2, @line_map2, path)
                 end
+          loc ||= if after.length < min_locate_length && path
+                    locate_via_parent_element(path, @text2, @line_map2)
+                  else
+                    SourceLocator.locate(after, @text2, @line_map2)
+                  end
 
           if loc
             end_line = find_end_line(loc[:line_number], @line_map2, after)
@@ -643,13 +647,20 @@ module Canon
           return
         end
 
-        # Element removed (only in text1)
+        # Element removed (only in text1). The path-aware locate runs
+        # FIRST: an identical sibling earlier in the document would win
+        # a plain first-occurrence search, anchoring the deletion to
+        # the wrong element and letting the line builder absorb it
+        # into a formatting gap (issue #85/#86).
         if after.nil?
-          loc = if before.length < min_locate_length && path
-                  locate_via_parent_element(path, @text1, @line_map1)
-                else
-                  SourceLocator.locate(before, @text1, @line_map1)
+          loc = if path
+                  locate_element_at_index(before, @text1, @line_map1, path)
                 end
+          loc ||= if before.length < min_locate_length && path
+                    locate_via_parent_element(path, @text1, @line_map1)
+                  else
+                    SourceLocator.locate(before, @text1, @line_map1)
+                  end
 
           if loc
             end_line = find_end_line(loc[:line_number], @line_map1, before)
@@ -982,6 +993,39 @@ module Canon
         SourceLocator.locate(value, text, line_map)
       end
 
+      # Index-aware location for element_structure changes: the path's
+      # last bracketed segment names the element itself (unlike
+      # text_content paths, whose last segment is the text node).
+      # Picks the occurrence whose element index matches the path, so
+      # identical siblings anchor at the right one; falls back to the
+      # first occurrence when no indexed match exists.
+      def locate_element_at_index(value, text, line_map, path)
+        return nil if value.nil? || value.length < 3
+
+        segments = path.split("/").reject(&:empty?)
+        element_segment = segments.reverse.find { |seg| seg.include?("[") }
+        return nil unless element_segment
+
+        element_match = element_segment.match(/([a-zA-Z0-9_:-]+)\[(\d+)\]/)
+        return nil unless element_match
+
+        element_name = element_match[1]
+        target_index = element_match[2].to_i
+
+        # Occurrence offsets point AT the element's own opening tag,
+        # so the prefix scan counts exactly the preceding siblings —
+        # no "inside the element" correction (count_elements_before_
+        # position subtracts one for text-node offsets).
+        opener = /<#{element_name}[>\s]/
+        occurrences = SourceLocator.locate_all(value, text, line_map)
+        occurrences.each do |occ|
+          count = text[0...occ[:char_offset]].scan(opener).length
+          return occ if count == target_index
+        end
+
+        SourceLocator.locate(value, text, line_map)
+      end
+
       # Fallback location strategy for text_content when locate_at_element_index
       # fails (e.g., the text value is too short to locate reliably).
       # Walks the full element hierarchy from the path to locate the correct

data/lib/canon/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Canon
-  VERSION = "0.3.35"
+  VERSION = "0.3.37"
 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.35
+  version: 0.3.37
 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