canon 0.3.14 → 0.3.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d9954ac6056439abc3c5b211ecf17b9af2391ad0b809eb3c239fef55cbdc723a
-  data.tar.gz: dbe215e817f160c840769b5bbd0969fe83d315d2b4429cec125de43312ec821a
+  metadata.gz: 133da0e86ad37cf095f738d15a37ebcc3b35ae92240327d459ed1d1bbedc3a5b
+  data.tar.gz: 6c7c2cf6e60712058a6f49f28cf9181316f9e410da5a3982b72fee7fdebde115
 SHA512:
-  metadata.gz: b1552e6f9a7735903f10b8f73902c6896cfab41b61da29b9bf725c6d5a1132483566eec58eeeb5ce2a59714a5e228ba8cb2979fa79f853cf5bd361f5ffcd849f
-  data.tar.gz: c2b93d2248033a3680164769ab57163f44935314a0929155fa98e2a488f1ea278bff8dba5bbdc38b19d313db13e9ddc6ffeb8b56cdf7537d1ba5c08098ec9bb2
+  metadata.gz: fd39028ce4e945d04ac83d44f9a0da8b516dadf8a454bb634147aabfa480f896ed25f7cf048b39d6b0173a6a1b6aab2881a607b6e8588ff124d4616f95fb944c
+  data.tar.gz: 20eedf19bb73922d482537bfe8411bf8b8816001a4df6d59130f08558d80e14d2bfd968c9029d176cae056b0a4d9b1c36d16fb4012329073cceb490846462f7a

data/lib/canon/comparison/diff_node_builder.rb

@@ -10,10 +10,21 @@ module Canon
     # attributes), and whitespace visualization — previously duplicated
     # across MarkupComparator and XmlComparator.
     class DiffNodeBuilder
-      # Build an enriched DiffNode.
-      def self.build(node1:, node2:, diff1:, diff2:, dimension:, **_opts)
+      # Build a DiffNode. Verbose callers get the fully enriched form —
+      # reason, path, serialized content, attributes; non-verbose
+      # callers only ever ask normative?, and DiffClassifier reads node
+      # refs and dimension alone, so reason building and metadata
+      # enrichment (five display operations per difference) are
+      # skipped entirely.
+      def self.build(node1:, node2:, diff1:, diff2:, dimension:,
+                     verbose: false, **_opts)
         raise ArgumentError, "dimension required for DiffNode" if dimension.nil?
 
+        unless verbose
+          return Canon::Diff::DiffNode.new(node1: node1, node2: node2,
+                                           dimension: dimension)
+        end
+
         reason = build_reason(node1, node2, diff1, diff2, dimension)
         metadata = enrich_metadata(node1, node2)
 

data/lib/canon/comparison/html_comparator.rb

@@ -198,7 +198,7 @@ module Canon
 
           return Comparison::EQUIVALENT if children1.empty? && children2.empty?
 
-          emitter = html_diff_emitter(differences)
+          emitter = html_diff_emitter(differences, opts)
           ChildRealignment.walk(children1, children2, emitter,
                                 emit_structural_orphans: true) do |c1, c2|
             XmlNodeComparison.compare_nodes(c1, c2, opts, child_opts,
@@ -208,10 +208,12 @@ module Canon
 
         # Build a diff emitter for the HTML comparator path that
         # creates DiffNode objects via DiffNodeBuilder.
-        def html_diff_emitter(differences)
+        def html_diff_emitter(differences, opts)
+          verbose = opts[:verbose]
           proc do |n1, n2, d1, d2, dim|
             differences << Canon::Comparison::DiffNodeBuilder.build(
               node1: n1, node2: n2, diff1: d1, diff2: d2, dimension: dim,
+              verbose: verbose
             )
           end
         end

data/lib/canon/comparison/markup_comparator.rb

@@ -16,11 +16,11 @@ module Canon
         #
         # Delegates to DiffNodeBuilder, the single DiffNode factory for
         # the DOM comparison path.
-        def add_difference(node1, node2, diff1, diff2, dimension, _opts,
+        def add_difference(node1, node2, diff1, diff2, dimension, opts,
                            differences)
           differences << Canon::Comparison::DiffNodeBuilder.build(
             node1: node1, node2: node2, diff1: diff1, diff2: diff2,
-            dimension: dimension
+            dimension: dimension, verbose: opts[:verbose]
           )
         end
 
@@ -53,6 +53,19 @@ module Canon
         # @param opts [Hash] Comparison options
         # @return [Array] Filtered array of children
         def filter_children(children, opts)
+          # Fast path: with no ignore_nodes list, only text/comment
+          # children can ever be excluded (node_excluded? returns false
+          # for every other kind) — an all-element child list passes
+          # through untouched, with no reject copy and no per-child
+          # exclusion checks.
+          ignore_nodes = opts[:ignore_nodes]
+          if (ignore_nodes.nil? || ignore_nodes.empty?) && !children.empty?
+            excludable = children.any? do |child|
+              text_node?(child) || comment_node?(child)
+            end
+            return children unless excludable
+          end
+
           children.reject do |child|
             node_excluded?(child, opts)
           end

data/lib/canon/comparison/match_options.rb

@@ -70,6 +70,10 @@ module Canon
           when :strict
             text1 == text2
           when :normalize
+            # Identical strings normalize identically — skip the two
+            # gsub+strip chains.
+            return true if text1 == text2
+
             if whitespace_type == :normalize
               normalize_text(text1) == normalize_text(text2)
             else
@@ -92,22 +96,34 @@ module Canon
             .strip # Remove leading/trailing whitespace
         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.
+        # regexes do not honor \p{Space}); a pure-ASCII miss is
+        # conclusively non-whitespace; only non-ASCII text falls back
+        # to normalize_text's exact Unicode semantics. NUL is included
+        # because String#strip strips nulls too.
         ASCII_WHITESPACE_ONLY = /\A[ \t\r\n\v\f\x00]*\z/
+        ASCII_ONLY = /\A[\x00-\x7f]*\z/
 
         def whitespace_only?(text)
           text = text.to_s
-          text.empty? || text.match?(ASCII_WHITESPACE_ONLY) ||
-            normalize_text(text).empty?
+          return true if text.empty?
+          return true if text.match?(ASCII_WHITESPACE_ONLY)
+          # A pure-ASCII string that failed the class contains an ASCII
+          # non-whitespace character, which survives both the collapse
+          # and the strip — conclusively not whitespace-only, with no
+          # intermediate strings. Only non-ASCII text (NBSP, U+3000,
+          # ...) needs normalize_text's exact Unicode semantics — and
+          # no \p{} classes appear in the fast paths, which Opal's JS
+          # regexes would not honor anyway.
+          return false if text.match?(ASCII_ONLY)
+
+          normalize_text(text).empty?
         end
 
+        # Normalize text preserving Unicode whitespace type distinctions.
         def normalize_text_preserving_type(text)
           return "" if text.nil?
 

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

@@ -26,6 +26,14 @@ module Canon
           match_opts = opts[:match_opts]
           attribute_order_behavior = match_opts[:attribute_order] || :strict
 
+          # FAST PATH: identical filtered attributes in identical key
+          # order — exact equality implies behavioral equality for every
+          # value behavior, and no order difference exists. Most element
+          # pairs hit this and skip the sort/hash/value work entirely.
+          if attrs1 == attrs2 && attrs1.keys == attrs2.keys
+            return Comparison::EQUIVALENT
+          end
+
           # Check attribute order if not ignored
           keys1 = attrs1.keys.map(&:to_s)
           keys2 = attrs2.keys.map(&:to_s)
@@ -157,14 +165,14 @@ differences)
         # @param opts [Hash] Options
         # @param differences [Array] Array to append difference to
         def self.add_attribute_difference(n1:, n2:, diff1:, diff2:,
-dimension:, differences:, **opts)
+                                          dimension:, differences:, opts: {})
           diff_node = Canon::Comparison::DiffNodeBuilder.build(
             node1: n1,
             node2: n2,
             diff1: diff1,
             diff2: diff2,
             dimension: dimension,
-            **opts,
+            verbose: opts[:verbose],
           )
           differences << diff_node if diff_node
         end

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

@@ -17,6 +17,9 @@ module Canon
           ns_decls1 = extract_declarations(node1)
           ns_decls2 = extract_declarations(node2)
 
+          # Most element pairs declare nothing — skip the set algebra.
+          return Comparison::EQUIVALENT if ns_decls1.empty? && ns_decls2.empty?
+
           # Find missing, extra, and changed namespace declarations
           missing = ns_decls1.keys - ns_decls2.keys  # In node1 but not node2
           extra = ns_decls2.keys - ns_decls1.keys    # In node2 but not node1

data/lib/canon/comparison/xml_comparator.rb

@@ -298,14 +298,18 @@ module Canon
           ns2 = Canon::XmlParsing.namespace_uri(n2)
 
           unless ns1 == ns2
-            diff_node = Canon::Comparison::DiffNodeBuilder.build(
-              node1: n1,
-              node2: n2,
-              diff1: Comparison::UNEQUAL_ELEMENTS,
-              diff2: Comparison::UNEQUAL_ELEMENTS,
-              dimension: :namespace_uri,
-            )
-            differences << diff_node if opts[:verbose]
+            # The DiffNode is only ever appended in verbose mode — skip
+            # building it entirely otherwise.
+            if opts[:verbose]
+              differences << Canon::Comparison::DiffNodeBuilder.build(
+                node1: n1,
+                node2: n2,
+                diff1: Comparison::UNEQUAL_ELEMENTS,
+                diff2: Comparison::UNEQUAL_ELEMENTS,
+                dimension: :namespace_uri,
+                verbose: true,
+              )
+            end
             return Comparison::UNEQUAL_ELEMENTS
           end
 

data/lib/canon/diff/diff_node.rb

@@ -34,7 +34,7 @@ module Canon
       # @param serialized_after [String, nil] Optional serialized content for display
       # @param attributes_before [Hash, nil] Optional normalized attributes hash
       # @param attributes_after [Hash, nil] Optional normalized attributes hash
-      def initialize(node1:, node2:, dimension:, reason:,
+      def initialize(node1:, node2:, dimension:, reason: nil,
                      path: nil, serialized_before: nil, serialized_after: nil,
                      attributes_before: nil, attributes_after: nil)
         @node1 = node1

data/lib/canon/version.rb

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

data/lib/canon/xml/node.rb

@@ -4,6 +4,13 @@ module Canon
   module Xml
     # Base class for all XPath data model nodes
     class Node
+      # Shared by every childless node: leaves (text, attributes,
+      # namespaces, comments, PIs) and empty elements read `children`
+      # without materializing a private array. Mutating the returned
+      # array is a bug — writers go through add_child/children=, which
+      # install a private array first.
+      EMPTY_CHILDREN = [].freeze
+
       attr_reader :parent
 
       def initialize
@@ -12,12 +19,8 @@ module Canon
         @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 ||= []
+        @children || EMPTY_CHILDREN
       end
 
       def children=(new_children)
@@ -26,7 +29,7 @@ module Canon
 
       def add_child(child)
         child.parent = self
-        children << child
+        (@children ||= []) << child
       end
 
       def in_node_set?

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

@@ -15,12 +15,16 @@ module Canon
           @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.
+        # Lazy: attribute-free elements (common in real documents) share
+        # one frozen empty array on read instead of materializing one
+        # per element; writers install a private array first. Inherited
+        # namespace nodes arrive as one shared frozen array from
+        # TreeBuilder#attach_namespace_scope.
+        EMPTY_ATTRIBUTE_NODES = [].freeze
+        EMPTY_NAMESPACE_NODES = [].freeze
+
         def namespace_nodes
-          @namespace_nodes ||= []
+          @namespace_nodes || EMPTY_NAMESPACE_NODES
         end
 
         def namespace_nodes=(nodes)
@@ -28,7 +32,7 @@ module Canon
         end
 
         def attribute_nodes
-          @attribute_nodes ||= []
+          @attribute_nodes || EMPTY_ATTRIBUTE_NODES
         end
 
         def node_type
@@ -41,12 +45,12 @@ 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)

data/lib/canon/xml/sax_builder.rb

@@ -22,6 +22,10 @@ module Canon
     #   root = SaxBuilder.parse(xml_string, strip_doctype: true)
     #
     class SaxBuilder
+      # Shared empties for the no-declaration common case: both
+      # consumers only iterate them.
+      NO_NAMESPACE_DECLS = [].freeze
+      EMPTY_NS_HASH = {}.freeze
       # Parse XML string and return Canon::Xml::Node tree
       #
       # @param xml_string [String] XML content to parse
@@ -110,6 +114,31 @@ strip_doctype: false)
       def start_element(name, attrs = [])
         parent = @stack.last
 
+        # Fast path: attribute-less elements (the bulk of most
+        # documents) declare no namespaces — no separation, no hash,
+        # no qname pair array; the inherited scope object is pushed
+        # as-is (shared scope → cached namespace-node array).
+        if attrs.empty?
+          if (colon = name.index(":"))
+            prefix = name[0...colon]
+            local_name = name[(colon + 1)..]
+          else
+            prefix = nil
+            local_name = name
+          end
+          new_scope = @namespace_stack.last
+          @namespace_stack.push(new_scope)
+          element = TreeBuilder::DEFAULT.element(
+            name: local_name,
+            prefix: prefix,
+            namespace_uri: new_scope[prefix.to_s],
+            namespace_scope: new_scope,
+          )
+          parent.add_child(element)
+          @stack.push(element)
+          return
+        end
+
         # Parse namespace from name (prefix:localname or just localname)
         prefix, local_name = parse_qname(name)
 
@@ -280,6 +309,8 @@ strip_doctype: false)
       # @param ns_decls [Array] Array of [name, value] pairs for namespace declarations
       # @return [Hash] Namespace prefix => URI mapping
       def build_ns_hash(ns_decls)
+        return EMPTY_NS_HASH if ns_decls.empty?
+
         result = {}
         ns_decls.each do |name, uri|
           # xmlns="..." for default namespace, xmlns:prefix="..." for prefixed
@@ -311,6 +342,12 @@ strip_doctype: false)
       # @param attrs [Array] Array of [name, value] pairs
       # @return [Array] Two arrays: [namespace_decls, regular_attrs]
       def separate_namespaces(attrs)
+        # Fast path: no xmlns declarations — the attribute pairs pass
+        # through untouched and nothing is copied.
+        unless attrs.any? { |name, _| name == "xmlns" || name.start_with?("xmlns:") }
+          return [NO_NAMESPACE_DECLS, attrs]
+        end
+
         ns_decls = []
         regular_attrs = []
 

metadata

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