canon 0.3.84 → 0.3.86

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8eb8f8e66d462a55fad0d7a649c3c928ecd8e4e0d3a774c38bccfb4be7972fd4
-  data.tar.gz: 8114e80672e76a7c239c76ad485d7d3bb2c090871ff4e44f59d7d46cf31db569
+  metadata.gz: dce8920ae714ac966a2d0c91f81d8066c43cd7d7311bd4c100e00c4ea60ad66c
+  data.tar.gz: 0b1dd87f74475eb5e6ef3afa486ebd1ca4160d2aae408b7bfc410135687a117e
 SHA512:
-  metadata.gz: 4939b31f56f07b0c61d7d91a40550eb039e1e2f7d3707c6ae8213ed928386c3533ae64badbd66f8ee09d89f6054a0a2d56149c83fbe4b459deb51db7e5122346
-  data.tar.gz: 706e55d06c6998cbe1d9828f286480c9b270f59d0926c0cb4b410b2ac0dde4a135fe28e61575aa6e06c3a8a3aa48bfb74b08a030dc9e9d88a64f775dc3f76ede
+  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.84"
+  VERSION = "0.3.86"
 end

data/lib/canon/xml/data_model.rb

@@ -278,13 +278,6 @@ preserve_whitespace: false)
         # 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
-          # gemspec floor — leaked epilog document-level records at depth
-          # 0, which the document-children enumeration also covers; one
-          # integer compare per record keeps those working.
-          next if depth.zero? && kind != :element
-
           # Relative-namespace validation rides the stream (the
           # namespaces buffer is the element's own declarations) — no
           # separate wrapper-tree walk per parse.

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

data/lib/canon/xml_parsing.rb

@@ -60,7 +60,7 @@ module Canon
         # contract keys off the RECORD, not the raise: non-HTML
         # malformed input stays loud; HTML-shaped input falls back to
         # the HTML parser. Engine-independent by construction.
-        recorded = doc.respond_to?(:parse_errors) ? doc.parse_errors : []
+        recorded = doc.parse_errors
         if recorded.any?
           raise Moxml::ParseError, recorded.join("; ") unless html_shaped?(xml_string)
 
@@ -114,31 +114,11 @@ module Canon
         end
       end
 
-      # Same underlying engine node? Wrapper identity first (correct
-      # everywhere wrappers are unified). Fallback: moxml 0.5.36-0.5.39
-      # wrap Document#root and Document#children entries in DIFFERENT
-      # wrapper classes for one node (NativeNode vs the FFI Element —
-      # moxml#216), so identity fails exactly where consumers exclude
-      # the document element from children; the shared C pointer
-      # address is the stable identity. Inert once wrappers unify.
+      # Same underlying engine node? Wrappers are unified on every
+      # moxml the gemspec floor allows (moxml#219 landed in 0.5.40), so
+      # object identity is the whole answer.
       def same_engine_node?(left, right)
-        return true if left.equal?(right)
-        return false unless defined?(::Moxml::Node) &&
-          left.is_a?(::Moxml::Node) && right.is_a?(::Moxml::Node)
-
-        address_left = moxml_node_address(left)
-        address_right = moxml_node_address(right)
-        !address_left.nil? && address_left == address_right
-      end
-
-      def moxml_node_address(wrapper)
-        native = wrapper.native
-        case native
-        when ::Leptris::XML::NativeNode then native.address
-        when ::Leptris::XML::Node then native.c_ptr.address
-        end
-      rescue StandardError
-        nil
+        left.equal?(right)
       end
 
       # --- Type checks (any recognized engine node) ---

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: canon
 version: !ruby/object:Gem::Version
-  version: 0.3.84
+  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
@@ -44,28 +44,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.9.340
+        version: 1.9.341
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.9.340
+        version: 1.9.341
 - !ruby/object:Gem::Dependency
   name: moxml
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.5.125
+        version: 0.5.126
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.5.125
+        version: 0.5.126
 - !ruby/object:Gem::Dependency
   name: paint
   requirement: !ruby/object:Gem::Requirement