canon 0.3.20 → 0.3.22

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 581a483d81eba304f20fefc4e14777efced86bd7b829d1181209bee00c3ac7df
-  data.tar.gz: ea8929a3686f268e5c99376a0aded4999714b298fe7a558c2ac713929fe3d6ac
+  metadata.gz: 4a369d56aae65493ad94c6352f01a15915eb0af020cde2c98868b7d51a8b0658
+  data.tar.gz: f667f5bf42ed4f1e581ee32951d561653187c06b74b6b996f9bcd1bb9fb0f073
 SHA512:
-  metadata.gz: 19d37bd2c6fec3949791787ca2a64e24afce11588bf17d335efa81fba225d945d77e578a2eb8dae0b8df48904f0f824830f43018cd78830448e05da127498f99
-  data.tar.gz: d3c3f990c6a133cb9cada5dbfae4bb752f524c972f3b75253c24c71226e7ad86138467559e533611b20beb95520f4441bfb80fafd4648bacf5b63e0717a69e70
+  metadata.gz: 6741dac3a19b779fbbd9fe49edaa7f3d6c71497fe4a1cc6339eb65f0d749bcfe9e0800323cb321f4cfd35a756e0ebfab5f8740f8c3aa5e895b70d7c71adc3a84
+  data.tar.gz: 8a360875b2c5597c9e87e81eb0a8037979efa6b8166fe18155a68efc432626d4efebc1aa8ad82ea66ec398681aa1d03f83d35aa1c8fe0684e74a616f0ee96913

data/lib/canon/comparison/node_inspector.rb

@@ -68,8 +68,11 @@ module Canon
       def self.whitespace_only_text?(node)
         return false unless text_node?(node)
 
+        # This runs per child pair in the realignment walk — the
+        # zero-allocation form of `text.strip.empty?` (exactly
+        # String#strip's character set; see WhitespacePolicy).
         text = text_content(node)
-        !text.empty? && text.strip.empty?
+        !text.empty? && text.match?(Canon::Xml::WhitespacePolicy::STRIP_ONLY)
       end
 
       # --- Noise classification ---

data/lib/canon/formatters/html_formatter_base.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "nokogiri" unless RUBY_ENGINE == "opal"
+require "set"
 
 module Canon
   module Formatters
@@ -55,6 +56,14 @@ module Canon
       WHITESPACE_SENSITIVE_ELEMENTS = %w[
         pre code textarea script style
       ].freeze
+      # Set form for the per-sibling hot lookup; Nokogiri lowercases
+      # HTML element names, so the downcase fallback only runs for
+      # unusual (already-mixed-case) input.
+      BLOCK_ELEMENT_SET = BLOCK_ELEMENTS.to_set
+      # Compiled once — building the alternation and compiling the
+      # regex per format call cost more than the gsub it drives.
+      BLOCK_SPACING_PATTERN =
+        Regexp.new("(</(?:#{BLOCK_ELEMENTS.join('|')})>)(<(?:#{BLOCK_ELEMENTS.join('|')})[\s>])").freeze
       # Format HTML using canonical form
       # @param html [String] HTML document to canonicalize
       # @return [String] Canonical form of HTML
@@ -100,6 +109,15 @@ module Canon
           next unless node.element?
           next if node.attributes.empty?
 
+          names = node.attributes.keys
+          # Already-sorted un-namespaced is the common case — removing
+          # and re-adding every attribute is expensive, so check first.
+          # Namespaced attributes must take the slow path: the
+          # remove/re-add below flattens their prefix, and skipping
+          # would change the canonical output.
+          next if names.each_cons(2).all? { |a, b| (a <=> b) <= 0 } &&
+            node.attributes.each_value.all? { |a| a.namespace.nil? }
+
           sorted_attrs = node.attributes.sort_by { |name, _| name }
           node.attributes.each_key { |name| node.remove_attribute(name) }
           sorted_attrs.each { |name, attr| node[name] = attr.value }
@@ -122,7 +140,7 @@ module Canon
           end
 
           # Handle whitespace-only text nodes
-          if node.text.strip.empty? && node.parent&.element?
+          if node.text.match?(Canon::Xml::WhitespacePolicy::STRIP_ONLY) && node.parent&.element?
             # Check if this text node is between block-level elements
             prev_sibling = node.previous_sibling
             next_sibling = node.next_sibling
@@ -138,14 +156,17 @@ module Canon
           else
             # Collapse multiple whitespace characters into single spaces
             # but preserve leading/trailing single spaces for inline content
-            normalized = node.text.gsub(/\s+/, " ")
+            text = node.text
+            normalized = text.gsub(/\s+/, " ")
             # Only strip if the entire parent chain suggests it's appropriate
             # (e.g., at document boundaries)
             if node.parent&.name == "body" &&
                 (node.previous_sibling.nil? || node.next_sibling.nil?)
               normalized = normalized.strip
             end
-            node.content = normalized
+            # node.content= re-parses the string — skip it when nothing
+            # changed (text with no collapsible whitespace).
+            node.content = normalized unless normalized == text
           end
         end
       end
@@ -154,19 +175,20 @@ module Canon
       # @param html [String] Serialized HTML string
       # @return [String] HTML with proper spacing between block elements
       def self.ensure_block_element_spacing(html)
-        # Build regex pattern for block element tags
-        block_tags = BLOCK_ELEMENTS.join("|")
-
         # Add space between closing and opening block element tags
-        # Match: ><opening_block_tag or </closing_block_tag><opening_block_tag
-        html.gsub(/(<\/(?:#{block_tags})>)(<(?:#{block_tags})[\s>])/, '\1 \2')
+        # (pattern compiled once — see BLOCK_SPACING_PATTERN)
+        html.gsub(BLOCK_SPACING_PATTERN, '\1 \2')
       end
 
       # Check if a node is a block-level element
       # @param node [Nokogiri::XML::Node, nil] Node to check
       # @return [Boolean] true if node is a block element
       def self.block_element?(node)
-        node&.element? && BLOCK_ELEMENTS.include?(node.name.downcase)
+        return false unless node&.element?
+
+        name = node.name
+        BLOCK_ELEMENT_SET.include?(name) ||
+          BLOCK_ELEMENT_SET.include?(name.downcase)
       end
 
       # Check if a node is a whitespace-sensitive element
@@ -178,8 +200,14 @@ module Canon
         # Check if this element or any ancestor is whitespace-sensitive
         current = node
         while current
-          if current.element? && WHITESPACE_SENSITIVE_ELEMENTS.include?(current.name.downcase)
-            return true
+          if current.element?
+            name = current.name
+            # Nokogiri lowercases HTML names — the downcase fallback
+            # only allocates for unusual mixed-case input.
+            if WHITESPACE_SENSITIVE_ELEMENTS.include?(name) ||
+                WHITESPACE_SENSITIVE_ELEMENTS.include?(name.downcase)
+              return true
+            end
           end
           # Stop at document root - documents don't have parents
           break if current.is_a?(Nokogiri::XML::Document) || current.is_a?(Nokogiri::HTML5::Document)

data/lib/canon/version.rb

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

data/lib/canon/xml/character_encoder.rb

@@ -5,10 +5,18 @@ module Canon
     # Character encoder for C14N 1.1
     # Handles UTF-8 encoding and character reference encoding per spec
     class CharacterEncoder
+      # Most text and attribute values contain nothing to escape —
+      # the zero-allocation guard keeps those from paying the gsub
+      # copy on every render.
+      TEXT_ESCAPABLE = /[&<>\r]/
+      ATTRIBUTE_ESCAPABLE = /[&<"\t\n\r]/
+
       # Encode text node content
       # Replace: & → &amp;, < → &lt;, > → &gt;, #xD → &#xD;
       def encode_text(text)
-        text.gsub(/[&<>\r]/) do |char|
+        return text unless text.match?(TEXT_ESCAPABLE)
+
+        text.gsub(TEXT_ESCAPABLE) do |char|
           case char
           when "&" then "&amp;"
           when "<" then "&lt;"
@@ -22,7 +30,9 @@ module Canon
       # Replace: & → &amp;, < → &lt;, " → &quot;,
       #          #x9 → &#x9;, #xA → &#xA;, #xD → &#xD;
       def encode_attribute(value)
-        value.gsub(/[&<"\t\n\r]/) do |char|
+        return value unless value.match?(ATTRIBUTE_ESCAPABLE)
+
+        value.gsub(ATTRIBUTE_ESCAPABLE) do |char|
           case char
           when "&" then "&amp;"
           when "<" then "&lt;"

data/lib/canon/xml/namespace_handler.rb

@@ -14,7 +14,7 @@ module Canon
       def process_namespaces(element, output, parent_element = nil)
         return unless element.in_node_set?
 
-        namespaces = element.sorted_namespace_nodes.select(&:in_node_set?)
+        namespaces = renderable_namespaces(element)
 
         # Check if we need to emit xmlns="" for empty default namespace
         if should_emit_empty_default_namespace?(element, namespaces,
@@ -61,26 +61,45 @@ module Canon
       end
 
       # Check if a namespace node should be skipped
-      def should_skip_namespace?(ns, _element, parent_element)
+      def should_skip_namespace?(ns, element, parent_element)
         # Skip xml namespace with standard URI
         return true if ns.xml_namespace?
 
         # Skip if an ancestor already declared this namespace
-        return true if namespace_declared_by_ancestor?(ns, parent_element)
+        return true if namespace_declared_by_ancestor?(ns, element,
+                                                       parent_element)
 
         false
       end
 
       # Check if a namespace is already declared by an ancestor
-      def namespace_declared_by_ancestor?(ns, parent_element)
+      def namespace_declared_by_ancestor?(ns, element, parent_element)
         return false unless parent_element
 
-        parent_ns = parent_element.namespace_nodes.find do |parent_ns|
+        parent_nodes = parent_element.namespace_nodes
+        # Elements that declared nothing share their parent's scope
+        # object (TreeBuilder scope sharing), so identical arrays mean
+        # identical bindings — every namespace of this element is
+        # already declared above and will be skipped without a scan.
+        return true if parent_nodes.equal?(element.namespace_nodes)
+
+        parent_ns = parent_nodes.find do |parent_ns|
           parent_ns.prefix == ns.prefix && parent_ns.in_node_set?
         end
 
         parent_ns && parent_ns.uri == ns.uri
       end
+
+      # Sorted, in-node-set namespaces for one element. Undeclaring
+      # elements share one frozen array object, and node-set marking is
+      # fixed before processing runs, so the rendered form is cached
+      # per array identity for the lifetime of this handler (one
+      # canonicalization run).
+      def renderable_namespaces(element)
+        cache = (@renderable_namespaces ||= {}.compare_by_identity)
+        nodes = element.namespace_nodes
+        cache[nodes] ||= nodes.sort_by(&:local_name).select(&:in_node_set?)
+      end
     end
   end
 end

data/lib/canon/xml/nodes/element_node.rb

@@ -53,15 +53,26 @@ module Canon
           (@attribute_nodes ||= []) << attribute_node
         end
 
-        # Get namespace nodes in sorted order (lexicographically by local name)
+        # Get namespace nodes in sorted order (lexicographically by local name).
         def sorted_namespace_nodes
-          namespace_nodes.sort_by(&:local_name)
+          nodes = namespace_nodes
+          return nodes if nodes.empty?
+
+          nodes.sort_by(&:local_name)
         end
 
-        # Get attribute nodes in sorted order (by namespace URI then local name)
+        # Get attribute nodes in sorted order (by namespace URI then local
+        # name). A comparator block instead of sort_by keys allocates no
+        # per-attribute key arrays; (uri, name) pairs are unique per
+        # element (duplicates are resolved at build), so the order is
+        # identical.
         def sorted_attribute_nodes
-          attribute_nodes.sort_by do |attr|
-            [attr.namespace_uri.to_s, attr.local_name]
+          attrs = attribute_nodes
+          return attrs if attrs.empty?
+
+          attrs.sort do |a, b|
+            (a.namespace_uri.to_s <=> b.namespace_uri.to_s).nonzero? ||
+              (a.local_name <=> b.local_name)
           end
         end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: canon
 version: !ruby/object:Gem::Version
-  version: 0.3.20
+  version: 0.3.22
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-09-06 00:00:00.000000000 Z
+date: 2026-09-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: diff-lcs