canon 0.3.15 → 0.3.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d48fa5b4488a85c95b613bcab72881a5e286fdb9859da76aafc78553ff506419
-  data.tar.gz: f0bd3b76b81a0181dc4ae801bed2288828f8d8bc85a6414a98c993d10d770b7a
+  metadata.gz: 133da0e86ad37cf095f738d15a37ebcc3b35ae92240327d459ed1d1bbedc3a5b
+  data.tar.gz: 6c7c2cf6e60712058a6f49f28cf9181316f9e410da5a3982b72fee7fdebde115
 SHA512:
-  metadata.gz: 1b32e0477c8932748179074f076478747d3eb1bce3892e6d7fd8ecae3e1dc7e686fa51907cdbd6444ad87267eb9521206b4caaa6f2d85a93b36f5cc2b3758e4a
-  data.tar.gz: 11c89d97b5144a557746e7d84e9128db443e8951fc40381486da826935f012ccc15249de122232a0ca95b32b5c32ebffe64a2415b6db8f8b9790af2e1eda1b10
+  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/xml_comparator/attribute_comparator.rb

@@ -165,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.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.15"
+  VERSION = "0.3.16"
 end

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.15
+  version: 0.3.16
 platform: ruby
 authors:
 - Ribose Inc.