canon 0.3.32 → 0.3.34

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 44f563b9b8ac9fa82cc08c9413ca4a17afd8080c524d6eb92536572356892539
-  data.tar.gz: 4a7cbe635232ca07fa8b9924e46c027849145fbc6ac6846df3ec9de4c51edbc4
+  metadata.gz: af3e6b392ac406de109410e886a3bd12371cc9e5038d3c08833b6b3d71b6ac69
+  data.tar.gz: 464804eeac7d4390eb1e6dc44b0759bf45c4d2cd78d5e113ecc5459edb753821
 SHA512:
-  metadata.gz: a228ef2b06e3e59545aab338afd72cdcf4943c32b34fa24063e43884f01b41444558966cb121986513d28041a92f0918864106886875ef44da9b3f00e53dcdc2
-  data.tar.gz: 9dbddd3a07e0d6076118ed7e2619de864b9bf3c99ff68c109fa31805a912a1839054d4cf843f712faa2df2a2ee619806d256a47bdce9399feb422721d6117e71
+  metadata.gz: 7b1556a7e0bce22da9c862785d24e2ad5176d26fd6f82c97640fe30597d4eed18a2b298d771abcd4b81e9b4fee67eaff4f1b423ccfd798a903d77239ee2925e5
+  data.tar.gz: ae481888161bbf62db1b014cd3adaa28ef9bfa39aa7112cae2075a850242276d458445e511f84737ba62a20d1a2bb313132d5e962c331d017f66d69d61e238c3

data/lib/canon/comparison/html_comparator.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "set"
 require "nokogiri" unless RUBY_ENGINE == "opal"
 
 module Canon
@@ -596,6 +597,12 @@ compare_profile = nil)
                                   # Use default list from WhitespaceSensitivity (single source of truth)
                                   WhitespaceSensitivity.format_default_preserve_elements(match_opts).map(&:to_s)
                                 end
+          preserve_set = preserve_whitespace.to_set
+          # Element names arrive lowercased from the HTML parser but the
+          # ancestor walk would still allocate a downcase copy per visit;
+          # memoize per unique name instead (bounded by the tag vocabulary).
+          name_cache = {}
+          whitespace_result_cache = {}
 
           # Walk all text nodes
           doc.xpath(".//text()").each do |text_node|
@@ -603,11 +610,20 @@ compare_profile = nil)
             # Check all ancestors, not just immediate parent
             # Whitespace preservation happens REGARDLESS of text_content setting
             parent = text_node.parent
-            next if ancestor_preserves_whitespace?(parent, preserve_whitespace)
+            next if ancestor_preserves_whitespace?(parent, preserve_set,
+                                                   name_cache,
+                                                   whitespace_result_cache)
 
             # Collapse whitespace sequences (spaces, tabs, newlines) to single
             # space - use tr/squeeze to avoid ReDoS vulnerability from gsub(/\s+/)
-            normalized = text_node.content.tr("\t\n\r\f\v", " ").squeeze(" ")
+            # Content with no tab-class char and no space run is already
+            # collapsed — skip the copies entirely.
+            content = text_node.content
+            normalized = if content.match?(/[\t\n\r\f\v]/) || content.include?(" ")
+                           content.tr("\t\n\r\f\v", " ").squeeze(" ")
+                         else
+                           content
+                         end
 
             # Trim leading/trailing whitespace if appropriate
             normalized = normalized.strip if should_trim_text_node?(text_node)
@@ -616,31 +632,36 @@ compare_profile = nil)
           end
         end
 
-        # Check if any ancestor of the given node preserves whitespace
-        def ancestor_preserves_whitespace?(node, preserve_list)
-          current = node
-          while current.is_a?(Canon::Xml::Node) || Canon::XmlParsing.xml_node?(current)
-            return true if preserve_list.include?(current.name.downcase)
-
-            break if Canon::XmlParsing.document?(current)
-
-            current = current.parent
-          end
-          false
+        # Check if any ancestor of the given node preserves whitespace.
+        # +name_cache+ memoizes downcased names per unique element name
+        # (one downcase per tag vocabulary entry), and +result_cache+
+        # memoizes the verdict per element — engine node names allocate
+        # a fresh String per call, so sibling text nodes must not
+        # re-walk shared ancestors.
+        def ancestor_preserves_whitespace?(node, preserve_set, name_cache,
+                                          result_cache)
+          return false unless node.is_a?(Canon::Xml::Node) ||
+            Canon::XmlParsing.xml_node?(node)
+
+          cached = result_cache[node]
+          return cached unless cached.nil?
+
+          name = node.name
+          name = (name_cache[name] ||= name.downcase)
+          result_cache[node] = preserve_set.include?(name) ||
+            ancestor_preserves_whitespace?(
+              node.parent, preserve_set, name_cache,
+              result_cache
+            )
         end
 
         # Determine if a text node should have leading/trailing whitespace
         # trimmed Text nodes at the start or end of their parent element should
-        # be trimmed
+        # be trimmed. Only/first/last child ⟺ a missing sibling pointer —
+        # checked without allocating the parent's children NodeSet.
+        # (The walk runs on Nokogiri fragments only — see the callers.)
         def should_trim_text_node?(text_node)
-          parent = text_node.parent
-          siblings = parent.children
-
-          # Trim if text is the only child
-          return true if siblings.length == 1
-
-          # Trim if text is at the start or end of parent
-          text_node == siblings.first || text_node == siblings.last
+          text_node.previous_sibling.nil? || text_node.next_sibling.nil?
         end
 
         # Remove whitespace-only text nodes from the document
@@ -654,12 +675,16 @@ compare_profile = nil)
         def remove_whitespace_only_text_nodes(doc)
           # Elements where whitespace is significant - don't remove whitespace-only nodes
           # SINGLE SOURCE OF TRUTH: WhitespaceSensitivity.format_default_preserve_elements
-          preserve_whitespace = WhitespaceSensitivity.format_default_preserve_elements(format: :html).map(&:to_s)
+          preserve_whitespace = WhitespaceSensitivity.format_default_preserve_elements(format: :html).to_set(&:to_s)
+          name_cache = {}
+          whitespace_result_cache = {}
 
           doc.xpath(".//text()").each do |text_node|
             # CRITICAL: Skip if this text node is inside a whitespace-preserving element
             parent = text_node.parent
-            next if ancestor_preserves_whitespace?(parent, preserve_whitespace)
+            next if ancestor_preserves_whitespace?(parent, preserve_whitespace,
+                                                   name_cache,
+                                                   whitespace_result_cache)
 
             content = text_node.content
 

data/lib/canon/comparison/node_inspector.rb

@@ -40,7 +40,14 @@ module Canon
 
           # HTML comments are parsed as TEXT nodes by Nokogiri
           if node.text?
-            text_stripped = text_content(node).to_s.strip.gsub("\\", "")
+            raw = text_content(node).to_s
+            # A comment-shaped text must start (after whitespace and
+            # backslash removal) with '<' — anything else is a cheap
+            # negative with no strip/gsub copies. ('\' must reach the
+            # slow path: backslash removal happens before the check.)
+            return false unless raw.match?(/\A[ \t\r\n\f]*[<\\]/)
+
+            text_stripped = raw.strip.gsub("\\", "")
             return true if text_stripped.start_with?("<!--") && text_stripped.end_with?("-->")
           end
           false

data/lib/canon/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Canon
-  VERSION = "0.3.32"
+  VERSION = "0.3.34"
 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,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: canon
 version: !ruby/object:Gem::Version
-  version: 0.3.32
+  version: 0.3.34
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-09-12 00:00:00.000000000 Z
+date: 2026-09-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: diff-lcs