canon 0.3.85 → 0.3.87

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5dbb59b967dbaedab05c9dd8aa4186851ed71d055c44d89ecc23f2b8c8b92e96
-  data.tar.gz: c665d661c0e4984f112a82239406ddc349b6120be032849adf5de7db75331217
+  metadata.gz: 1f8305566ebcb025deeeaf3a7493373c378ba4b62ef6895c0689ecfbb9ce751e
+  data.tar.gz: 58ba3679b7819da639da058fe82f7c9d14bd005bb33a8851f06ed654bbea66fd
 SHA512:
-  metadata.gz: f75058359a37d053f57d6c6d86b27330a0553f925ba49755fa24d31fd248ff0c72b3393d539f75e9cd16fefd02813a590b2e9192031ba1a201cadf4dc7175bc1
-  data.tar.gz: e64b15e520378443018037c78931a7ce9172728ca7c25b8d0caad7acdc1bd6379682e63f8bd28bf88659eef99ec62d03dd86812db282ad936b92d5128d4031b0
+  metadata.gz: e65a54f2e878a4d1d073690bbda3fded68ca6e3546a8508f1623848905b0d28f1c32bffd88fe4eb4b573f084a566b98909ed4940ac23d8d0c65ccb7b4c7eae24
+  data.tar.gz: 11602849c2da9b9e53ac209b48c4b6faa8295f1e4c46f475f866449b7cfab83b7f04884caa8146dbdf8bbf4c7757bdcdabfbf33ef045f1ae067c712340c58bc1

data/CLAUDE.md

@@ -136,7 +136,7 @@ Canon is engine-agnostic across three seams (MECE — one concern per module):
 
 - `Canon::XmlBackend` — XML engine selection. The default follows moxml's resolved adapter: **leptris whenever it is installed** (parse ~1.6x, serialize ~3.8x vs Nokogiri), raw Nokogiri otherwise (wrapping Nokogiri in moxml buys nothing — the wrapper adds 2-3x overhead). `:moxml` under Opal. `CANON_XML_BACKEND=nokogiri|moxml` forces either engine.
 - `Canon::XmlParsing` — the only place that talks to engines for XML parse/serialize (moxml parses pass `readonly: true` — canon never mutates engine documents); node type queries answer for ANY recognized node (Nokogiri or moxml) by type, never by active backend — user-supplied Nokogiri nodes keep working under the moxml engine.
-- `Canon::Html::NokogiriSupport` — HTML is always Nokogiri on CRuby (moxml has no HTML adapter, leptris no HTML parser); independent of the XML engine.
+- `Canon::Html::NokogiriSupport` — HTML engine seam. **HTML comparison parses through the engine** since 0.3.86: `HtmlParser.parse` routes through moxml `Context#parse_html_fragment` (WHATWG fragment parsing, moxml#353 riding leptris) and builds a Canon tree via the materialize-records fast path — whitespace text nodes survive the parse unconditionally (HTML whitespace significance is the comparison profile's decision, #112/#137), and `parse_node` walks Canon trees directly. The Nokogiri HTML4/HTML5 fragment path remains for runtimes without an engine HTML adapter and for user-supplied Nokogiri nodes. Nokogiri still serves the other HTML lanes: the pretty-printer's HTML5/fixture-ready display modes, the canonical HTML formatters, and the semantic lane's `DataModel.from_html`. The fragment-records lane once delivered nil URIs for prefixed attributes (moxml#367, fixed in moxml 0.5.130 — the bulk read now falls back to the reserved-prefix table); the TreeBuilder keeps the one legal `xml`-prefix binding as standing defense.
 - `Canon::Xml::Sax` — SAX driver selection follows the resolved adapter: `MoxmlDriver` (leptris SAX — the comparison hot path, CI-gated in the split flip) under the leptris default, `NokogiriDriver` when the resolved adapter is nokogiri, `MoxmlDriver` under Opal. The builder (`SaxBuilder`) is engine-neutral.
 
 Engine parity is complete through libleptris 1.9.8 / leptris-ruby 1.9.33 / moxml 0.5.12: attribute-value normalization, prolog/epilog PIs and comments, DTD ATTLIST defaults off by default (opt-in via `ParseOptions::DTDATTR`), PI-data whitespace matching libxml2, materialize with namespace declarations and a root-subtree-only record contract (moxml#140), readonly parse, deterministic `Document#free` (wired into `from_moxml_xml` — moxml#134). Canon's moxml conversion is record-based (`build_from_moxml` consumes `materialize` records — no per-node wrapper allocation; ~0.55x the Nokogiri conversion). `spec/canon/xml/engine_parity_spec.rb` is fully green. Pretty-printing runs the leptris serializer through `PrettyPrinter::Xml#moxml_format` (byte parity via moxml#153/#155/#156; the #167 escaping race fixed in 0.5.28), with Nokogiri serving the fallback engine and Opal — pretty-printed bytes are canon's product, gated by the fixture-integrity suite and the CI performance gate.

data/README.adoc

@@ -18,7 +18,8 @@ Key features:
 * **Smart diff output**: By-line or by-object modes with syntax highlighting
 * **Fast native engines, zero mandatory C deps**:
 ** XML on https://github.com/leptris/leptris[libleptris] (via moxml) whenever
-   installed — Nokogiri otherwise and for HTML; both byte-compatible, engine
+   installed — Nokogiri otherwise; HTML comparison parses through the engine's
+   WHATWG fragment mode. Both byte-compatible, engine
    parity is spec-gated
 ** JSON on https://github.com/leptris/yeptris[libyeptris]' strict JSON surface
    (yeptris is a required gem — platform gems, zero compilation)
@@ -974,7 +975,9 @@ bundle exec rake performance:yaml
 Canon is engine-agnostic across its formats:
 
 * **XML**: libleptris via moxml whenever installed (parse, comparison, C14N,
-  pretty-printing); raw Nokogiri otherwise, and always Nokogiri for HTML.
+  pretty-printing); raw Nokogiri otherwise. HTML comparison parses through the
+  engine's WHATWG fragment mode (Canon trees, since 0.3.86); Nokogiri serves
+  HTML display modes, canonical formatters, and the semantic data model.
   `CANON_XML_BACKEND=nokogiri|moxml` forces either engine; parity between the
   two is spec-gated (`spec/canon/xml/engine_parity_spec.rb`).
 * **JSON**: yeptris' strict JSON surface when the native materializer is

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,39 @@ 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).
+        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.87"
 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.87
 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.341
+        version: 1.9.344
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.9.341
+        version: 1.9.344
 - !ruby/object:Gem::Dependency
   name: moxml
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.5.126
+        version: 0.5.130
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.5.126
+        version: 0.5.130
 - !ruby/object:Gem::Dependency
   name: paint
   requirement: !ruby/object:Gem::Requirement