canon 0.3.12 → 0.3.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cb5f47fd1b5759edefe57276d19baec565e015cebc47c683125875dad10122b2
-  data.tar.gz: e21fe66a481474c041add458fdbf2e7bcb39dfc910d5fe58f3c6394f33929426
+  metadata.gz: d9954ac6056439abc3c5b211ecf17b9af2391ad0b809eb3c239fef55cbdc723a
+  data.tar.gz: dbe215e817f160c840769b5bbd0969fe83d315d2b4429cec125de43312ec821a
 SHA512:
-  metadata.gz: a28e38753f0ac126563f37bdea72adec9f605885c25320f09407b4367495ee17c72b60f014615bc7bad6c352640eda067ece20ef4e04361632ae7fd8323f644d
-  data.tar.gz: 6db620f6c3ccdb828102c7b80489b302396e8bdda96c07b0a11abb65b4e2cc09b08ea7ea221cb9bfced71eaaaad829ccc37c1e47d0a88036e2f8c25e5d6b15c4
+  metadata.gz: b1552e6f9a7735903f10b8f73902c6896cfab41b61da29b9bf725c6d5a1132483566eec58eeeb5ce2a59714a5e228ba8cb2979fa79f853cf5bd361f5ffcd849f
+  data.tar.gz: c2b93d2248033a3680164769ab57163f44935314a0929155fa98e2a488f1ea278bff8dba5bbdc38b19d313db13e9ddc6ffeb8b56cdf7537d1ba5c08098ec9bb2

data/lib/canon/comparison/html_comparator.rb

@@ -44,6 +44,16 @@ module Canon
         # @return [Boolean, Array] true if equivalent, or array of diffs if
         #   verbose
         def equivalent?(html1, html2, opts = {}, child_opts = {})
+          # FAST PATH: identical inputs never differ under any profile —
+          # byte-identical HTML parses to identical DOMs. Comparison's
+          # entry point already catches this; it is repeated here for
+          # callers invoking the comparator directly. Verbose callers
+          # need full metadata, so they take the whole pipeline.
+          if !opts[:verbose] && (html1.equal?(html2) ||
+              (html1.is_a?(String) && html2.is_a?(String) && html1 == html2))
+            return true
+          end
+
           opts = DEFAULT_OPTS.merge(opts)
 
           # Capture original HTML strings for display.
@@ -94,10 +104,6 @@ module Canon
           # Create child_opts with resolved options
           child_opts = opts.merge(child_opts)
 
-          # Serialize preprocessed nodes for diff display (avoid re-preprocessing)
-          preprocessed_str1 = serialize_for_display(node1)
-          preprocessed_str2 = serialize_for_display(node2)
-
           differences = []
           diff_children = opts[:diff_children] || false
 
@@ -124,10 +130,11 @@ module Canon
           if opts[:verbose]
             ComparisonResult.new(
               differences: differences,
-              preprocessed_strings: [preprocessed_str1, preprocessed_str2],
+              preprocessed_strings: [serialize_for_display(node1),
+                                     serialize_for_display(node2)],
               original_strings: [original_str1, original_str2],
               format: :html,
-              html_version: detect_html_version_from_node(node1),
+              html_version: html_version,
               match_options: match_opts_hash,
               algorithm: :dom,
               parse_errors_expected: Comparison.parse_errors_for(node1),

data/lib/canon/comparison/markup_comparator.rb

@@ -93,7 +93,7 @@ module Canon
           # Use preserve_whitespace_elements / strip_whitespace_elements to control.
           # Blacklist (strip) > preserve > collapse > format defaults.
           return false unless text_node?(node) && node.parent
-          return false unless MatchOptions.normalize_text(node_text(node)).empty?
+          return false unless MatchOptions.whitespace_only?(node_text(node))
 
           # NBSP (U+00A0) is never insignificant whitespace —
           # it always renders as a visible non-breaking space.

data/lib/canon/comparison/match_options.rb

@@ -93,6 +93,21 @@ module Canon
         end
 
         # Normalize text preserving Unicode whitespace type distinctions.
+        # Fast form of `normalize_text(text).empty?`, called per text
+        # node by node_excluded?. Pure-ASCII whitespace (the common
+        # case — pretty-print indentation) matches a plain class with
+        # no intermediate strings and no \p{} property (Opal's JS
+        # regexes do not honor \p{Space}); anything else falls back to
+        # normalize_text's exact semantics. NUL is included because
+        # String#strip strips nulls too.
+        ASCII_WHITESPACE_ONLY = /\A[ \t\r\n\v\f\x00]*\z/
+
+        def whitespace_only?(text)
+          text = text.to_s
+          text.empty? || text.match?(ASCII_WHITESPACE_ONLY) ||
+            normalize_text(text).empty?
+        end
+
         def normalize_text_preserving_type(text)
           return "" if text.nil?
 

data/lib/canon/comparison/whitespace_sensitivity.rb

@@ -24,6 +24,19 @@ module Canon
         time tt u var wbr
       ].freeze
 
+      # Precomputed symbol forms of the default lists: format_default_*
+      # used to map(&:to_sym) per call — one array per classified node.
+      HTML_PRESERVE_SYMBOLS = HTML_PRESERVE_ELEMENTS.map(&:to_sym).freeze
+      HTML_COLLAPSE_SYMBOLS = HTML_COLLAPSE_ELEMENTS.map(&:to_sym).freeze
+
+      # The resolved element sets depend only on match_opts, which is
+      # resolved once per comparison — but classification runs per node,
+      # so the sets are memoized per match_opts object (identity-keyed;
+      # side-flag merges produce distinct objects and their own entries).
+      # Bounded: stale entries of finished comparisons cost a few
+      # hundred bytes until the next clear.
+      RESOLVED_SETS_LIMIT = 1024
+
       class << self
         # Classify the whitespace behaviour for an element using ancestor walk.
         def classify_element(element, match_opts)
@@ -107,7 +120,7 @@ module Canon
           format = match_opts[:format] || :xml
           case format
           when :html, :html4, :html5
-            HTML_PRESERVE_ELEMENTS.map(&:to_sym).freeze
+            HTML_PRESERVE_SYMBOLS
           else
             [].freeze
           end
@@ -117,7 +130,7 @@ module Canon
           format = match_opts[:format] || :xml
           case format
           when :html, :html4, :html5
-            HTML_COLLAPSE_ELEMENTS.map(&:to_sym).freeze
+            HTML_COLLAPSE_SYMBOLS
           else
             [].freeze
           end
@@ -184,30 +197,43 @@ module Canon
         end
 
         def resolved_preserve_elements_set(match_opts)
-          set = Set.new(format_default_preserve_elements(match_opts).map(&:to_s))
+          entry = resolved_sets_entry(match_opts)
+          entry[0] ||= begin
+            set = Set.new(format_default_preserve_elements(match_opts).map(&:to_s))
 
-          if match_opts[:preserve_whitespace_elements]
-            set |= match_opts[:preserve_whitespace_elements].map(&:to_s)
-          end
+            if match_opts[:preserve_whitespace_elements]
+              set |= match_opts[:preserve_whitespace_elements].map(&:to_s)
+            end
 
-          strip_set = resolved_strip_elements_set(match_opts)
-          set.reject { |e| strip_set.include?(e) }.to_set
+            strip_set = resolved_strip_elements_set(match_opts)
+            set.reject { |e| strip_set.include?(e) }.to_set
+          end
         end
 
         def resolved_collapse_elements_set(match_opts)
-          set = Set.new(format_default_collapse_elements(match_opts).map(&:to_s))
+          entry = resolved_sets_entry(match_opts)
+          entry[1] ||= begin
+            set = Set.new(format_default_collapse_elements(match_opts).map(&:to_s))
 
-          if match_opts[:collapse_whitespace_elements]
-            set |= match_opts[:collapse_whitespace_elements].map(&:to_s)
-          end
+            if match_opts[:collapse_whitespace_elements]
+              set |= match_opts[:collapse_whitespace_elements].map(&:to_s)
+            end
 
-          strip_set = resolved_strip_elements_set(match_opts)
-          set.reject { |e| strip_set.include?(e) }.to_set
+            strip_set = resolved_strip_elements_set(match_opts)
+            set.reject { |e| strip_set.include?(e) }.to_set
+          end
         end
 
         def resolved_strip_elements_set(match_opts)
-          raw = match_opts[:strip_whitespace_elements]
-          Set.new((raw || []).map(&:to_s))
+          entry = resolved_sets_entry(match_opts)
+          entry[2] ||= Set.new((match_opts[:strip_whitespace_elements] || [])
+                                 .map(&:to_s))
+        end
+
+        def resolved_sets_entry(match_opts)
+          cache = (@resolved_sets_cache ||= {}.compare_by_identity)
+          cache.clear if cache.size >= RESOLVED_SETS_LIMIT
+          cache[match_opts] ||= [nil, nil, nil]
         end
 
         def walk_ancestor_classification(element, preserve_set, collapse_set,
@@ -271,7 +297,7 @@ module Canon
           name = node_name(element)
           return false unless name
 
-          list.map(&:to_s).include?(name.to_s)
+          list.any? { |e| e.to_s == name }
         end
 
         def text_node_parent?(node)

data/lib/canon/comparison/xml_comparator/child_comparison.rb

@@ -75,21 +75,10 @@ module Canon
           # Use ElementMatcher for semantic comparison
           def use_element_matcher_comparison(children1, children2, parent_node, comparator,
                                              opts, child_opts, diff_children, differences)
-            # Create temporary RootNode wrappers
-            temp_root1 = Canon::Xml::Nodes::RootNode.new
-            temp_root1.children = children1.dup
-
-            temp_root2 = Canon::Xml::Nodes::RootNode.new
-            temp_root2.children = children2.dup
-
-            matcher = Canon::Xml::ElementMatcher.new
-            matches = matcher.match_trees(temp_root1, temp_root2)
-
-            # Filter matches to only include direct children
-            matches = matches.select do |m|
-              (m.elem1.nil? || children1.include?(m.elem1)) &&
-                (m.elem2.nil? || children2.include?(m.elem2))
-            end
+            # Single-level matching: the comparator itself descends via
+            # compare_nodes below, so nested matches would be discarded.
+            matches = Canon::Xml::ElementMatcher.new
+              .match_children_only(children1, children2)
 
             # If no matches and children exist, they're all different
             if matches.empty? && (!children1.empty? || children2.empty?)

data/lib/canon/comparison.rb

@@ -230,6 +230,16 @@ module Canon
       #   - :verbose - Return detailed diff array (default: false)
       # @return [Boolean, Array] true if equivalent, or array of diffs if verbose
       def equivalent?(obj1, obj2, opts = {})
+        # FAST PATH: identical inputs never differ under any profile —
+        # byte-identical strings parse to identical structures, and one
+        # object parsed twice yields the same tree. Verbose callers need
+        # full metadata (differences list, statistics), so they take the
+        # whole pipeline.
+        if !opts[:verbose] && (obj1.equal?(obj2) ||
+            (obj1.is_a?(String) && obj2.is_a?(String) && obj1 == obj2))
+          return true
+        end
+
         # Normalize: match: { semantic_diff: true } → diff_algorithm: :semantic
         if opts.dig(:match, :semantic_diff) || opts.dig(:match, :semantic_tree)
           opts = opts.merge(diff_algorithm: :semantic)

data/lib/canon/html/data_model.rb

@@ -107,17 +107,20 @@ module Canon
             inherited_namespaces,
             node.namespace_definitions.map { |ns| [ns.prefix, ns.href] },
           )
+          # HTML attributes are namespace-free; xmlns declarations are
+          # not reported as attributes. Flat stride-4 array
+          # (TreeBuilder#element contract).
+          flat_attributes = []
+          node.attribute_nodes.each do |attr|
+            next if attr.name.start_with?("xmlns")
+
+            flat_attributes << attr.name << attr.value << nil << nil
+          end
           element = builder.element(
             name: node.name,
             prefix: node.namespace&.prefix,
             namespace_uri: node.namespace&.href,
-            # HTML attributes are namespace-free; xmlns declarations are
-            # not reported as attributes.
-            attributes: node.attribute_nodes.filter_map do |attr|
-              next if attr.name.start_with?("xmlns")
-
-              [attr.name, attr.value, nil, nil]
-            end,
+            attributes: flat_attributes,
             namespace_scope: scope,
           )
           node.children.each do |child|

data/lib/canon/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Canon
-  VERSION = "0.3.12"
+  VERSION = "0.3.14"
 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
 
@@ -165,13 +171,16 @@ inherited_namespaces: nil)
             inherited_namespaces,
             node.namespace_definitions.map { |ns| [ns.prefix, ns.href] },
           )
+          flat_attributes = []
+          node.attribute_nodes.each do |attr|
+            flat_attributes << attr.name << attr.value <<
+              attr.namespace&.href << attr.namespace&.prefix
+          end
           element = TreeBuilder::DEFAULT.element(
             name: node.name,
             prefix: node.namespace&.prefix,
             namespace_uri: node.namespace&.href,
-            attributes: node.attribute_nodes.map do |attr|
-              [attr.name, attr.value, attr.namespace&.href, attr.namespace&.prefix]
-            end,
+            attributes: flat_attributes,
             namespace_scope: scope,
           )
           node.children.each do |child|
@@ -246,13 +255,18 @@ inherited_namespaces: nil)
 
       def self.build_moxml_subtree_from_records(moxml_element,
 preserve_whitespace: false)
-        frames = []
+        # Parallel depth/node stacks: one [depth, node] pair per record
+        # cost two Arrays per node; depths are Integers (immediate
+        # values), so two parallel arrays allocate nothing per record.
+        frame_depths = []
+        frame_nodes = []
         own_namespaces = {}.compare_by_identity
 
         # materialize_fields: the zero-allocation hot path (moxml#143).
         # Flat reused buffers — attributes stride 4, namespaces stride
         # 2 — valid only inside the block, so the element builder
-        # copies them into pairs before returning.
+        # consumes them synchronously before the next record reuses
+        # the buffer.
         moxml_element.materialize_fields do |kind, qname, prefix, namespace_uri, namespaces, attributes, text, depth|
           # The record contract is root-subtree-only since moxml 0.5.11
           # (moxml#140). Older 0.5.x releases — still allowed by canon's
@@ -280,7 +294,7 @@ preserve_whitespace: false)
                  when :element
                    build_moxml_element_from_fields(
                      qname, prefix, namespace_uri, namespaces, attributes,
-                     depth, frames, own_namespaces
+                     depth, frame_depths, frame_nodes, own_namespaces
                    )
                  when :text, :cdata
                    content = text.to_s
@@ -294,34 +308,44 @@ preserve_whitespace: false)
                    TreeBuilder::DEFAULT.processing_instruction(qname, text || "")
                  end
 
-          frames.push([depth, node]) if node
+          if node
+            frame_depths << depth
+            frame_nodes << node
+          end
         end
 
-        top = frames.last
-        return nil unless top
+        return nil if frame_nodes.empty?
 
-        assign_moxml_namespace_scopes(top[1], nil, own_namespaces)
-        top[1]
+        top = frame_nodes.last
+        assign_moxml_namespace_scopes(top, nil, own_namespaces)
+        top
       end
 
       def self.build_moxml_element_from_fields(qname, prefix, namespace_uri,
                                                namespaces, attributes, depth,
-                                               frames, own_namespaces)
+                                               frame_depths, frame_nodes,
+                                               own_namespaces)
+        # The flat attribute buffer is consumed synchronously — the
+        # next record reuses it (no each_slice copy out of the block).
         element = TreeBuilder::DEFAULT.element(
           name: qname,
           prefix: prefix,
           namespace_uri: namespace_uri,
-          attributes: attributes.each_slice(4).to_a,
+          attributes: attributes,
         )
 
         # Adopt completed children: they pop in reverse order; reversing
         # once is O(n) (unshift per child would be O(n^2) on wide trees).
         children = []
-        children << frames.pop[1] while frames.any? && frames.last[0] > depth
+        while frame_depths.any? && frame_depths.last > depth
+          frame_depths.pop
+          children << frame_nodes.pop
+        end
         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
 
@@ -345,13 +369,16 @@ inherited_namespaces: nil)
             inherited_namespaces,
             node.namespace_definitions.map { |ns| [ns.prefix, ns.uri] },
           )
+          flat_attributes = []
+          node.attributes.each do |attr|
+            flat_attributes << attr.name << attr.value <<
+              attr.namespace&.uri << attr.namespace&.prefix
+          end
           element = TreeBuilder::DEFAULT.element(
             name: node.name,
             prefix: node.namespace&.prefix,
             namespace_uri: node.namespace&.uri,
-            attributes: node.attributes.map do |attr|
-              [attr.name, attr.value, attr.namespace&.uri, attr.namespace&.prefix]
-            end,
+            attributes: flat_attributes,
             namespace_scope: scope,
           )
           node.children.each do |child|

data/lib/canon/xml/element_matcher.rb

@@ -130,6 +130,21 @@ module Canon
         @matches
       end
 
+      # Match one level of children only — no descent into matched
+      # pairs. The comparator walks descendants itself (compare_nodes →
+      # ChildComparison per level), so the nested matches match_trees
+      # would produce below this level are discarded by its direct-
+      # children filter; matching them is wasted work.
+      #
+      # @param children1 [Array<Canon::Xml::Node>] First parent's children
+      # @param children2 [Array<Canon::Xml::Node>] Second parent's children
+      # @return [Array<MatchResult>] Match results for these children only
+      def match_children_only(children1, children2)
+        @matches = []
+        match_level(children1, children2, [], recursive: false)
+        @matches
+      end
+
       private
 
       # Match children recursively
@@ -137,10 +152,25 @@ module Canon
         # FAST PATH: Same array object means all children match
         return if children1.equal?(children2)
 
+        match_level(children1, children2, path, recursive: true)
+      end
+
+      # One matching level: identity attributes, then name+namespace
+      # position, then class attribute, then deleted/inserted recording.
+      # With +recursive:+ true, matched pairs descend immediately after
+      # being recorded (match_trees' ordering contract).
+      def match_level(children1, children2, path, recursive:)
         # Filter to only element nodes
         elems1 = children1.select { |n| n.node_type == :element }
         elems2 = children2.select { |n| n.node_type == :element }
 
+        # Positions by identity: elems.index(elem) was an O(n) scan per
+        # recorded match — O(n²) per level on element-heavy parents.
+        positions1 = {}
+        elems1.each_with_index { |e, i| positions1[e] = i }
+        positions2 = {}
+        elems2.each_with_index { |e, i| positions2[e] = i }
+
         # Build identity maps for quick lookup
         map1 = build_identity_map(elems1)
         map2 = build_identity_map(elems2)
@@ -160,24 +190,22 @@ module Canon
                                   path + [elem1.name]
                                 end
 
-            # Track positions
-            pos1 = elems1.index(elem1)
-            pos2 = elems2.index(elem2)
-
             @matches << MatchResult.new(
               status: :matched,
               elem1: elem1,
               elem2: elem2,
               path: elem_path_with_ns,
-              pos1: pos1,
-              pos2: pos2,
+              pos1: positions1[elem1],
+              pos2: positions2[elem2],
             )
 
             matched1.add(elem1)
             matched2.add(elem2)
 
             # Recursively match children
-            match_children(elem1.children, elem2.children, elem_path_with_ns)
+            if recursive
+              match_children(elem1.children, elem2.children, elem_path_with_ns)
+            end
           end
         end
 
@@ -185,14 +213,15 @@ module Canon
         unmatched1 = elems1.reject { |e| matched1.include?(e) }
         unmatched2 = elems2.reject { |e| matched2.include?(e) }
 
-        match_by_position(unmatched1, unmatched2, path, matched1, matched2)
+        match_by_position(unmatched1, unmatched2, path, matched1, matched2,
+                          recursive: recursive)
 
         # Fallback: match remaining elements by class attribute
         # This handles insertions that shift positions
         still_unmatched1 = elems1.reject { |e| matched1.include?(e) }
         still_unmatched2 = elems2.reject { |e| matched2.include?(e) }
         match_by_class(still_unmatched1, still_unmatched2, path, matched1,
-                       matched2)
+                       matched2, recursive: recursive)
 
         # Record unmatched as deleted/inserted
         unmatched1.each do |elem1|
@@ -203,14 +232,13 @@ module Canon
                               else
                                 path + [elem1.name]
                               end
-          pos1 = elems1.index(elem1)
 
           @matches << MatchResult.new(
             status: :deleted,
             elem1: elem1,
             elem2: nil,
             path: elem_path_with_ns,
-            pos1: pos1,
+            pos1: positions1[elem1],
             pos2: nil,
           )
         end
@@ -223,7 +251,6 @@ module Canon
                               else
                                 path + [elem2.name]
                               end
-          pos2 = elems2.index(elem2)
 
           @matches << MatchResult.new(
             status: :inserted,
@@ -231,17 +258,25 @@ module Canon
             elem2: elem2,
             path: elem_path_with_ns,
             pos1: nil,
-            pos2: pos2,
+            pos2: positions2[elem2],
           )
         end
       end
 
       # Match remaining elements by name and position
-      def match_by_position(elems1, elems2, path, matched1, matched2)
+      def match_by_position(elems1, elems2, path, matched1, matched2,
+                            recursive:)
         # Group by element name AND namespace_uri
         by_identity1 = elems1.group_by { |e| [e.name, e.namespace_uri] }
         by_identity2 = elems2.group_by { |e| [e.name, e.namespace_uri] }
 
+        # Positions within these (already unmatched-filtered) lists —
+        # elems.index(elem) was an O(n) scan per recorded match
+        subset_positions1 = {}
+        elems1.each_with_index { |e, i| subset_positions1[e] = i }
+        subset_positions2 = {}
+        elems2.each_with_index { |e, i| subset_positions2[e] = i }
+
         # For each name+namespace combination, match by position
         by_identity1.each do |identity, list1|
           next unless by_identity2.key?(identity)
@@ -264,34 +299,39 @@ module Canon
                                   path + [name]
                                 end
 
-            # Track positions in original element lists
-            pos1 = elems1.index(elem1)
-            pos2 = elems2.index(elem2)
-
             @matches << MatchResult.new(
               status: :matched,
               elem1: elem1,
               elem2: elem2,
               path: elem_path_with_ns,
-              pos1: pos1,
-              pos2: pos2,
+              pos1: subset_positions1[elem1],
+              pos2: subset_positions2[elem2],
             )
             matched1.add(elem1)
             matched2.add(elem2)
 
             # Recursively match children
-            match_children(elem1.children, elem2.children, elem_path_with_ns)
+            if recursive
+              match_children(elem1.children, elem2.children, elem_path_with_ns)
+            end
           end
         end
       end
 
       # Match remaining elements by class attribute (position-independent)
       # This handles cases where insertions shift positions but elements have class-based identity
-      def match_by_class(elems1, elems2, path, matched1, matched2)
+      def match_by_class(elems1, elems2, path, matched1, matched2,
+                         recursive:)
         # Build class maps for elements that have class attributes
         class_map1 = build_class_map(elems1)
         class_map2 = build_class_map(elems2)
 
+        # Positions within these (still-unmatched-filtered) lists
+        subset_positions1 = {}
+        elems1.each_with_index { |e, i| subset_positions1[e] = i }
+        subset_positions2 = {}
+        elems2.each_with_index { |e, i| subset_positions2[e] = i }
+
         # Match by class attribute
         class_map1.each do |class_value, elem1|
           next if matched1.include?(elem1)
@@ -311,23 +351,21 @@ module Canon
                                 path + [elem1.name]
                               end
 
-          # Track positions in original element lists
-          pos1 = elems1.index(elem1)
-          pos2 = elems2.index(elem2)
-
           @matches << MatchResult.new(
             status: :matched,
             elem1: elem1,
             elem2: elem2,
             path: elem_path_with_ns,
-            pos1: pos1,
-            pos2: pos2,
+            pos1: subset_positions1[elem1],
+            pos2: subset_positions2[elem2],
           )
           matched1.add(elem1)
           matched2.add(elem2)
 
           # Recursively match children
-          match_children(elem1.children, elem2.children, elem_path_with_ns)
+          if recursive
+            match_children(elem1.children, elem2.children, elem_path_with_ns)
+          end
         end
       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,20 +129,31 @@ 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)
 
+        # Flat stride-4 attribute array (TreeBuilder#element contract):
+        # one array per element instead of one sub-array per attribute.
+        flat_attributes = []
+        regular_attrs.each do |attr_name, attr_value|
+          attr_prefix, attr_local = parse_qname(attr_name)
+          attr_ns_uri = attr_prefix ? new_scope[attr_prefix] : nil
+          flat_attributes << attr_local <<
+            decode_character_references(attr_value || "") << attr_ns_uri << attr_prefix
+        end
+
         element = TreeBuilder::DEFAULT.element(
           name: local_name,
           prefix: prefix,
           namespace_uri: new_scope[prefix.to_s],
           namespace_scope: new_scope,
-          attributes: regular_attrs.map do |attr_name, attr_value|
-            attr_prefix, attr_local = parse_qname(attr_name)
-            attr_ns_uri = attr_prefix ? new_scope[attr_prefix] : nil
-            [attr_local, decode_character_references(attr_value || ""), attr_ns_uri, attr_prefix]
-          end,
+          attributes: flat_attributes,
         )
 
         parent.add_child(element)
@@ -319,6 +330,10 @@ strip_doctype: false)
       # @param value [String] String potentially containing character references
       # @return [String] String with character references decoded
       def decode_character_references(value)
+        # Fast path: no reference opener means nothing to decode —
+        # skip the gsub and its string copy on every plain text chunk.
+        return value unless value.include?("&")
+
         value.gsub(/&#(x?[0-9a-fA-F]+);/) do |match|
           code_str = Regexp.last_match(1)
           code_point = if code_str.start_with?("x")

data/lib/canon/xml/tree_builder.rb

@@ -23,56 +23,104 @@ module Canon
       XML_NAMESPACE_PREFIX = "xml"
       XML_NAMESPACE_URI = "http://www.w3.org/XML/1998/namespace"
 
+      # Repetitive short strings — element/attribute names, prefixes,
+      # namespace URIs — are interned so one frozen instance is shared
+      # across every tree canon builds: a thousand `<p>` elements hold
+      # one "p". Values (text content, attribute values) are unique and
+      # are never interned. Bounded; cleared when full.
+      INTERN_LIMIT = 8192
+
+      def intern(string)
+        return string if string.nil?
+
+        cache = (@string_intern_cache ||= {})
+        cache.clear if cache.size >= INTERN_LIMIT
+        cache.fetch(string) { cache[string] = string.freeze }
+      end
+
       # 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: intern(prefix), uri: intern(uri))
+          end.freeze
+          cache[scope] = nodes
         end
+        element.namespace_nodes = nodes
       end
 
-      # Build an element. `attributes` are [name, value, namespace_uri,
-      # prefix] pairs; `namespace_scope` is a merged scope (or nil for
-      # no namespace nodes).
+      # Build an element. `attributes` is a FLAT stride-4 array —
+      # [name, value, namespace_uri, prefix, name, value, ...] — so the
+      # moxml records feed hands its reused buffer straight through
+      # (read synchronously below) and the tree feeds build one flat
+      # array instead of one sub-array per attribute. `namespace_scope`
+      # is a merged scope (or nil for no namespace nodes).
       def element(name:, prefix: nil, namespace_uri: nil,
                   attributes: NO_ATTRIBUTES, namespace_scope: nil)
         element = Nodes::ElementNode.new(
-          name: name,
-          namespace_uri: namespace_uri,
-          prefix: prefix,
+          name: intern(name),
+          namespace_uri: intern(namespace_uri),
+          prefix: intern(prefix),
         )
         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. Flat index arithmetic keeps the scan
+        # allocation-free.
+        base = 0
+        limit = attributes.size
+        while base < limit
+          attr_name = attributes[base]
+          attr_namespace_uri = attributes[base + 2]
+          duplicate = false
+          prior = 0
+          while prior < base
+            if attributes[prior] == attr_name &&
+                attributes[prior + 2] == attr_namespace_uri
+              duplicate = true
+              break
+            end
+            prior += 4
+          end
+
+          unless duplicate
+            element.add_attribute(Nodes::AttributeNode.new(
+                                    name: intern(attr_name),
+                                    value: attributes[base + 1],
+                                    namespace_uri: intern(attr_namespace_uri),
+                                    prefix: intern(attributes[base + 3]),
+                                  ))
           end
-          next if duplicate
-
-          element.add_attribute(Nodes::AttributeNode.new(
-                                  name: attr_name,
-                                  value: value,
-                                  namespace_uri: attr_namespace_uri,
-                                  prefix: attr_prefix,
-                                ))
+          base += 4
         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.14
 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