canon 0.2.11 → 0.3.0

data/lib/canon/xml/data_model.rb

@@ -2,16 +2,6 @@
 
 require "nokogiri" unless RUBY_ENGINE == "opal"
 require "set"
-require_relative "../data_model"
-require_relative "../xml_backend"
-require_relative "../xml_parsing"
-require_relative "nodes/root_node"
-require_relative "nodes/element_node"
-require_relative "nodes/namespace_node"
-require_relative "nodes/attribute_node"
-require_relative "nodes/text_node"
-require_relative "nodes/comment_node"
-require_relative "nodes/processing_instruction_node"
 
 module Canon
   module Xml
@@ -169,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
@@ -232,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,
@@ -269,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)
@@ -298,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,
@@ -306,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
 
@@ -364,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/line_range_mapper.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "../pretty_printer/xml"
-
 module Canon
   module Xml
     # Maps DOM elements to line ranges in pretty-printed XML

data/lib/canon/xml/nodes/attribute_node.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "../node"
-
 module Canon
   module Xml
     module Nodes

data/lib/canon/xml/nodes/comment_node.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "../node"
-
 module Canon
   module Xml
     module Nodes

data/lib/canon/xml/nodes/element_node.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "../node"
-
 module Canon
   module Xml
     module Nodes

data/lib/canon/xml/nodes/namespace_node.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "../node"
-
 module Canon
   module Xml
     module Nodes

data/lib/canon/xml/nodes/processing_instruction_node.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "../node"
-
 module Canon
   module Xml
     module Nodes

data/lib/canon/xml/nodes/root_node.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "../node"
-
 module Canon
   module Xml
     module Nodes

data/lib/canon/xml/nodes/text_node.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "../node"
-
 module Canon
   module Xml
     module Nodes

data/lib/canon/xml/nodes.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Canon
+  module Xml
+    # XPath data model node types. All nodes inherit from
+    # {Canon::Xml::Node}. Children are autoloaded — never
+    # `require_relative` them.
+    module Nodes
+      autoload :AttributeNode, "canon/xml/nodes/attribute_node"
+      autoload :CommentNode, "canon/xml/nodes/comment_node"
+      autoload :ElementNode, "canon/xml/nodes/element_node"
+      autoload :NamespaceNode, "canon/xml/nodes/namespace_node"
+      autoload :ProcessingInstructionNode,
+               "canon/xml/nodes/processing_instruction_node"
+      autoload :RootNode, "canon/xml/nodes/root_node"
+      autoload :TextNode, "canon/xml/nodes/text_node"
+    end
+  end
+end

data/lib/canon/xml/processor.rb

@@ -1,10 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "character_encoder"
-require_relative "namespace_handler"
-require_relative "attribute_handler"
-require_relative "xml_base_handler"
-
 module Canon
   module Xml
     # C14N 1.1 processor
@@ -135,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

data/lib/canon/xml/sax.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Canon
+  module Xml
+    # SAX engine selection and driving for the data-model builder.
+    #
+    # The builder (SaxBuilder) owns tree construction and speaks a single
+    # engine-neutral event protocol (Nokogiri-shaped: qname + attribute
+    # pairs with xmlns entries inline). Each driver adapts one engine's SAX
+    # API to that protocol. OCP: a new engine is a new driver plus one line
+    # here; the builder never changes.
+    #
+    # Engine choice: leptris SAX outperforms Nokogiri SAX (1.10x min-of-N
+    # on canon's builder, 53KB doc) through moxml 0.5.12's
+    # interest-proportional callbacks — BUT the batch-attribute transport
+    # reads uninitialized memory at certain buffer offsets, corrupting the
+    # first N attributes of an element (leptris-ruby#95). Until that is
+    # fixed, CRuby keeps the Nokogiri driver; flipping is the one-line
+    # change below.
+    module Sax
+      autoload :NokogiriDriver, "canon/xml/sax/nokogiri_driver"
+      autoload :MoxmlDriver, "canon/xml/sax/moxml_driver"
+
+      class << self
+        # Drive `builder` with the runtime's SAX engine.
+        def parse(xml_string, builder)
+          if RUBY_ENGINE == "opal"
+            MoxmlDriver.new(builder).parse(xml_string)
+          else
+            NokogiriDriver.new(builder).parse(xml_string)
+          end
+          nil
+        end
+      end
+    end
+  end
+end