canon 0.3.12 → 0.3.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cb5f47fd1b5759edefe57276d19baec565e015cebc47c683125875dad10122b2
-  data.tar.gz: e21fe66a481474c041add458fdbf2e7bcb39dfc910d5fe58f3c6394f33929426
+  metadata.gz: e052ba548bcbe2090cf0ebb538cc50a56ca64cc30a24e875418dbbe9accd053d
+  data.tar.gz: 6dfb8f2c9f840d0326271545ffee0ec137f3313469fa78c0cf80c9dc3e14f931
 SHA512:
-  metadata.gz: a28e38753f0ac126563f37bdea72adec9f605885c25320f09407b4367495ee17c72b60f014615bc7bad6c352640eda067ece20ef4e04361632ae7fd8323f644d
-  data.tar.gz: 6db620f6c3ccdb828102c7b80489b302396e8bdda96c07b0a11abb65b4e2cc09b08ea7ea221cb9bfced71eaaaad829ccc37c1e47d0a88036e2f8c25e5d6b15c4
+  metadata.gz: c041ca7ded4daedf25b1ecc59d6e3be6ebb7df8dfa12f4bf87ae5458fdfb7bdcc2c3aa8bad1eb92f75c365ee91047d075be45cd05694477275ad1f9313b665be
+  data.tar.gz: 97d0a91b0fb8629cc57315872b2a8c151c2c06b28eca0f6c686c9ba6258b3405e3717fbbc72fa837794ed1129d2412c684955194de8a5e5112831ad4af695bb1

data/lib/canon/version.rb

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

data/lib/canon/xml/data_model.rb

@@ -80,8 +80,14 @@ module Canon
       end
 
       def self.extract_xml_encoding(xml_string)
-        binary_string = xml_string.dup.force_encoding("BINARY")
-        if binary_string =~ /\A\s*<\?xml[^>]*\bencoding\s*=\s*["']([^"']+)["'][^>]*\?>/i
+        # A valid UTF-8 string matches directly (the regex is
+        # ASCII-only); anything else still needs the BINARY view so a
+        # broken byte sequence cannot raise mid-probe. Skipping the
+        # dup avoids a full-document copy on every parse.
+        unless xml_string.encoding.name == "UTF-8" && xml_string.valid_encoding?
+          xml_string = xml_string.dup.force_encoding("BINARY")
+        end
+        if xml_string =~ /\A\s*<\?xml[^>]*\bencoding\s*=\s*["']([^"']+)["'][^>]*\?>/i
           return Regexp.last_match(1)
         end
 
@@ -320,8 +326,9 @@ preserve_whitespace: false)
         children << frames.pop[1] while frames.any? && frames.last[0] > depth
         children.reverse_each { |child| element.add_child(child) }
 
-        # Copy the declarations out of the reused buffer.
-        own_namespaces[element] = namespaces.each_slice(2).to_a
+        # Copy the declarations out of the reused buffer (most
+        # elements declare none — stash nothing for those).
+        own_namespaces[element] = namespaces.each_slice(2).to_a unless namespaces.empty?
         element
       end
 

data/lib/canon/xml/node.rb

@@ -4,17 +4,29 @@ module Canon
   module Xml
     # Base class for all XPath data model nodes
     class Node
-      attr_reader :parent, :children
+      attr_reader :parent
 
       def initialize
         @parent = nil
-        @children = []
+        @children = nil
         @in_node_set = true
       end
 
+      # Leaf nodes (text, attributes, namespaces, comments, PIs) never
+      # gain children; allocating the array eagerly cost one Array per
+      # node — the single largest retained-allocation source in a built
+      # tree — so it materializes on first add or read.
+      def children
+        @children ||= []
+      end
+
+      def children=(new_children)
+        @children = new_children
+      end
+
       def add_child(child)
         child.parent = self
-        @children << child
+        children << child
       end
 
       def in_node_set?

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

@@ -3,18 +3,32 @@
 module Canon
   module Xml
     module Nodes
-      # Element node in the XPath data model
       class ElementNode < Node
-        attr_reader :name, :namespace_uri, :prefix, :namespace_nodes,
-                    :attribute_nodes
+        attr_reader :name, :namespace_uri, :prefix
 
         def initialize(name:, namespace_uri: nil, prefix: nil)
           super()
           @name = name
           @namespace_uri = namespace_uri
           @prefix = prefix
-          @namespace_nodes = []
-          @attribute_nodes = []
+          @namespace_nodes = nil
+          @attribute_nodes = nil
+        end
+
+        # Lazy: most elements carry no attributes, and inherited
+        # namespace nodes arrive as one shared frozen array (see
+        # TreeBuilder#attach_namespace_scope) — eager per-element arrays
+        # were the largest retained-allocation source in a built tree.
+        def namespace_nodes
+          @namespace_nodes ||= []
+        end
+
+        def namespace_nodes=(nodes)
+          @namespace_nodes = nodes
+        end
+
+        def attribute_nodes
+          @attribute_nodes ||= []
         end
 
         def node_type
@@ -27,24 +41,22 @@ module Canon
 
         def add_namespace(namespace_node)
           namespace_node.parent = self
-          @namespace_nodes << namespace_node
+          namespace_nodes << namespace_node
         end
 
         def add_attribute(attribute_node)
           attribute_node.parent = self
-          @attribute_nodes << attribute_node
+          attribute_nodes << attribute_node
         end
 
         # Get namespace nodes in sorted order (lexicographically by local name)
         def sorted_namespace_nodes
-          @namespace_nodes.sort_by do |ns|
-            ns.local_name.to_s
-          end
+          namespace_nodes.sort_by(&:local_name)
         end
 
         # Get attribute nodes in sorted order (by namespace URI then local name)
         def sorted_attribute_nodes
-          @attribute_nodes.sort_by do |attr|
+          attribute_nodes.sort_by do |attr|
             [attr.namespace_uri.to_s, attr.local_name]
           end
         end

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

@@ -12,10 +12,6 @@ module Canon
         def node_type
           :root
         end
-
-        def children=(new_children)
-          @children = new_children
-        end
       end
     end
   end

data/lib/canon/xml/sax_builder.rb

@@ -129,8 +129,13 @@ strip_doctype: false)
         end
 
         # Push new namespace scope with declarations (own shadows
-        # inherited — the same merge the TreeBuilder scope kernel applies)
-        new_scope = @namespace_stack.last.merge(ns_hash)
+        # inherited — the same merge the TreeBuilder scope kernel
+        # applies). Elements that declare nothing push the inherited
+        # scope object itself, so scopes — and their cached
+        # namespace-node arrays in TreeBuilder — are shared down runs
+        # of undeclaring elements instead of re-merged per element.
+        inherited_scope = @namespace_stack.last
+        new_scope = ns_hash.empty? ? inherited_scope : inherited_scope.merge(ns_hash)
         @namespace_stack.push(new_scope)
 
         element = TreeBuilder::DEFAULT.element(

data/lib/canon/xml/tree_builder.rb

@@ -26,23 +26,41 @@ module Canon
       # In-scope namespace bindings: the element's own declarations
       # shadow inherited ones; xml is prebound at the base. Declaration
       # pairs are [prefix-or-nil, uri]; nil and "" both mean the default
-      # namespace.
+      # namespace. Elements with no declarations return the inherited
+      # scope unchanged — most elements — so equal scopes share one
+      # object (and one namespace-node array, see attach). The xml
+      # binding is materialized at the root even for undeclaring
+      # elements: it is in scope on every element per the XPath data
+      # model (and the SAX feed's initial stack carries it too).
       def merge_namespace_scope(inherited, declaration_pairs)
+        return inherited if declaration_pairs.empty? && inherited
+
         scope = inherited ? inherited.dup : { XML_NAMESPACE_PREFIX => XML_NAMESPACE_URI }
         declaration_pairs.each do |prefix, uri|
           scope[prefix || ""] = uri
         end
-        scope
+        scope.freeze
       end
 
-      # Attach an in-scope scope to an element as namespace nodes.
+      # Attach an in-scope scope to an element as namespace nodes. The
+      # node array is cached per scope object: elements that introduced
+      # no declarations share their parent's array instead of
+      # re-materializing one NamespaceNode per prefix per element.
+      # NamespaceNode#parent is never read, so shared nodes carry the
+      # first creator as parent by convention. The cache is identity
+      # keyed and bounded — stale scopes of dead trees cost a few
+      # hundred bytes until the next clear.
       def attach_namespace_scope(element, scope)
-        scope.each do |prefix, uri|
-          element.add_namespace(Nodes::NamespaceNode.new(
-                                  prefix: prefix,
-                                  uri: uri,
-                                ))
+        cache = (@namespace_node_cache ||= {}.compare_by_identity)
+        cache.clear if cache.size >= 4096
+        nodes = cache[scope]
+        if nodes.nil?
+          nodes = scope.map do |prefix, uri|
+            Nodes::NamespaceNode.new(prefix: prefix, uri: uri)
+          end.freeze
+          cache[scope] = nodes
         end
+        element.namespace_nodes = nodes
       end
 
       # Build an element. `attributes` are [name, value, namespace_uri,
@@ -58,21 +76,33 @@ module Canon
         attach_namespace_scope(element, namespace_scope) if namespace_scope
 
         # Duplicate (name, namespace) pairs are invalid XML — first
-        # occurrence wins. Attributes per element are few, so a pairwise
-        # scan beats a per-element seen-hash on allocation (this is the
-        # hot SAX path).
-        attributes.each_with_index do |(attr_name, value, attr_namespace_uri, attr_prefix), index|
-          duplicate = attributes[0...index].any? do |prior_name, _v, prior_ns, _p|
-            prior_name == attr_name && prior_ns == attr_namespace_uri
+        # occurrence wins. Index arithmetic instead of subarray slices:
+        # the scan stays allocation-free on the hot paths.
+        index = 0
+        while index < attributes.size
+          pair = attributes[index]
+          attr_name = pair[0]
+          attr_namespace_uri = pair[2]
+          duplicate = false
+          prior = 0
+          while prior < index
+            candidate = attributes[prior]
+            if candidate[0] == attr_name && candidate[2] == attr_namespace_uri
+              duplicate = true
+              break
+            end
+            prior += 1
           end
-          next if duplicate
 
-          element.add_attribute(Nodes::AttributeNode.new(
-                                  name: attr_name,
-                                  value: value,
-                                  namespace_uri: attr_namespace_uri,
-                                  prefix: attr_prefix,
-                                ))
+          unless duplicate
+            element.add_attribute(Nodes::AttributeNode.new(
+                                    name: attr_name,
+                                    value: pair[1],
+                                    namespace_uri: attr_namespace_uri,
+                                    prefix: pair[3],
+                                  ))
+          end
+          index += 1
         end
 
         element

data/lib/canon/xml/whitespace_policy.rb

@@ -14,6 +14,13 @@ module Canon
     # text; engines that report it (libxml2 does not, libleptris 1.9.38+
     # does) stay byte-compatible through here.
     module WhitespacePolicy
+      # Zero-allocation forms of the `content.strip.empty?` /
+      # `content.gsub(...).empty?` checks these policies used to run
+      # per text node. STRIP_ONLY is exactly String#strip's set
+      # (ASCII whitespace plus null); SAX drops space/tab/CR/LF runs.
+      STRIP_ONLY = /\A[\0\t\n\v\f\r ]*\z/
+      SAX_DROPPED = /\A[ \t\r\n]*\z/
+
       module_function
 
       # DOM conversion rule: whitespace-only text is dropped unless
@@ -27,11 +34,11 @@ element_parent: true)
         # The XPath data model has no root text children — drop
         # whitespace-only document-level text even when preserving
         # (engines that report it stay byte-compatible with libxml2).
-        return false if !element_parent && content.strip.empty?
+        return false if !element_parent && content.match?(STRIP_ONLY)
 
         return true if preserve_whitespace
 
-        !content.strip.empty?
+        !content.match?(STRIP_ONLY)
       end
 
       # SAX rule: same shape, plus CR-bearing content is always kept
@@ -39,12 +46,12 @@ element_parent: true)
       # whitespace (space, tab, CR, LF) are dropped when not preserving.
       def keep_sax_text?(content, preserve_whitespace:,
 element_parent: true)
-        return false if !element_parent && content.strip.empty?
+        return false if !element_parent && content.match?(STRIP_ONLY)
 
         return true if preserve_whitespace
         return true if content.include?("\r")
 
-        !content.gsub(/[ \t\r\n]/, "").empty?
+        !content.match?(SAX_DROPPED)
       end
 
       # HTML conversion rule: whitespace-only text is dropped except in
@@ -55,7 +62,7 @@ element_parent: true)
       HTML_WHITESPACE_SENSITIVE_TAGS = %w[pre code textarea script style].freeze
 
       def keep_html_text?(content, parent_name:, inline_significant: false)
-        return true unless content.strip.empty?
+        return true unless content.match?(STRIP_ONLY)
         return true if content.include?(" ")
 
         parent_name = parent_name.to_s.downcase

metadata

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