canon 0.3.101 → 0.3.102

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dc66e03ef02db4a7cbb21e496076e2794027a7a52996eb797b90b697c77013ee
-  data.tar.gz: 6ab70c76adfd5fe466b0fa8a54f542097344f4726c34192b1f85f59a542b5752
+  metadata.gz: 7585f36fdd0ec2e32f315db6393c265e885eeff9e1ad705ad792bfcaeab3373d
+  data.tar.gz: f29aa48def44453b036c2dad82883839f19fc846b6e9e4d095f25da4b1a82eb8
 SHA512:
-  metadata.gz: efc3813ef9fa91be57ddd8fa537506cb938361e5c582f4bdc06ac272c7ffd299b92172c9bf41cf194f1a5d0c50237b82c8a01de801f652545dc51693ed96f08b
-  data.tar.gz: a867f50610cb84caa68f469561f9bd5cc15ec49cb4732543fd76efbca201787520245f013edca9454349e7a164be73f8f884bc503458f007f7ee7206bd5fedc9
+  metadata.gz: 6e05e33a87145653f7986ee62c076bd12ded0c95ff96dc74cc5ddf81c2bf48b5286d000715b9c7c32da4160c73f419b6fde7597e46f6e4fbf667324bf0a3d5ca
+  data.tar.gz: 3c11b01ca57ab4d737aafd8c159040934ab4e7c80d697d9be07c0b1e05bbfc9bbc7db6e1718a0bb54f1629cad16f5a0f4c80431846babceb236d74b63ec4226e

data/lib/canon/comparison/xml_comparator.rb

@@ -571,8 +571,8 @@ module Canon
             return Comparison::UNEQUAL_NODES_TYPES
           end
 
-          content1 = Canon::XmlParsing.xml_node?(n1) ? n1.content.to_s.strip : ""
-          content2 = Canon::XmlParsing.xml_node?(n2) ? n2.content.to_s.strip : ""
+          content1 = pi_content(n1)
+          content2 = pi_content(n2)
 
           if content1 == content2
             Comparison::EQUIVALENT
@@ -597,8 +597,60 @@ module Canon
             return Comparison::MISSING_NODE
           end
 
-          compare_nodes(root1, root2, opts, child_opts, diff_children,
-                        differences)
+          status = compare_nodes(root1, root2, opts, child_opts, diff_children,
+                                 differences)
+          compare_document_siblings(n1, n2, root1, root2, opts, differences)
+          status
+        end
+
+        # Document-level processing instructions and comments (the XML
+        # declaration never appears here - it is stripped at parse time
+        # by policy) participate in the comparison as an ordered sibling
+        # sequence around the root element.
+        def compare_document_siblings(n1, n2, root1, root2, opts, differences)
+          sibs1 = document_siblings(n1, root1)
+          sibs2 = document_siblings(n2, root2)
+
+          if sibs1.length != sibs2.length
+            add_difference(n1, n2, Comparison::MISSING_NODE,
+                           Comparison::MISSING_NODE, :text_content, opts,
+                           differences)
+            return
+          end
+
+          sibs1.zip(sibs2).each do |a, b|
+            next unless a.class != b.class ||
+              (a.is_a?(Canon::Xml::Nodes::ProcessingInstructionNode) &&
+               compare_processing_instruction_nodes(a, b, opts,
+                                                    differences) ==
+               Comparison::UNEQUAL_TEXT_CONTENTS) ||
+              (a.is_a?(Canon::Xml::Nodes::CommentNode) &&
+               compare_comment_nodes(a, b, opts, differences) ==
+               Comparison::UNEQUAL_COMMENTS)
+
+            add_difference(a, b, Comparison::UNEQUAL_NODES_TYPES,
+                           Comparison::UNEQUAL_NODES_TYPES, :text_content,
+                           opts, differences)
+          end
+        end
+
+        def document_siblings(doc, root)
+          return [] unless doc.respond_to?(:children)
+
+          doc.children.reject do |child|
+            child.equal?(root) || child.is_a?(Canon::Xml::Nodes::TextNode) ||
+              child.is_a?(Canon::Xml::Nodes::ElementNode)
+          end
+        end
+
+        # PI content lives in different accessors per node flavour:
+        # Canon::Xml::Nodes::ProcessingInstructionNode#data, engine
+        # processing instructions expose #content.
+        def pi_content(node)
+          return node.data.to_s if node.is_a?(Canon::Xml::Nodes::ProcessingInstructionNode)
+          return node.content.to_s if Canon::XmlParsing.xml_node?(node)
+
+          node.respond_to?(:data) ? node.data.to_s : ""
         end
 
         # Compare children of two nodes using semantic matching

data/lib/canon/pretty_printer/html.rb

@@ -98,29 +98,24 @@ module Canon
       # indentation; +AS_XHTML+ produces well-shaped output (void
       # elements self-closed, non-void paired); +NO_DECLARATION+
       # suppresses the +<?xml ...?>+ prefix.
-      # Engine parse + significance-aware strip + the #354 indent
-      # knobs + a canon-side void self-closing pass for the AS_XHTML
-      # contract (an engine XHTML mode is asked upstream as moxml#390;
-      # until then the shape transform is ours).
+      # Engine parse + significance-aware strip + the engine's
+      # XHTML serialization mode (moxml#390 delivered to_xhtml /
+      # to_html(xhtml: true)): void elements self-closed, non-void
+      # paired — the AS_XHTML contract, engine-served.
       def format_fixture_ready(html_string)
         doc = Canon::Html::DataModel.engine_html_parse(html_string)
         Canon::Html::DataModel.strip_insignificant_whitespace!(doc.root)
         html = if @indent_type == "tab"
-                 doc.to_html(indent: 1, indent_text: "\t")
+                 doc.to_xhtml(indent: 1, indent_text: "\t")
                else
-                 doc.to_html(indent: @indent)
+                 doc.to_xhtml(indent: @indent)
                end
-        self_closing_voids(html)
-      end
-
-      # AS_XHTML: void elements self-closed (<br/>, <img ... />).
-      def self_closing_voids(html)
-        html.gsub(%r{<([A-Za-z][A-Za-z0-9:-]*)((?:\s+[^<>"]*(?:"[^"]*"[^<>"]*)*)?)>}) do
-          name = ::Regexp.last_match(1)
-          next ::Regexp.last_match(0) unless HtmlVoidElements.void?(name)
-
-          "<#{name}#{::Regexp.last_match(2)}/>"
-        end
+        # The AS_XHTML contract pairs empty NON-void elements (<a .../>)
+        # for browser-safe pasting; the engine's to_xhtml self-closes
+        # every empty element. The existing transform restores the
+        # pairing for non-voids while voids stay self-closed — the
+        # #135 regression pins it.
+        expand_non_void_self_closing(html)
       end
 
       # Rewrite +<tag …/>+ into +<tag …></tag>+ for every element name

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

@@ -49,6 +49,12 @@ module Canon
             return to_tree_from_canon_processing_instruction(node)
           end
 
+          # Raw moxml documents/elements (the leptris engine's parse
+          # output) convert through the shared data model.
+          if defined?(Moxml) && node.is_a?(Moxml::Node)
+            return to_tree(Canon::Xml::DataModel.build_from_moxml(node))
+          end
+
           # Fallback to raw engine documents (legacy support). Nokogiri
           # is optional — under the moxml/leptris engine a raw Nokogiri
           # object cannot exist, so the constants stay unresolved.
@@ -200,10 +206,34 @@ module Canon
         # @param root_node [Canon::Xml::Nodes::RootNode] Root node
         # @return [Core::TreeNode, nil] Tree node for first child (document element)
         def to_tree_from_canon_root(root_node)
-          # Root node: process first child (document element)
+          # Root node: convert the document element, keeping
+          # document-level processing instructions / comments as
+          # siblings of it (before it first, then after) so they
+          # participate in the diff. The XML declaration never reaches
+          # here - it is stripped at parse time by policy.
           return nil if root_node.children.empty?
 
-          to_tree(root_node.children.first)
+          element_child = root_node.children.find do |child|
+            child.is_a?(Canon::Xml::Nodes::ElementNode)
+          end
+          return to_tree(root_node.children.first) if element_child.nil?
+
+          tree = to_tree(element_child)
+          seen_element = false
+          root_node.children.each do |child|
+            if child.equal?(element_child)
+              seen_element = true
+              next
+            end
+            next if child.is_a?(Canon::Xml::Nodes::ElementNode)
+            next if child.is_a?(Canon::Xml::Nodes::TextNode)
+
+            sibling = to_tree(child)
+            next if sibling.nil?
+
+            seen_element ? tree.children << sibling : tree.children.unshift(sibling)
+          end
+          tree
         end
 
         # Convert Canon::Xml::Nodes::ElementNode to TreeNode

data/lib/canon/validators/html_validator.rb

@@ -4,7 +4,9 @@ module Canon
   module Validators
     # Validator for HTML input
     #
-    # Validates HTML input (HTML4, HTML5, or XHTML) using Nokogiri.
+    # Validates HTML input (HTML4, HTML5, or XHTML) through the
+    # engine (strict XML parse for XHTML; the WHATWG parse-lint
+    # surface for HTML5 — leptris#1771).
     # Automatically detects the HTML type and applies appropriate validation.
     # Raises detailed ValidationError with line and column information
     # when malformed HTML is detected.
@@ -73,74 +75,44 @@ module Canon
       # @param input [String] The HTML5 string to validate
       # @raise [Canon::ValidationError] If HTML5 is malformed
       # @return [void]
+      # The HTML5 lint layer is engine-served (leptris#1771 delivered
+      # the §13.2.5 parse-error token stream: machine-readable code +
+      # line + column, RECOVER class). Engine-direct call — the
+      # documented seam exception (moxml's parse_html does not forward
+      # the collect_errors option yet; ask filed upstream).
       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)
+        doc = Leptris::XML.parse_html(input, mode: :whatwg,
+                                             collect_errors: true)
+        errors = doc.errors
+        return if errors.empty?
 
-        # Check for parse errors
-        return unless doc.errors.any?
-
-        # Find first significant error (level 2 = error, level 1 = warning)
-        # Filter out doctype warnings and other non-critical issues
-        significant_errors = doc.errors.select do |e|
-          e.level >= 2 && !doctype_or_warning?(e)
-        end
-
-        return if significant_errors.empty?
-
-        error = significant_errors.first
-        location = extract_location(error)
+        error = errors.first
         raise Canon::ValidationError.new(
-          error.message,
+          "[#{error.code}] #{error.message}",
           format: :html,
-          line: location[:line],
-          column: location[:column],
-          details: build_error_details(significant_errors),
+          line: error.line,
+          column: error.column,
+          details: build_error_details(errors),
         )
       end
 
-      # Extract additional error details
-      #
-      # @param error [Nokogiri::XML::SyntaxError] The syntax error
-      # @return [String, nil] Additional details about the error
-      def self.extract_details(_error)
-        nil
-      end
-
       # Build error details from multiple errors
       #
-      # @param errors [Array<Nokogiri::XML::SyntaxError>] Array of errors
+      # @param errors [Array<Leptris::XML::SyntaxError>] Array of errors
       # @return [String, nil] Combined error details
       def self.build_error_details(errors)
         return nil if errors.size <= 1
 
-        significant = errors.select { |e| e.level >= 2 }
-        return nil if significant.empty?
-
-        details = significant[1..3].map do |e|
-          loc = extract_location(e)
+        errors[1..3].map do |e|
           msg = e.message
-          msg += " (line #{loc[:line]})" if loc[:line]
+          msg += " (line #{e.line})" if e.respond_to?(:line) && e.line
           msg
-        end
-        details.join("; ")
-      end
-
-      # Check if error is a doctype or other non-critical warning
-      #
-      # @param error [Nokogiri::XML::SyntaxError] The error to check
-      # @return [Boolean] true if error is non-critical
-      def self.doctype_or_warning?(error)
-        error.message.match?(/doctype|Expected a doctype token/i)
+        end.join("; ")
       end
 
       private_class_method :xhtml?, :validate_xhtml!, :validate_html5!,
-                           :extract_details, :build_error_details,
-                           :doctype_or_warning?, :extract_engine_location
+                           :build_error_details,
+                           :extract_engine_location
     end
   end
 end

data/lib/canon/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: canon
 version: !ruby/object:Gem::Version
-  version: 0.3.101
+  version: 0.3.102
 platform: ruby
 authors:
 - Ribose Inc.