canon 0.3.85 → 0.3.86

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5dbb59b967dbaedab05c9dd8aa4186851ed71d055c44d89ecc23f2b8c8b92e96
-  data.tar.gz: c665d661c0e4984f112a82239406ddc349b6120be032849adf5de7db75331217
+  metadata.gz: dce8920ae714ac966a2d0c91f81d8066c43cd7d7311bd4c100e00c4ea60ad66c
+  data.tar.gz: 0b1dd87f74475eb5e6ef3afa486ebd1ca4160d2aae408b7bfc410135687a117e
 SHA512:
-  metadata.gz: f75058359a37d053f57d6c6d86b27330a0553f925ba49755fa24d31fd248ff0c72b3393d539f75e9cd16fefd02813a590b2e9192031ba1a201cadf4dc7175bc1
-  data.tar.gz: e64b15e520378443018037c78931a7ce9172728ca7c25b8d0caad7acdc1bd6379682e63f8bd28bf88659eef99ec62d03dd86812db282ad936b92d5128d4031b0
+  metadata.gz: fd4055332d0210c7db855eff4027bc1c3a4a4a13a3a1d5398f76f34a00125bf4f180611109fd5e3437610d894f2dbaa27cb66bb5b10783c27cb019138be7f6ff
+  data.tar.gz: cce33bad9441d9f1d9d3f54ef18fc8944cbd37eb2f6b2bb607dfb6020426e3d455f06e0239b7dc9085cf915624a602a51a26219472fd03e2094f503a5987eda6

data/lib/canon/comparison/html_comparator.rb

@@ -310,13 +310,12 @@ module Canon
 
         # Parse a node from string or return as-is
         # Applies preprocessing transformation before parsing if specified
-        # Returns Nokogiri nodes for DOM comparison (preserves original behavior)
+        # Canon trees walk directly (engine HTML lane, semantic handoff);
+        # Nokogiri nodes and strings keep their existing paths.
         def parse_node(node, preprocessing = :none, match_opts = {})
-          # If already a Canon::Xml::Node, convert to Nokogiri for DOM path
           if node.is_a?(Canon::Xml::Node)
-            # Canon nodes used in semantic diff path, convert to Nokogiri for DOM path
-            xml_str = Canon::Xml::DataModel.serialize(node)
-            node = xml_str
+            apply_datamodel_preprocessing!(node, preprocessing, match_opts)
+            return node
           end
 
           # If already a Nokogiri node, check for incompatible XML documents
@@ -406,6 +405,102 @@ module Canon
           find_and_normalize_style_script(root)
         end
 
+        # Post-parse preprocessing for Canon trees (engine HTML lane,
+        # semantic handoff) — the canon-tree mirror of the Nokogiri
+        # fragment normalizers at the bottom of this module, applied at
+        # the same preprocessing points (:normalize/:format get the
+        # style/script pass and whitespace-only removal; :rendered adds
+        # whitespace collapsing).
+        def apply_datamodel_preprocessing!(root, preprocessing, match_opts)
+          return root unless %i[normalize format rendered].include?(preprocessing)
+
+          normalize_html_style_script_comments_datamodel(root)
+          if preprocessing == :rendered
+            normalize_rendered_whitespace_datamodel(root, match_opts)
+          end
+          remove_whitespace_only_text_nodes_datamodel(root)
+          root
+        end
+
+        # Canon-tree mirror of normalize_rendered_whitespace: collapse
+        # whitespace runs in text nodes under non-preserving ancestors
+        # and trim edge-child text. Mutates TextNode#value in place.
+        def normalize_rendered_whitespace_datamodel(root, match_opts = {})
+          return if match_opts[:text_content] == :strict
+
+          preserve_set = WhitespaceSensitivity
+            .format_default_preserve_elements(match_opts)
+            .to_set(&:to_s)
+          name_cache = {}
+          whitespace_result_cache = {}
+
+          each_datamodel_text_node(root) do |text|
+            next if ancestor_preserves_whitespace?(text.parent, preserve_set,
+                                                   name_cache,
+                                                   whitespace_result_cache)
+
+            content = text.value
+            normalized = if content.match?(/[\t\n\r\f\v]/) || content.include?(" ")
+                           content.tr("\t\n\r\f\v", " ").squeeze(" ")
+                         else
+                           content
+                         end
+
+            siblings = text.parent.children
+            if siblings.first.equal?(text) || siblings.last.equal?(text)
+              normalized = normalized.strip
+            end
+            text.value = normalized
+          end
+        end
+
+        # Canon-tree mirror of remove_whitespace_only_text_nodes:
+        # drop whitespace-only text under non-preserving ancestors,
+        # keeping NBSP-bearing and inline-significant nodes. Removals
+        # are batched per parent (writers go through children=).
+        def remove_whitespace_only_text_nodes_datamodel(root)
+          preserve_set = WhitespaceSensitivity
+            .format_default_preserve_elements(format: :html)
+            .to_set(&:to_s)
+          name_cache = {}
+          whitespace_result_cache = {}
+          to_remove = []
+
+          each_datamodel_text_node(root) do |text|
+            next if ancestor_preserves_whitespace?(text.parent, preserve_set,
+                                                   name_cache,
+                                                   whitespace_result_cache)
+
+            content = text.value
+            next if content.include?("\u00A0")
+            next if WhitespaceSensitivity.inline_whitespace_significant?(text)
+
+            to_remove << text if content.strip.empty?
+          end
+
+          to_remove.each do |text|
+            parent = text.parent
+            parent.children = parent.children.reject { |c| c.equal?(text) }
+          end
+        end
+
+        # Yield every TextNode in the tree in document order
+        # (pre-order walk — mirrors xpath(".//text()") order).
+        def each_datamodel_text_node(root)
+          stack = [root]
+          until stack.empty?
+            node = stack.pop
+            yield node if node.is_a?(Canon::Xml::Nodes::TextNode)
+
+            children = node.children
+            i = children.size
+            while i.positive?
+              i -= 1
+              stack.push(children[i])
+            end
+          end
+        end
+
         def find_and_normalize_style_script(node)
           return unless node.is_a?(Canon::Xml::Node)
 

data/lib/canon/comparison/html_parser.rb

@@ -16,20 +16,29 @@ module Canon
     #   HtmlParser.detect_and_parse("<!DOCTYPE html><html>...</html>")
     class HtmlParser
       class << self
-        # Parse HTML string into Nokogiri document with the correct parser
+        # Parse HTML string into the comparison tree.
+        #
+        # The engine lane (moxml Context#parse_html_fragment, moxml#353
+        # riding leptris' WHATWG fragment parsing) builds a Canon tree
+        # through the same TreeBuilder walk the XML lane uses: same
+        # tree construction as Nokogiri::HTML5.fragment (the #118
+        # html4/html5 unification semantics), native named-entity
+        # decoding, and a ~5x faster parse. The Nokogiri fragment
+        # path remains for runtimes without the engine surface.
         #
         # @param content [String, Object] Content to parse (returns as-is if not a string)
         # @param format [Symbol] HTML format (:html, :html4, :html5)
-        # @return [Nokogiri::HTML::Document, Nokogiri::HTML5::Document, Nokogiri::HTML::DocumentFragment, Object]
+        # @return [Canon::Xml::Nodes::RootNode, Object] Canon tree or content
         def parse(content, format)
           return content unless content.is_a?(String)
-          return content if already_parsed?(content)
 
           # Normalize HTML to ensure consistent parsing by HTML4.fragment
           # The key issue is that HTML4.fragment treats newlines after </head>
           # differently than no newlines, causing inconsistent parsing
           content = normalize_html_for_parsing(content)
 
+          return engine_fragment(content) if engine_html_fragments?
+
           begin
             case format
             when :html5
@@ -47,6 +56,47 @@ module Canon
           end
         end
 
+        # Parse an HTML string through the engine's WHATWG fragment
+        # parsing and build a Canon tree from the fragment children.
+        # Whitespace text nodes are preserved unconditionally — HTML
+        # whitespace significance is the comparison profile's decision
+        # (#112/#137 ride on stray whitespace surviving the parse),
+        # unlike the XML DOM lane's parse-time policy. Top-level
+        # element children convert through the materialize-records
+        # fast path; the wrapper walk serves the rare non-element
+        # top-level nodes (text, comments).
+        #
+        # NOTE: the fragment record buffer delivers a nil namespace
+        # URI for prefixed attributes on HTML-parsed trees (xml:lang
+        # arrives as name="lang", prefix="xml", uri=nil) where the
+        # wrapper API reports the bound URI — moxml#367. The TreeBuilder
+        # covers the xml prefix (the one legal binding); other
+        # foreign-content prefixes keep nil URIs on this lane until
+        # the records gap closes.
+        def engine_fragment(html)
+          frag = Canon::XmlParsing.moxml_context.parse_html_fragment(html)
+          root = Canon::Xml::Nodes::RootNode.new
+          frag.children.each do |child|
+            node =
+              if child.is_a?(Moxml::Element)
+                Canon::Xml::DataModel.build_moxml_subtree_from_records(
+                  child, preserve_whitespace: true
+                )
+              else
+                Canon::Xml::DataModel.walk_moxml(child, preserve_whitespace: true)
+              end
+            root.add_child(node) if node
+          end
+          root
+        end
+
+        # Engine HTML fragments are served by adapters with an engine
+        # HTML mode (leptris, nokogiri) — moxml#353 pins WHATWG tree
+        # construction on both.
+        def engine_html_fragments?
+          %i[leptris nokogiri].include?(Canon::XmlParsing.moxml_adapter_name)
+        end
+
         # Check if content is already a parsed HTML document/fragment
         #
         # @param content [Object] Content to check

data/lib/canon/version.rb

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

data/lib/canon/xml/tree_builder.rb

@@ -100,7 +100,15 @@ module Canon
         limit = attributes.size
         while base < limit
           attr_name = attributes[base]
+          attr_prefix = attributes[base + 3]
+          # The xml prefix is bound by definition to the XML namespace
+          # (XML Namespaces 3): when a feed delivers the prefix without
+          # the URI — the HTML fragment records lane, moxml#367 — the
+          # constant is the one legal binding.
           attr_namespace_uri = attributes[base + 2]
+          if attr_namespace_uri.nil? && attr_prefix == "xml"
+            attr_namespace_uri = "http://www.w3.org/XML/1998/namespace"
+          end
           duplicate = false
           prior = 0
           while prior < base

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: canon
 version: !ruby/object:Gem::Version
-  version: 0.3.85
+  version: 0.3.86
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-10-11 00:00:00.000000000 Z
+date: 2026-10-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: diff-lcs