canon 0.2.12 → 0.3.0

data/lib/canon/diff_formatter/by_line/html_formatter.rb

@@ -10,7 +10,7 @@ module Canon
       class HtmlFormatter < BaseFormatter
         attr_reader :html_version
 
-        # rubocop:disable Metrics/ParameterLists
+        # rubocop:disable-next Metrics/ParameterLists
         def initialize(use_color: true, context_lines: 3,
                        diff_grouping_lines: nil, visualization_map: nil,
                        html_version: :html4, show_diffs: :all, differences: [],
@@ -25,7 +25,6 @@ module Canon
                 character_visualization: character_visualization)
           @html_version = html_version
         end
-        # rubocop:enable Metrics/ParameterLists
 
         # Format DOM-guided HTML diff
         #

data/lib/canon/diff_formatter/by_line_formatter.rb

@@ -9,7 +9,7 @@ module Canon
     # Receives preprocessed document strings from the DiffFormatter facade
     # and delegates to format-specific ByLine formatters (XML, HTML, JSON, YAML).
     class ByLineFormatter
-      # rubocop:disable Metrics/ParameterLists
+      # rubocop:disable-next Metrics/ParameterLists
       def initialize(use_color:, visualization_map:, context_lines:,
                      diff_grouping_lines:, show_diffs:, character_visualization:,
                      legacy_terminal:, diff_mode:)
@@ -22,7 +22,6 @@ module Canon
         @legacy_terminal = legacy_terminal
         @diff_mode = diff_mode
       end
-      # rubocop:enable Metrics/ParameterLists
 
       # Format a line-by-line diff between two documents.
       #

data/lib/canon/diff_formatter/diff_detail_formatter/node_utils.rb

@@ -226,7 +226,7 @@ module Canon
           end
 
           def serialize_backend_node_compact(node)
-            if XmlBackend.nokogiri? && node.is_a?(Nokogiri::XML::Node)
+            if defined?(Nokogiri) && node.is_a?(Nokogiri::XML::Node)
               serialize_nokogiri_node_compact(node)
             elsif node.is_a?(Canon::Xml::Node)
               serialize_node_compact(node)
@@ -256,7 +256,7 @@ module Canon
           end
 
           def serialize_backend_open_tag(node)
-            if XmlBackend.nokogiri? && node.is_a?(Nokogiri::XML::Element)
+            if defined?(Nokogiri) && node.is_a?(Nokogiri::XML::Element)
               tag = node.name.to_s
               attrs = node.attribute_nodes.map do |a|
                 " #{a.name}=\"#{CGI.escapeHTML(a.value.to_s)}\""

data/lib/canon/diff_formatter/theme.rb

@@ -125,11 +125,11 @@ module Canon
           },
           added: {
             marker: { color: :green, bg: nil, bold: false },
-            content: { color: :green,       bg: nil, bold: false,
+            content: { color: :green, bg: nil, bold: false,
                        underline: false, strikethrough: false },
           },
           changed: {
-            marker: { color: :yellow,       bg: nil, bold: true },
+            marker: { color: :yellow, bg: nil, bold: true },
             content_old: { color: :bright_red,   bg: nil, bold: false,
                            underline: false, strikethrough: true },
             content_new: { color: :bright_green, bg: nil, bold: false,

data/lib/canon/diff_formatter.rb

@@ -311,11 +311,10 @@ module Canon
       # In by-line mode with both docs present, always use by-line diff
       if @mode == :by_line && doc1 && doc2
         doc1, doc2 = apply_display_preprocessing(doc1, doc2, format)
-        # rubocop:disable Layout/HashAlignment
+        # rubocop:disable-next Layout/HashAlignment
         return by_line_formatter.format(doc1, doc2, format: format,
                                                   html_version: html_version,
                                                   differences: differences)
-        # rubocop:enable Layout/HashAlignment
       end
 
       # In pretty_diff mode, always use text-LCS diff (bypasses DiffNodeMapper).
@@ -343,11 +342,10 @@ module Canon
           doc1, doc2 = apply_display_preprocessing(doc1, doc2,
                                                    format)
         end
-        # rubocop:disable Layout/HashAlignment
+        # rubocop:disable-next Layout/HashAlignment
         by_line_formatter.format(doc1, doc2, format: format,
                                                html_version: html_version,
                                                differences: differences)
-        # rubocop:enable Layout/HashAlignment
       when :pretty_diff
         d1, d2 = if doc1 && doc2
                    apply_display_preprocessing(doc1, doc2,

data/lib/canon/html/nokogiri_support.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Canon
+  module Html
+    # Nokogiri node utilities for the HTML pipeline.
+    #
+    # HTML parsing is Nokogiri's job on every CRuby runtime regardless of
+    # the XML engine (XmlBackend): moxml has no HTML adapter and leptris no
+    # HTML parser. Under Opal Nokogiri is unavailable and these helpers
+    # degrade the same way the moxml backend always did (false / nil /
+    # raise), which keeps HTML comparison unsupported there.
+    module NokogiriSupport
+      class << self
+        # Whether the node is a document fragment (any variant).
+        def document_fragment?(node)
+          return false unless defined?(Nokogiri)
+
+          node.is_a?(Nokogiri::XML::DocumentFragment) ||
+            node.is_a?(Nokogiri::HTML4::DocumentFragment) ||
+            node.is_a?(Nokogiri::HTML5::DocumentFragment)
+        end
+
+        # Whether the node is an HTML document (any variant).
+        def html_document?(node)
+          return false unless defined?(Nokogiri)
+
+          node.is_a?(Nokogiri::HTML::Document) ||
+            node.is_a?(Nokogiri::HTML4::Document) ||
+            node.is_a?(Nokogiri::HTML5::Document)
+        end
+
+        # Detect HTML version from a Nokogiri node.
+        # Returns :html5 or :html4. Defaults to :html5 for non-Nokogiri nodes.
+        def html_version_from_node(node)
+          return :html5 unless defined?(Nokogiri)
+
+          if node.is_a?(Nokogiri::HTML5::Document) ||
+              node.is_a?(Nokogiri::HTML5::DocumentFragment)
+            :html5
+          elsif node.is_a?(Nokogiri::HTML4::Document) ||
+              node.is_a?(Nokogiri::HTML4::DocumentFragment)
+            :html4
+          else
+            :html5
+          end
+        end
+
+        # Parse an HTML string into an XML fragment for the XML comparator.
+        def xml_fragment(html_string)
+          unless defined?(Nokogiri)
+            raise Canon::Error,
+                  "HTML fragment parsing requires Nokogiri"
+          end
+
+          Nokogiri::XML.fragment(html_string)
+        end
+      end
+    end
+  end
+end

data/lib/canon/html.rb

@@ -6,5 +6,6 @@ module Canon
   # Children are autoloaded — never `require_relative` them.
   module Html
     autoload :DataModel, "canon/html/data_model"
+    autoload :NokogiriSupport, "canon/html/nokogiri_support"
   end
 end

data/lib/canon/pretty_printer/xml.rb

@@ -11,7 +11,12 @@ module Canon
       end
 
       def format(xml_string)
-        if Canon::XmlBackend.nokogiri?
+        # Output parity: pretty-printed bytes are canon's product. The
+        # moxml serializer cannot yet match Nokogiri's output (empty
+        # element expansion, declaration placement, tab indent), so the
+        # Nokogiri pipeline is used whenever available — the moxml branch
+        # is the Opal fallback.
+        if defined?(Nokogiri)
           nokogiri_format(xml_string)
         else
           moxml_format(xml_string)

data/lib/canon/pretty_printer/xml_normalized.rb

@@ -153,12 +153,12 @@ module Canon
       # @return [String] Serialized XML, one node per line, with content
       #   whitespace visualized at line boundaries
       def format(xml_string)
-        doc = if Canon::XmlBackend.moxml?
-                Canon::XmlParsing.parse(xml_string)
-              elsif @html_mode
-                Nokogiri::HTML5(xml_string)
+        # Output parity: see PrettyPrinter::Xml — the Nokogiri pipeline
+        # produces canon's byte-stable output; moxml is the Opal fallback.
+        doc = if defined?(Nokogiri)
+                @html_mode ? Nokogiri::HTML5(xml_string) : Nokogiri::XML(xml_string)
               else
-                Nokogiri::XML(xml_string)
+                Canon::XmlParsing.parse(xml_string)
               end
         lines = []
 

data/lib/canon/tree_diff/core/tree_node.rb

@@ -356,10 +356,11 @@ module Canon
         end
 
         # True when the supplied source node is a Nokogiri node that
-        # exposes an XPath via +path+.  Nokogiri is an optional
-        # backend so the constant is guarded.
+        # exposes an XPath via +path+. Nokogiri nodes arrive from user
+        # input under any engine, so this is a type check; the constant
+        # is guarded for Opal.
         def nokogiri_source?(node)
-          return false unless Canon::XmlBackend.nokogiri?
+          return false unless defined?(Nokogiri)
 
           node.is_a?(Nokogiri::XML::Node)
         end

data/lib/canon/tree_diff/operation_converter_helpers/post_processor.rb

@@ -66,7 +66,7 @@ module Canon
           return false unless node
           return false unless Canon::Comparison::NodeInspector.element_node?(node)
 
-          Canon::XmlBackend.nokogiri? ? node.is_a?(Nokogiri::XML::Node) : false
+          Canon::XmlParsing.xml_node?(node) && defined?(Nokogiri) && node.is_a?(Nokogiri::XML::Node)
         end
         private_class_method :backend_element?
 

data/lib/canon/version.rb

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

data/lib/canon/xml/data_model.rb

@@ -159,7 +159,7 @@ preserve_whitespace: false)
         when Nokogiri::XML::Element
           build_element_node(nokogiri_node,
                              preserve_whitespace: preserve_whitespace)
-        when Nokogiri::XML::Text
+        when Nokogiri::XML::Text, Nokogiri::XML::CDATA
           build_text_node(nokogiri_node,
                           preserve_whitespace: preserve_whitespace)
         when Nokogiri::XML::Comment
@@ -222,7 +222,10 @@ preserve_whitespace: false)
       end
 
       def self.build_attribute_nodes(nokogiri_element, element)
-        nokogiri_element.attributes.each_value do |attr|
+        # attribute_nodes, not the attributes hash: the hash is keyed by
+        # local name and collapses e.g. attr / a:attr / b:attr into one
+        # entry, losing namespaced attributes (W3C C14N ex 3.3).
+        nokogiri_element.attribute_nodes.each do |attr|
           attr_node = Nodes::AttributeNode.new(
             name: attr.name,
             value: attr.value,
@@ -259,26 +262,183 @@ preserve_whitespace: false)
 
       def self.from_moxml_xml(xml_string, preserve_whitespace:)
         doc = Canon::XmlParsing.parse(xml_string)
-        build_from_moxml(doc, preserve_whitespace: preserve_whitespace)
+        check_moxml_relative_namespace_uris(doc)
+        result = build_from_moxml(doc, preserve_whitespace: preserve_whitespace)
+        # Canon owns this document's full lifecycle: the canon tree holds
+        # no engine references once built, so release the native tree now
+        # instead of waiting for the GC finalizer (moxml#134; no-op on
+        # GC-managed adapters).
+        doc.free
+        result
+      end
+
+      def self.check_moxml_relative_namespace_uris(node)
+        case node
+        when Moxml::Element
+          node.namespace_definitions.each do |ns|
+            href = ns.uri
+            next if href.nil? || href.empty?
+            if relative_uri?(href)
+              raise Canon::Error,
+                    "Relative namespace URI not allowed: #{href}"
+            end
+          end
+          node.children.each { |child| check_moxml_relative_namespace_uris(child) }
+        when Moxml::Document
+          node.children.each { |child| check_moxml_relative_namespace_uris(child) }
+        end
       end
 
       def self.build_from_moxml(moxml_doc, preserve_whitespace: false)
         root = Nodes::RootNode.new
 
         if moxml_doc.is_a?(Moxml::Document) && moxml_doc.root
-          root.add_child(build_moxml_element_node(moxml_doc.root,
-                                                  preserve_whitespace: preserve_whitespace))
+          element = build_moxml_subtree_from_records(moxml_doc.root,
+                                                     preserve_whitespace: preserve_whitespace)
+          root.add_child(element) if element
+          moxml_doc.children.each do |child|
+            next if child.equal?(moxml_doc.root)
+            next if child.is_a?(Moxml::Doctype)
+
+            node = build_moxml_node(child,
+                                    preserve_whitespace: preserve_whitespace)
+            root.add_child(node) if node
+          end
+        else
+          moxml_doc.children.each do |child|
+            next if child.is_a?(Moxml::Doctype)
+
+            node = build_moxml_node(child,
+                                    preserve_whitespace: preserve_whitespace)
+            root.add_child(node) if node
+          end
         end
 
         root
       end
 
-      def self.build_moxml_node(node, preserve_whitespace: false)
+      # Document path: build the root subtree from materialize records —
+      # one flattened record stream (moxml#132/#138) instead of a wrapper
+      # walk, so conversion costs no Moxml::Node allocation per node.
+      #
+      # Records arrive post-order (children before parents): completed
+      # nodes stack up with their depth, and an element record adopts
+      # every completed node deeper than itself. Each element's OWN
+      # namespace declarations ride an identity-keyed stash; afterwards
+      # assign_moxml_namespace_scopes expands them to in-scope scopes
+      # with the same first-wins/xml-prebound semantics as the Nokogiri
+      # collector.
+      def self.build_moxml_subtree_from_records(moxml_element,
+preserve_whitespace: false)
+        frames = []
+        own_namespaces = {}.compare_by_identity
+
+        moxml_element.materialize do |record|
+          # 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 below also covers;
+          # one integer compare per record keeps those working.
+          next if record[:depth].zero? && record[:kind] != :element
+
+          node = case record[:kind]
+                 when :element
+                   build_moxml_element_from_record(record, frames,
+                                                   own_namespaces)
+                 when :text, :cdata
+                   build_moxml_text_from_record(record, preserve_whitespace)
+                 when :comment
+                   Nodes::CommentNode.new(value: record[:text])
+                 when :processing_instruction
+                   Nodes::ProcessingInstructionNode.new(
+                     target: record[:qname],
+                     data: record[:text] || "",
+                   )
+                 end
+
+          frames.push([record[:depth], node]) if node
+        end
+
+        top = frames.last
+        return nil unless top
+
+        element = top[1]
+        assign_moxml_namespace_scopes(element,
+                                      { "xml" => "http://www.w3.org/XML/1998/namespace" },
+                                      own_namespaces)
+        element
+      end
+
+      def self.build_moxml_element_from_record(record, frames, own_namespaces)
+        element = Nodes::ElementNode.new(
+          name: record[:qname],
+          namespace_uri: record[:namespace_uri],
+          prefix: record[:prefix],
+        )
+
+        seen = {}
+        record[:attributes].each do |name, value, namespace_uri, prefix|
+          key = [name, namespace_uri]
+          next if seen.key?(key)
+
+          seen[key] = true
+          element.add_attribute(Nodes::AttributeNode.new(
+                                  name: name,
+                                  value: value,
+                                  namespace_uri: namespace_uri,
+                                  prefix: prefix,
+                                ))
+        end
+
+        # Adopt completed children (they stack in reverse: unshift
+        # restores document order).
+        children = []
+        children.unshift(frames.pop[1]) while frames.any? && frames.last[0] > record[:depth]
+        children.each { |child| element.add_child(child) }
+
+        own_namespaces[element] = record[:namespaces]
+        element
+      end
+
+      # Text records inside a document subtree always have an element
+      # parent (only the document element sits at depth 0), so the
+      # whitespace-only skip rule matches the wrapper path exactly.
+      def self.build_moxml_text_from_record(record, preserve_whitespace)
+        content = record[:text].to_s
+        return nil if !preserve_whitespace && content.strip.empty?
+
+        Nodes::TextNode.new(value: content, original: content)
+      end
+
+      # Expand each element's own declarations to in-scope bindings:
+      # the element's declarations shadow inherited ones; xml is
+      # prebound. Scope flows down the canon tree — no engine calls.
+      def self.assign_moxml_namespace_scopes(element, inherited, own_namespaces)
+        scope = inherited.dup
+        own_namespaces[element].to_a.each do |prefix, uri|
+          scope[prefix || ""] = uri
+        end
+
+        scope.each do |prefix, uri|
+          element.add_namespace(Nodes::NamespaceNode.new(
+                                  prefix: prefix,
+                                  uri: uri,
+                                ))
+        end
+
+        element.children.each do |child|
+          assign_moxml_namespace_scopes(child, scope, own_namespaces) if child.is_a?(Nodes::ElementNode)
+        end
+      end
+
+      def self.build_moxml_node(node, preserve_whitespace: false,
+inherited_namespaces: nil)
         case node
         when Moxml::Element
           build_moxml_element_node(node,
-                                   preserve_whitespace: preserve_whitespace)
-        when Moxml::Text
+                                   preserve_whitespace: preserve_whitespace,
+                                   inherited_namespaces: inherited_namespaces)
+        when Moxml::Text, Moxml::Cdata
           build_moxml_text_node(node, preserve_whitespace: preserve_whitespace)
         when Moxml::Comment
           build_moxml_comment_node(node)
@@ -288,7 +448,8 @@ preserve_whitespace: false)
       end
 
       def self.build_moxml_element_node(moxml_element,
-preserve_whitespace: false)
+preserve_whitespace: false,
+inherited_namespaces: nil)
         ns = moxml_element.namespace
         element = Nodes::ElementNode.new(
           name: moxml_element.name,
@@ -296,44 +457,56 @@ preserve_whitespace: false)
           prefix: ns&.prefix,
         )
 
-        build_moxml_namespace_nodes(moxml_element, element)
+        scope = moxml_namespace_scope(moxml_element, inherited_namespaces)
+        scope.each do |prefix, uri|
+          element.add_namespace(Nodes::NamespaceNode.new(
+                                  prefix: prefix,
+                                  uri: uri,
+                                ))
+        end
+
         build_moxml_attribute_nodes(moxml_element, element)
 
         moxml_element.children.each do |child|
           node = build_moxml_node(child,
-                                  preserve_whitespace: preserve_whitespace)
+                                  preserve_whitespace: preserve_whitespace,
+                                  inherited_namespaces: scope)
           element.add_child(node) if node
         end
 
         element
       end
 
-      def self.build_moxml_namespace_nodes(moxml_element, element)
-        moxml_element.namespace_definitions.each do |ns|
-          ns_node = Nodes::NamespaceNode.new(
-            prefix: ns.prefix || "",
-            uri: ns.uri,
-          )
-          element.add_namespace(ns_node)
-        end
-
-        unless element.namespace_nodes.any? do |n|
-          n.prefix == "xml"
-        end
-          element.add_namespace(Nodes::NamespaceNode.new(
-                                  prefix: "xml",
-                                  uri: "http://www.w3.org/XML/1998/namespace",
-                                ))
+      # In-scope namespace bindings: the element's own declarations
+      # shadow inherited ones, xml is prebound. The scope is passed down
+      # the recursion so each element pays one declaration fetch instead
+      # of an ancestor walk through the adapter layer (the Nokogiri
+      # collector walks ancestors because those calls are cheap there).
+      def self.moxml_namespace_scope(moxml_element, inherited)
+        scope = inherited ? inherited.dup : { "xml" => "http://www.w3.org/XML/1998/namespace" }
+        moxml_element.namespace_definitions.each do |decl|
+          scope[decl.prefix || ""] = decl.uri
         end
+        scope
       end
 
       def self.build_moxml_attribute_nodes(moxml_element, element)
+        seen = {}
         moxml_element.attributes.each do |attr|
-          attr_node = Nodes::AttributeNode.new(
-            name: attr.name,
-            value: attr.value,
-          )
-          element.add_attribute(attr_node)
+          # Duplicate attribute names are invalid XML; engines expose
+          # them differently (libxml2 lists repeats, libleptris dedups
+          # last-wins). Canon follows the Nokogiri presentation contract:
+          # first occurrence wins, keyed by name + namespace.
+          key = [attr.name, attr.namespace&.uri]
+          next if seen.key?(key)
+
+          seen[key] = true
+          element.add_attribute(Nodes::AttributeNode.new(
+                                  name: attr.name,
+                                  value: attr.value,
+                                  namespace_uri: attr.namespace&.uri,
+                                  prefix: attr.namespace&.prefix,
+                                ))
         end
       end
 
@@ -354,7 +527,7 @@ preserve_whitespace: false)
       def self.build_moxml_pi_node(moxml_pi)
         Nodes::ProcessingInstructionNode.new(
           target: moxml_pi.target,
-          data: moxml_pi.data,
+          data: moxml_pi.content,
         )
       end
     end

data/lib/canon/xml/processor.rb

@@ -130,10 +130,18 @@ module Canon
         # Add line break before PI if it's outside document element
         output << "\n" if parent_element.nil? && output.length.positive?
 
+        # C14N renders "<?target S data?>". Both CRuby engines now
+        # consume the leading whitespace run after the PI target
+        # (leptris-ruby#85), but the canonical writer owns the rule —
+        # it must not depend on engine pre-processing (and the pure-Ruby
+        # adapters don't). Trailing whitespace and internal newlines are
+        # preserved (W3C ex 3.1 keeps them).
+        data = node.data.to_s.sub(/\A[ \t\r\n]+/, "")
+
         output << "<?" << node.target
 
-        unless node.data.empty?
-          output << " " << node.data
+        unless data.empty?
+          output << " " << data
         end
 
         output << "?>"

data/lib/canon/xml/sax/moxml_driver.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Canon
+  module Xml
+    module Sax
+      # moxml SAX driver (rexml adapter under Opal). moxml splits namespace
+      # declarations out of the attribute hash and reports them separately,
+      # so this driver recombines them as inline "xmlns"/"xmlns:prefix"
+      # pairs to match the builder's engine-neutral protocol.
+      class MoxmlDriver < Moxml::SAX::Handler
+        def initialize(builder)
+          super()
+          @builder = builder
+        end
+
+        def parse(xml_string)
+          Canon::XmlParsing.moxml_context.sax_parse(xml_string, self)
+        end
+
+        def on_start_element(name, attributes = {}, namespaces = {})
+          attrs = attributes.to_a
+          namespaces.each do |prefix, uri|
+            attrs << if prefix.nil? || prefix.empty?
+                       ["xmlns", uri]
+                     else
+                       ["xmlns:#{prefix}", uri]
+                     end
+          end
+          @builder.start_element(name, attrs)
+        end
+
+        def on_end_element(name)
+          @builder.end_element(name)
+        end
+
+        def on_characters(text)
+          @builder.characters(text)
+        end
+
+        def on_cdata(text)
+          @builder.cdata(text)
+        end
+
+        def on_comment(text)
+          @builder.comment(text)
+        end
+
+        def on_processing_instruction(name, content)
+          @builder.processing_instruction(name, content || "")
+        end
+
+        def on_error(error)
+          @builder.error(error.message.to_s)
+        end
+      end
+    end
+  end
+end

data/lib/canon/xml/sax/nokogiri_driver.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "nokogiri" unless RUBY_ENGINE == "opal"
+
+module Canon
+  module Xml
+    module Sax
+      # Nokogiri SAX driver: the builder's protocol already matches
+      # Nokogiri::XML::SAX::Document, so every event is a pass-through.
+      class NokogiriDriver < Nokogiri::XML::SAX::Document
+        def initialize(builder)
+          super()
+          @builder = builder
+        end
+
+        def parse(xml_string)
+          Nokogiri::XML::SAX::Parser.new(self).parse(xml_string)
+        end
+
+        def error(string)
+          @builder.error(string)
+        end
+
+        def warning(string)
+          @builder.warning(string)
+        end
+
+        def start_element(name, attrs = [])
+          @builder.start_element(name, attrs)
+        end
+
+        def end_element(name)
+          @builder.end_element(name)
+        end
+
+        def characters(string)
+          @builder.characters(string)
+        end
+
+        def cdata_block(string)
+          @builder.cdata(string)
+        end
+
+        def comment(string)
+          @builder.comment(string)
+        end
+
+        def processing_instruction(name, content)
+          @builder.processing_instruction(name, content)
+        end
+      end
+    end
+  end
+end