canon 0.3.33 → 0.3.35

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6094f49ebe4d3b32a5396a0db4d62dbc502156d277ed12115029d50eb36f37ff
-  data.tar.gz: 8cf4e6d0b0e1feaaddaed2b996d98f9fd36adb4b250c3460ac2ae20a5263689a
+  metadata.gz: 746a0b0b72cc9111986fb3aab9b8c5de994d71b30a011983665b5a24130b092c
+  data.tar.gz: e9e5a262b99c0e44c2f11385e911faaf5216b52f32bc027d1a0ae82f0bae985e
 SHA512:
-  metadata.gz: 9b53fdc9296da8e354cbb99cc194f6dab11544a52c1cda09370a01f413ce57dc5b04d47d99d496d9a3dcb9558f934dd75a5124be10406de74106e6750b86f51a
-  data.tar.gz: b8cf46fd5d9380584db39732281d18e7186c33927518ac46e5a42fec09d7d3cc5aad167ca1a85c879f087a54a934e8a329b879c43b4cc3aade63512503d0fe80
+  metadata.gz: 9edbbe4c9eb6adb6218b2d282f1ac030fa4642ece72cedae34b54ea6cbac987acfd46bebbf1277da017b4bfcf511be98f41c64951fee9d7034d1410f8414a38b
+  data.tar.gz: 23d088e8fb394d5f36553b64f9e05955f788ca85615147878d6116552ed2ac3b297ebdc739604de009c754a5a8600a57cad97668c6c325a018635d6c6010df04

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.33"
+  VERSION = "0.3.35"
 end

data/lib/canon/xml/element_matcher.rb

@@ -447,7 +447,16 @@ module Canon
         map = {}
 
         elements.each do |elem|
-          class_attr = elem.attribute_nodes.find { |a| a.name == "class" }
+          class_attr = nil
+          attrs = elem.attribute_nodes
+          j = 0
+          while j < attrs.length
+            if attrs[j].name == "class"
+              class_attr = attrs[j]
+              break
+            end
+            j += 1
+          end
           next unless class_attr
 
           # Use element name + class as key to handle multiple element types
@@ -458,11 +467,24 @@ module Canon
         map
       end
 
-      # Extract identity from element attributes
+      # Extract identity from element attributes. Index loops, not
+      # find/detect blocks — Enumerable#find allocates ~3 objects per
+      # call on CRuby 3.4 and this runs per element (both sides) on
+      # every comparison level.
       def extract_identity(elem)
-        @identity_attrs.each do |attr_name|
-          attr = elem.attribute_nodes.find { |a| a.name == attr_name }
-          return attr.value if attr
+        attrs = elem.attribute_nodes
+        i = 0
+        identity_count = @identity_attrs.length
+        while i < identity_count
+          attr_name = @identity_attrs[i]
+          j = 0
+          attr_count = attrs.length
+          while j < attr_count
+            return attrs[j].value if attrs[j].name == attr_name
+
+            j += 1
+          end
+          i += 1
         end
         nil
       end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: canon
 version: !ruby/object:Gem::Version
-  version: 0.3.33
+  version: 0.3.35
 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