canon 0.3.32 → 0.3.33

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 44f563b9b8ac9fa82cc08c9413ca4a17afd8080c524d6eb92536572356892539
-  data.tar.gz: 4a7cbe635232ca07fa8b9924e46c027849145fbc6ac6846df3ec9de4c51edbc4
+  metadata.gz: 6094f49ebe4d3b32a5396a0db4d62dbc502156d277ed12115029d50eb36f37ff
+  data.tar.gz: 8cf4e6d0b0e1feaaddaed2b996d98f9fd36adb4b250c3460ac2ae20a5263689a
 SHA512:
-  metadata.gz: a228ef2b06e3e59545aab338afd72cdcf4943c32b34fa24063e43884f01b41444558966cb121986513d28041a92f0918864106886875ef44da9b3f00e53dcdc2
-  data.tar.gz: 9dbddd3a07e0d6076118ed7e2619de864b9bf3c99ff68c109fa31805a912a1839054d4cf843f712faa2df2a2ee619806d256a47bdce9399feb422721d6117e71
+  metadata.gz: 9b53fdc9296da8e354cbb99cc194f6dab11544a52c1cda09370a01f413ce57dc5b04d47d99d496d9a3dcb9558f934dd75a5124be10406de74106e6750b86f51a
+  data.tar.gz: b8cf46fd5d9380584db39732281d18e7186c33927518ac46e5a42fec09d7d3cc5aad167ca1a85c879f087a54a934e8a329b879c43b4cc3aade63512503d0fe80

data/lib/canon/version.rb

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

data/lib/canon/xml/element_matcher.rb

@@ -164,6 +164,21 @@ module Canon
         elems1 = children1.select { |n| n.node_type == :element }
         elems2 = children2.select { |n| n.node_type == :element }
 
+        # FAST PATH: pairwise-corresponding children. When both lists
+        # are the same length and every position pairs elements with
+        # equal name, namespace URI, and identity value, the full
+        # matcher's output is exactly the positional pairing: unique
+        # identity keys pair same-with-same, duplicate keys pair
+        # last-with-last in the identity phase and the rest pair in
+        # order in the positional phase. No deleted/inserted results
+        # either way. Skip the identity/positional/class machinery.
+        if !elems1.empty? && elems1.length == elems2.length &&
+            pairwise_corresponding?(elems1, elems2)
+          record_positional_matches(elems1, elems2, path,
+                                    recursive: recursive)
+          return
+        end
+
         # Positions by identity: elems.index(elem) was an O(n) scan per
         # recorded match — O(n²) per level on element-heavy parents.
         positions1 = {}
@@ -263,6 +278,48 @@ module Canon
         end
       end
 
+      # True when every position pairs elements with equal name,
+      # namespace URI, and identity value (nil-safe).
+      def pairwise_corresponding?(elems1, elems2)
+        elems1.each_index.all? do |i|
+          e1 = elems1[i]
+          e2 = elems2[i]
+          e1.name == e2.name && e1.namespace_uri == e2.namespace_uri &&
+            extract_identity(e1) == extract_identity(e2)
+        end
+      end
+
+      # Record the positional pairing as :matched MatchResults,
+      # descending per pair in recursive mode (match_trees' ordering
+      # contract).
+      def record_positional_matches(elems1, elems2, path, recursive:)
+        elems1.each_index do |i|
+          elem1 = elems1[i]
+          elem_path = element_path(path, elem1)
+          @matches << MatchResult.new(
+            status: :matched,
+            elem1: elem1,
+            elem2: elems2[i],
+            path: elem_path,
+            pos1: i,
+            pos2: i,
+          )
+          if recursive
+            match_children(elem1.children, elems2[i].children, elem_path)
+          end
+        end
+      end
+
+      # Path segment for an element: expanded under a namespace,
+      # bare otherwise.
+      def element_path(path, elem)
+        if elem.namespace_uri && !elem.namespace_uri.empty?
+          path + ["{#{elem.namespace_uri}}#{elem.name}"]
+        else
+          path + [elem.name]
+        end
+      end
+
       # Match remaining elements by name and position
       def match_by_position(elems1, elems2, path, matched1, matched2,
                             recursive:)

data/lib/tasks/benchmark_runner.rb

@@ -225,6 +225,13 @@ compare_against: nil)
       failure_means: "Slow formatting affects serialization performance. C14N is critical for digital signatures and XML canonicalization.",
       compare_against: "Previous branch (main).",
     },
+    data_comparison: {
+      name: "Data Comparison",
+      icon: "🧮",
+      description: "JSON and YAML semantic comparison. Both formats load through their engine gateways (yeptris/stdlib), so this referees engine choice.",
+      failure_means: "Slow data comparison affects validation pipelines and test suites. A regression here can also signal an engine lane flip gone wrong.",
+      compare_against: "Previous branch (main). Inputs are freshly generated (different values), so the comparison does real work.",
+    },
   }.freeze
 
   # Test definitions
@@ -265,6 +272,12 @@ compare_against: nil)
       { name: "JSON", method: :json_format, desc: "JSON formatting" },
       { name: "YAML", method: :yaml_format, desc: "YAML formatting" },
     ],
+    data_comparison: [
+      { name: "JSON", method: :json_compare_equivalent,
+        desc: "JSON equivalence" },
+      { name: "YAML", method: :yaml_compare_equivalent,
+        desc: "YAML equivalence" },
+    ],
   }.freeze
 
   # Test data generators
@@ -555,6 +568,14 @@ compare_against: nil)
       yaml = DataGenerator.generate_yaml(items: @items)
       data = YAML.safe_load(yaml, permitted_classes: [Time])
       measure { Canon.format_yaml(data) }
+    when :json_compare_equivalent
+      json1 = DataGenerator.generate_json(items: @items)
+      json2 = DataGenerator.generate_json(items: @items)
+      measure { Canon::Comparison.equivalent?(json1, json2, format: :json) }
+    when :yaml_compare_equivalent
+      yaml1 = DataGenerator.generate_yaml(items: @items)
+      yaml2 = DataGenerator.generate_yaml(items: @items)
+      measure { Canon::Comparison.equivalent?(yaml1, yaml2, format: :yaml) }
     else
       raise "Unknown benchmark: #{method}"
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: canon
 version: !ruby/object:Gem::Version
-  version: 0.3.32
+  version: 0.3.33
 platform: ruby
 authors:
 - Ribose Inc.