canon 0.3.98 → 0.3.100

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 07c9d8c96426b670ad088e3b96e662b45283c4868e99c27a5afb5a6ecb537780
-  data.tar.gz: 5e8bc5ee7aa5b1e1b75b158d1afc68f3035e1c58bcd3da4624fdebbbbc83b4a6
+  metadata.gz: 47ebab684f05c7445139ea4b0ed5133ab734c1d16918f3dadc055b3ddbc5692f
+  data.tar.gz: d80c1ae4a66f43ffb92c3eb8a14ebca8e2bcd2eb373130797a71e7f79a748d9a
 SHA512:
-  metadata.gz: 813b81bd8fe090e71c9729d18326e864b0af54129e422ae4d624676ed8e191f6b2b278e5dab5e00c1827fccaed9658e5bd85a9ef6ac908c9e0cc4ff97d33839e
-  data.tar.gz: 6819b9252b0e6f27efec816241b1444d1ff92456562996ddc0c89a8f07b04eb41d48302025fda8776581437fb793da24db3ed21fec2b1589522c0680739bd99c
+  metadata.gz: 3555261e4b8280e6967bd63900dec75bb19d2225ff2da16748136ee7ddcb076fcee4f04b6502801afd92d344ef67b578c692868e63c3c181dff8008efc472986
+  data.tar.gz: 590b8d12f49526bd3965d78f2000b4d7e64452e0b026547285d0762f6fb0565311ffb00c595aaac85813c90658656842aca1a8970e25f88f20e4f6d09e6ddeb8

data/lib/canon/comparison/html_comparator.rb

@@ -295,8 +295,8 @@ module Canon
                              Canon::Xml::C14n.canonicalize(html_string,
                                                            with_comments: false)
                            when :format
-                             # Pretty format
-                             Canon.format(html_string, :html)
+                             # Engine single-line structural normalizer
+                             Canon::Html::DataModel.engine_html_format(html_string)
                            else
                              # :none or unrecognized
                              html_string
@@ -375,8 +375,8 @@ module Canon
                           Canon::Xml::C14n.canonicalize(node,
                                                         with_comments: false)
                         when :format
-                          # Pretty format the HTML
-                          Canon.format(node, :html)
+                          # Engine single-line structural normalizer
+                          Canon::Html::DataModel.engine_html_format(node)
                         else
                           # :none, :rendered or unrecognized - use as-is
                           node

data/lib/canon/comparison/html_parser.rb

@@ -60,29 +60,10 @@ module Canon
         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).
+        # parsing and build a Canon tree. Canon::Html::DataModel owns
+        # the conversion (the single home for HTML→Canon-tree building).
         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
+          Canon::Html::DataModel.engine_fragment(html)
         end
 
         # Engine HTML fragments are served by adapters with an engine

data/lib/canon/html/data_model.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-Canon::NokogiriLoader.require!("HTML support")
-
 module Canon
   module Html
     # Builds XPath data model from HTML
@@ -10,58 +8,104 @@ module Canon
     class DataModel < Canon::DataModel
       # Build XPath data model from HTML string
       #
+      # The engine lane: moxml Context#parse_html_fragment (WHATWG
+      # fragment parsing) → Canon tree. The +version:+ parameter is
+      # accepted for API compatibility — the engine serves every input
+      # through one WHATWG parse (the #118 html4/html5 unification).
+      # Full documents keep their head content at the fragment top
+      # level (the in-body rules ignore the html/body start tags but
+      # preserve every other node); the former Nokogiri body-extraction
+      # dropped head content entirely.
+      #
       # @param html_string [String] HTML content to parse
-      # @param version [Symbol] HTML version (:html4 or :html5)
+      # @param version [Symbol] accepted for compatibility; unused
       # @return [Canon::Xml::Nodes::RootNode] Root of the data model tree
+      # rubocop:disable-next Lint/UnusedMethodArgument -- API compatibility
       def self.from_html(html_string, version: :html4)
-        # Detect if this is a full document (has <html> tag) or fragment
-        # Full documents should use document parser to preserve structure
-        # Fragments should use fragment parser to avoid adding implicit wrappers
-        is_full_document = html_string.match?(%r{<html[\s>]}i)
-
-        # Parse with Nokogiri using appropriate parser
-        doc = if is_full_document
-                # CRITICAL FIX: For full HTML documents, parse as document first
-                # and extract the body element. This avoids Nokogiri::HTML.fragment()
-                # incorrectly moving head elements (like meta) to the body.
-                # Parse as full document to get proper structure
-                full_doc = if version == :html5
-                             Nokogiri::HTML5(html_string)
-                           else
-                             Nokogiri::HTML4(html_string)
-                           end
-                # Extract body element and create fragment from it
-                body = full_doc.at_css("body")
-                if body
-                  # Create a fragment and copy body children to it
-                  # This preserves the body structure without head elements
-                  frag = if version == :html5
-                           Nokogiri::HTML5::DocumentFragment.new(full_doc)
-                         else
-                           Nokogiri::HTML4::DocumentFragment.new(full_doc)
-                         end
-                  body.children.each do |child|
-                    frag.add_child(child.dup)
-                  end
-                  frag
-                elsif version == :html5
-                  # No body found, fall back to fragment parsing
-                  Nokogiri::HTML5.fragment(html_string)
-                else
-                  Nokogiri::HTML4.fragment(html_string)
-                end
-              elsif version == :html5
-                # Fragment - use fragment parser to avoid implicit wrappers
-                Nokogiri::HTML5.fragment(html_string)
-              else
-                Nokogiri::HTML4.fragment(html_string)
-              end
-
-        # HTML doesn't have strict namespace requirements like XML,
-        # so skip the relative namespace URI check
-
-        # Convert to XPath data model (reuse XML infrastructure)
-        build_from_nokogiri(doc)
+        engine_fragment(html_string)
+      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), 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 self.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
+
+      # Elements whose inner whitespace is always significant.
+      WHITESPACE_PRESERVING = %w[pre textarea script style].freeze
+
+      # Deterministic single-line engine formatting for the :format
+      # string preprocessor: parse + strip whitespace-only text that
+      # is insignificant between block siblings + re-serialize — a
+      # pure function of the parsed tree, so equivalent inputs
+      # converge to identical bytes regardless of source indentation.
+      # Inline-significant whitespace (between two inline siblings,
+      # inside whitespace-preserving elements) survives.
+      def self.engine_html_format(html)
+        doc = engine_html_parse(html)
+        strip_insignificant_whitespace!(doc.root)
+        doc.to_html
+      end
+
+      # Parse a full HTML document through the engine WHATWG lane.
+      def self.engine_html_parse(html)
+        Canon::XmlParsing.moxml_context.parse_html(html)
+      end
+
+      def self.strip_insignificant_whitespace!(node)
+        return unless node.is_a?(Moxml::Element)
+
+        preserve_parent = WHITESPACE_PRESERVING.include?(node.name)
+        node.children.to_a.each do |child|
+          if child.is_a?(Moxml::Text)
+            next unless child.content.strip.empty?
+            next if preserve_parent
+            next if inline_significant?(child, node)
+
+            child.remove
+          elsif child.is_a?(Moxml::Element)
+            strip_insignificant_whitespace!(child)
+          end
+        end
+      end
+
+      # Whitespace between two inline siblings (or anchored by content)
+      # is significant — the #112 rule. Edge or block-anchored runs are
+      # formatting artifacts.
+      def self.inline_significant?(text, parent)
+        siblings = parent.children.to_a
+        idx = siblings.index(text)
+        prev = siblings[0...idx].reverse_each.find { |s| !whitespace_only?(s) }
+        nxt = siblings[(idx + 1)..].find { |s| !whitespace_only?(s) }
+        inline_node?(prev) && inline_node?(nxt)
+      end
+
+      def self.whitespace_only?(node)
+        node.is_a?(Moxml::Text) && node.content.strip.empty?
+      end
+
+      def self.inline_node?(node)
+        !node.nil? && node.is_a?(Moxml::Element) &&
+          Canon::Comparison::WhitespaceSensitivity::INLINE_ELEMENTS.include?(node.name)
       end
 
       # Alias for compatibility

data/lib/canon/pretty_printer/html.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-Canon::NokogiriLoader.require!("HTML pretty-printing")
 require "stringio"
 
 module Canon
@@ -37,7 +36,14 @@ module Canon
       end
 
       def format(html_string)
-        return format_fixture_ready(html_string) if @fixture_ready
+        if @fixture_ready
+          # The fixture-ready display mode is the one Nokogiri lane
+          # left (libxml FORMAT|AS_XHTML save flags — moxml#390 filed
+          # for an engine XHTML mode); everything else is engine-
+          # served.
+          Canon::NokogiriLoader.require!("HTML fixture-ready display")
+          return format_fixture_ready(html_string)
+        end
 
         if xhtml?(html_string)
           format_as_xhtml(html_string)
@@ -73,13 +79,15 @@ module Canon
         expand_non_void_self_closing(out)
       end
 
+      # Engine serialization with the #354 indent knobs — the engine's
+      # own nested layout (a deliberate byte change vs the Nokogiri
+      # lane: synthesis shape differs, e.g. no empty <head></head>).
       def format_as_html(html_string)
-        doc = Nokogiri::HTML5(html_string)
-
+        doc = Canon::Html::DataModel.engine_html_parse(html_string)
         if @indent_type == "tab"
-          doc.to_html(indent: 1, indent_text: "\t", encoding: "UTF-8")
+          doc.to_html(indent: 1, indent_text: "\t")
         else
-          doc.to_html(indent: @indent, encoding: "UTF-8")
+          doc.to_html(indent: @indent)
         end
       end
 

data/lib/canon/tree_diff/adapters/html_adapter.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-Canon::NokogiriLoader.require!("HTML tree diffing")
-
 module Canon
   module TreeDiff
     module Adapters
@@ -46,17 +44,22 @@ module Canon
             return to_tree_from_canon_comment(node)
           end
 
-          # Fallback to Nokogiri (legacy support)
-          case node
-          when Nokogiri::HTML::Document, Nokogiri::HTML4::Document, Nokogiri::HTML5::Document
-            # Start from html element or root element
-            root = node.at_css("html") || node.root
-            root ? to_tree(root) : nil
-          when Nokogiri::HTML4::DocumentFragment, Nokogiri::HTML5::DocumentFragment, Nokogiri::XML::DocumentFragment
-            # For DocumentFragment, create a wrapper root node and add all fragment children
-            convert_fragment(node)
-          when Nokogiri::XML::Element
-            convert_element(node)
+          # Fallback to Nokogiri (legacy support for user-supplied
+          # nodes) — the Canon tree branches above run nokogiri-less.
+          if defined?(Nokogiri)
+            case node
+            when Nokogiri::HTML::Document, Nokogiri::HTML4::Document, Nokogiri::HTML5::Document
+              # Start from html element or root element
+              root = node.at_css("html") || node.root
+              root ? to_tree(root) : nil
+            when Nokogiri::HTML4::DocumentFragment, Nokogiri::HTML5::DocumentFragment, Nokogiri::XML::DocumentFragment
+              # For DocumentFragment, create a wrapper root node and add all fragment children
+              convert_fragment(node)
+            when Nokogiri::XML::Element
+              convert_element(node)
+            else
+              raise ArgumentError, "Unsupported node type: #{node.class}"
+            end
           else
             raise ArgumentError, "Unsupported node type: #{node.class}"
           end
@@ -68,7 +71,10 @@ module Canon
         # @param doc [Nokogiri::HTML::Document] Optional document to use
         # @return [Nokogiri::HTML::Document, Nokogiri::XML::Element]
         def from_tree(tree_node, doc = nil)
-          doc ||= Nokogiri::HTML::Document.new
+          unless doc
+            Canon::NokogiriLoader.require!("HTML tree reconstruction")
+            doc = Nokogiri::HTML::Document.new
+          end
 
           element = build_element(tree_node, doc)
 

data/lib/canon/validators/html_validator.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-Canon::NokogiriLoader.require!("HTML validation")
-
 module Canon
   module Validators
     # Validator for HTML input
@@ -44,27 +42,43 @@ module Canon
       # @param input [String] The XHTML string to validate
       # @raise [Canon::ValidationError] If XHTML is malformed
       # @return [void]
+      # XHTML is XML: the engine strict parse is the validator. The
+      # engine reports the failure position as a byte offset embedded
+      # in the error message; line/column derive from it.
       def self.validate_xhtml!(input)
-        Nokogiri::XML(input) do |config|
-          config.strict.nonet
-        end
-      rescue Nokogiri::XML::SyntaxError => e
-        location = extract_location(e)
+        Canon::XmlParsing.moxml_context.parse(input, strict: true)
+      rescue Moxml::ParseError => e
+        location = extract_engine_location(e, input)
         raise Canon::ValidationError.new(
           e.message.split("\n").first,
           format: :html,
           line: location[:line],
           column: location[:column],
-          details: "XHTML validation failed: #{extract_details(e)}",
+          details: "XHTML validation failed",
         )
       end
 
+      # Derive line/column from the engine error's "at byte N" offset.
+      def self.extract_engine_location(error, input)
+        byte = error.message[/at byte (\d+)/, 1].to_i
+        before = input.byteslice(0, byte) || ""
+        line = before.count("\n") + 1
+        last_nl = before.rindex("\n")
+        column = last_nl ? byte - (last_nl + 1) : byte
+        { line: line, column: column }
+      end
+
       # Validate HTML5 input
       #
       # @param input [String] The HTML5 string to validate
       # @raise [Canon::ValidationError] If HTML5 is malformed
       # @return [void]
       def self.validate_html5!(input)
+        # The HTML5 lint layer stays on Nokogiri/gumbo: the WHATWG
+        # parser never fails, so the engine has no parse-error token
+        # stream to classify (filed as leptris#1771 - the ask carries
+        # canon's acceptance protocol).
+        Canon::NokogiriLoader.require!("HTML5 validation (leptris#1771)")
         doc = Nokogiri::HTML5(input, max_errors: 100)
 
         # Check for parse errors
@@ -126,7 +140,7 @@ module Canon
 
       private_class_method :xhtml?, :validate_xhtml!, :validate_html5!,
                            :extract_details, :build_error_details,
-                           :doctype_or_warning?
+                           :doctype_or_warning?, :extract_engine_location
     end
   end
 end

data/lib/canon/version.rb

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

metadata

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