canon 0.3.13 → 0.3.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e052ba548bcbe2090cf0ebb538cc50a56ca64cc30a24e875418dbbe9accd053d
-  data.tar.gz: 6dfb8f2c9f840d0326271545ffee0ec137f3313469fa78c0cf80c9dc3e14f931
+  metadata.gz: d9954ac6056439abc3c5b211ecf17b9af2391ad0b809eb3c239fef55cbdc723a
+  data.tar.gz: dbe215e817f160c840769b5bbd0969fe83d315d2b4429cec125de43312ec821a
 SHA512:
-  metadata.gz: c041ca7ded4daedf25b1ecc59d6e3be6ebb7df8dfa12f4bf87ae5458fdfb7bdcc2c3aa8bad1eb92f75c365ee91047d075be45cd05694477275ad1f9313b665be
-  data.tar.gz: 97d0a91b0fb8629cc57315872b2a8c151c2c06b28eca0f6c686c9ba6258b3405e3717fbbc72fa837794ed1129d2412c684955194de8a5e5112831ad4af695bb1
+  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.13"
+  VERSION = "0.3.14"
 end

data/lib/canon/xml/data_model.rb

@@ -171,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|
@@ -252,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
@@ -286,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
@@ -300,30 +308,39 @@ 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 (most
@@ -352,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/sax_builder.rb

@@ -138,16 +138,22 @@ strip_doctype: false)
         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)
@@ -324,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,6 +23,21 @@ 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
@@ -56,53 +71,56 @@ module Canon
         nodes = cache[scope]
         if nodes.nil?
           nodes = scope.map do |prefix, uri|
-            Nodes::NamespaceNode.new(prefix: prefix, uri: 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. 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]
+        # 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 < index
-            candidate = attributes[prior]
-            if candidate[0] == attr_name && candidate[2] == attr_namespace_uri
+          while prior < base
+            if attributes[prior] == attr_name &&
+                attributes[prior + 2] == attr_namespace_uri
               duplicate = true
               break
             end
-            prior += 1
+            prior += 4
           end
 
           unless duplicate
             element.add_attribute(Nodes::AttributeNode.new(
-                                    name: attr_name,
-                                    value: pair[1],
-                                    namespace_uri: attr_namespace_uri,
-                                    prefix: pair[3],
+                                    name: intern(attr_name),
+                                    value: attributes[base + 1],
+                                    namespace_uri: intern(attr_namespace_uri),
+                                    prefix: intern(attributes[base + 3]),
                                   ))
           end
-          index += 1
+          base += 4
         end
 
         element

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: canon
 version: !ruby/object:Gem::Version
-  version: 0.3.13
+  version: 0.3.14
 platform: ruby
 authors:
 - Ribose Inc.