canon 0.3.5 → 0.3.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8912c851a2e2b0e250fcae120cda428d7705f9c6262b57ec7fe1218aaf186229
-  data.tar.gz: 98a7b6c64818395e18c1de7b8918255368b6b4bf8766ecaa567b5502c7c084b4
+  metadata.gz: b1ce43e1e3cb461ac60687f0e9cdd815916f85cd40a87c8d70f0a071c56b1c04
+  data.tar.gz: 3eff7d2db22b5fe57674e64aa5f6b5ebb1d4b82d6f3afde5c45444f57f2c8e55
 SHA512:
-  metadata.gz: 2fee687e2469d42193c4f58a294179dc8332aca3fefca5c3ad476cdc061e40c2370d2183790b20c1e43ae83b420ae78567cf7f27114c128f21b0ab8d76be46fe
-  data.tar.gz: 61a58938d48f48ce066c93b09e734bc62a05cfccec1c7fea80ecdb4de97663e589940108f89f0d8f947737d096ca9c21b9f41edbe51569da5bcc2ad5c990fd0f
+  metadata.gz: 7428800d8125c5173b61338ce8929f1c3700684ccba7cae25847a1d5cc533c99eea946a46cd5f567841b978597670e26d546849b853b11bd88cb6f72c023c647
+  data.tar.gz: 77cdd82d177e2d476aece71503a70487ee31f6593f30d401e748199944fbc9230756c5bba08b73411dae62621c5d08c16c1fdb4ec427a5e96f0d43955cea0414

data/lib/canon/html/data_model.rb

@@ -80,7 +80,7 @@ module Canon
       # fragment — a TreeBuilder walk like the XML extractors, with the
       # HTML whitespace policy and xmlns-free attributes.
       def self.build_from_nokogiri(nokogiri_doc)
-        builder = Canon::Xml::TreeBuilder.new
+        builder = Canon::Xml::TreeBuilder::DEFAULT
         root = Canon::Xml::Nodes::RootNode.new
         skip_types = defined?(Nokogiri) ? [Nokogiri::XML::DTD] : []
 

data/lib/canon/version.rb

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

data/lib/canon/xml/data_model.rb

@@ -134,8 +134,6 @@ module Canon
       # node kinds, document ordering) live in TreeBuilder and
       # WhitespacePolicy — one dialect, three feeds.
 
-      TREE_BUILDER = TreeBuilder.new
-
       # -- Nokogiri walk: top-down, scope flows down the recursion --
 
       def self.build_from_nokogiri(nokogiri_doc, preserve_whitespace: false)
@@ -145,13 +143,13 @@ module Canon
         if nokogiri_doc.is_a?(Nokogiri::XML::Document) && nokogiri_doc.root
           root.add_child(walk_nokogiri(nokogiri_doc.root,
                                        preserve_whitespace: preserve_whitespace))
-          TREE_BUILDER.add_document_children(root, nokogiri_doc.children,
-                                             nokogiri_doc.root, skip_types) do |child|
+          TreeBuilder::DEFAULT.add_document_children(root, nokogiri_doc.children,
+                                                     nokogiri_doc.root, skip_types) do |child|
             walk_nokogiri(child, preserve_whitespace: preserve_whitespace)
           end
         else
-          TREE_BUILDER.add_document_children(root, nokogiri_doc.children,
-                                             nil, skip_types) do |child|
+          TreeBuilder::DEFAULT.add_document_children(root, nokogiri_doc.children,
+                                                     nil, skip_types) do |child|
             walk_nokogiri(child, preserve_whitespace: preserve_whitespace)
           end
         end
@@ -163,11 +161,11 @@ module Canon
 inherited_namespaces: nil)
         case node
         when Nokogiri::XML::Element
-          scope = TREE_BUILDER.merge_namespace_scope(
+          scope = TreeBuilder::DEFAULT.merge_namespace_scope(
             inherited_namespaces,
             node.namespace_definitions.map { |ns| [ns.prefix, ns.href] },
           )
-          element = TREE_BUILDER.element(
+          element = TreeBuilder::DEFAULT.element(
             name: node.name,
             prefix: node.namespace&.prefix,
             namespace_uri: node.namespace&.href,
@@ -184,17 +182,17 @@ inherited_namespaces: nil)
           end
           element
         when Nokogiri::XML::Text, Nokogiri::XML::CDATA
-          TREE_BUILDER.text(node.content,
-                            keep: WhitespacePolicy.keep_dom_text?(
-                              node.content,
-                              preserve_whitespace: preserve_whitespace,
-                              element_parent: node.parent.is_a?(Nokogiri::XML::Element),
-                            ),
-                            original: node.to_xml)
+          TreeBuilder::DEFAULT.text(node.content,
+                                    keep: WhitespacePolicy.keep_dom_text?(
+                                      node.content,
+                                      preserve_whitespace: preserve_whitespace,
+                                      element_parent: node.parent.is_a?(Nokogiri::XML::Element),
+                                    ),
+                                    original: node.to_xml)
         when Nokogiri::XML::Comment
-          TREE_BUILDER.comment(node.content)
+          TreeBuilder::DEFAULT.comment(node.content)
         when Nokogiri::XML::ProcessingInstruction
-          TREE_BUILDER.processing_instruction(node.name, node.content)
+          TreeBuilder::DEFAULT.processing_instruction(node.name, node.content)
         end
       end
 
@@ -207,9 +205,16 @@ inherited_namespaces: nil)
       # scopes cannot flow down during the stream).
 
       def self.from_moxml_xml(xml_string, preserve_whitespace:)
-        doc = Canon::XmlParsing.moxml_context.parse(xml_string, readonly: true)
+        # strict: false keeps the Nokogiri-engine contract — malformed
+        # input yields a recovered document plus diagnostics instead of
+        # an exception (moxml 0.5.15 defaults strict to true; issue
+        # #147 rides recover errors on Document#parse_errors).
+        doc = Canon::XmlParsing.moxml_context.parse(xml_string,
+                                                    readonly: true,
+                                                    strict: false)
         check_moxml_relative_namespace_uris(doc)
         result = build_from_moxml(doc, preserve_whitespace: preserve_whitespace)
+        result.parse_errors = doc.parse_errors if doc.parse_errors.any?
         # 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
@@ -243,13 +248,13 @@ inherited_namespaces: nil)
           element = build_moxml_subtree_from_records(moxml_doc.root,
                                                      preserve_whitespace: preserve_whitespace)
           root.add_child(element) if element
-          TREE_BUILDER.add_document_children(root, moxml_doc.children,
-                                             moxml_doc.root, skip_types) do |child|
+          TreeBuilder::DEFAULT.add_document_children(root, moxml_doc.children,
+                                                     moxml_doc.root, skip_types) do |child|
             walk_moxml(child, preserve_whitespace: preserve_whitespace)
           end
         else
-          TREE_BUILDER.add_document_children(root, moxml_doc.children,
-                                             nil, skip_types) do |child|
+          TreeBuilder::DEFAULT.add_document_children(root, moxml_doc.children,
+                                                     nil, skip_types) do |child|
             walk_moxml(child, preserve_whitespace: preserve_whitespace)
           end
         end
@@ -276,15 +281,15 @@ preserve_whitespace: false)
                                                    own_namespaces)
                  when :text, :cdata
                    content = record[:text].to_s
-                   TREE_BUILDER.text(content,
-                                     keep: WhitespacePolicy.keep_dom_text?(
-                                       content, preserve_whitespace: preserve_whitespace
-                                     ))
+                   TreeBuilder::DEFAULT.text(content,
+                                             keep: WhitespacePolicy.keep_dom_text?(
+                                               content, preserve_whitespace: preserve_whitespace
+                                             ))
                  when :comment
-                   TREE_BUILDER.comment(record[:text])
+                   TreeBuilder::DEFAULT.comment(record[:text])
                  when :processing_instruction
-                   TREE_BUILDER.processing_instruction(record[:qname],
-                                                       record[:text] || "")
+                   TreeBuilder::DEFAULT.processing_instruction(record[:qname],
+                                                               record[:text] || "")
                  end
 
           frames.push([record[:depth], node]) if node
@@ -298,7 +303,7 @@ preserve_whitespace: false)
       end
 
       def self.build_moxml_element_from_record(record, frames, own_namespaces)
-        element = TREE_BUILDER.element(
+        element = TreeBuilder::DEFAULT.element(
           name: record[:qname],
           prefix: record[:prefix],
           namespace_uri: record[:namespace_uri],
@@ -316,9 +321,9 @@ preserve_whitespace: false)
       end
 
       def self.assign_moxml_namespace_scopes(element, inherited, own_namespaces)
-        scope = TREE_BUILDER.merge_namespace_scope(inherited,
-                                                   own_namespaces[element].to_a)
-        TREE_BUILDER.attach_namespace_scope(element, scope)
+        scope = TreeBuilder::DEFAULT.merge_namespace_scope(inherited,
+                                                           own_namespaces[element].to_a)
+        TreeBuilder::DEFAULT.attach_namespace_scope(element, scope)
 
         element.children.each do |child|
           assign_moxml_namespace_scopes(child, scope, own_namespaces) if child.is_a?(Nodes::ElementNode)
@@ -331,11 +336,11 @@ preserve_whitespace: false)
 inherited_namespaces: nil)
         case node
         when Moxml::Element
-          scope = TREE_BUILDER.merge_namespace_scope(
+          scope = TreeBuilder::DEFAULT.merge_namespace_scope(
             inherited_namespaces,
             node.namespace_definitions.map { |ns| [ns.prefix, ns.uri] },
           )
-          element = TREE_BUILDER.element(
+          element = TreeBuilder::DEFAULT.element(
             name: node.name,
             prefix: node.namespace&.prefix,
             namespace_uri: node.namespace&.uri,
@@ -352,16 +357,16 @@ inherited_namespaces: nil)
           end
           element
         when Moxml::Text, Moxml::Cdata
-          TREE_BUILDER.text(node.content,
-                            keep: WhitespacePolicy.keep_dom_text?(
-                              node.content,
-                              preserve_whitespace: preserve_whitespace,
-                              element_parent: node.parent.is_a?(Moxml::Element),
-                            ))
+          TreeBuilder::DEFAULT.text(node.content,
+                                    keep: WhitespacePolicy.keep_dom_text?(
+                                      node.content,
+                                      preserve_whitespace: preserve_whitespace,
+                                      element_parent: node.parent.is_a?(Moxml::Element),
+                                    ))
         when Moxml::Comment
-          TREE_BUILDER.comment(node.content)
+          TreeBuilder::DEFAULT.comment(node.content)
         when Moxml::ProcessingInstruction
-          TREE_BUILDER.processing_instruction(node.target, node.content)
+          TreeBuilder::DEFAULT.processing_instruction(node.target, node.content)
         end
       end
     end

data/lib/canon/xml/sax.rb

@@ -10,16 +10,13 @@ module Canon
     # API to that protocol. OCP: a new engine is a new driver plus one line
     # here; the builder never changes.
     #
-    # Engine choice: the leptris SAX flip is armed but blocked twice over.
-    # The batch-attribute corruption (leptris-ruby#95) is answered by a
-    # correctness-first path in leptris 1.9.36 — attributes are correct,
-    # but that path DROPS namespace declarations from SAX events
-    # entirely (raw `["<root xmlns:a=.../>", []]` — xmlns pairs vanish),
-    # blinding namespace comparison. Until xmlns reporting is restored
-    # (and then the fast path returns with the C fix), CRuby keeps the
-    # Nokogiri driver; the flip is the one-line change below. With
-    # leptris absent (moxml resolving nokogiri) the driver calls Nokogiri
-    # directly — the wrapper layer only adds overhead there.
+    # Engine choice follows the resolved adapter — independent of the
+    # DOM engine default: leptris SAX (corruption leptris#625 and the
+    # missing xmlns reporting leptris-ruby#99 both fixed) builds canon
+    # trees at parity with or faster than Nokogiri SAX, CI-gated. The
+    # DOM engine default stays Nokogiri until the record conversion
+    # passes the same gate (see XmlBackend). With leptris absent the
+    # driver calls Nokogiri directly.
     module Sax
       autoload :NokogiriDriver, "canon/xml/sax/nokogiri_driver"
       autoload :MoxmlDriver, "canon/xml/sax/moxml_driver"
@@ -27,7 +24,7 @@ module Canon
       class << self
         # Drive `builder` with the runtime's SAX engine.
         def parse(xml_string, builder)
-          if RUBY_ENGINE == "opal"
+          if RUBY_ENGINE == "opal" || Canon::XmlParsing.moxml_adapter_name != :nokogiri
             MoxmlDriver.new(builder).parse(xml_string)
           else
             NokogiriDriver.new(builder).parse(xml_string)

data/lib/canon/xml/sax_builder.rb

@@ -9,6 +9,11 @@ module Canon
     # selects the driver. Much faster than DOM parsing + conversion —
     # no intermediate engine DOM tree, no traversal conversion pass.
     #
+    # Construction goes through TreeBuilder like every other feed:
+    # this class owns only what is SAX-specific — qname parsing, xmlns
+    # separation, character-reference decoding, adjacency combining,
+    # the namespace stack, and document-level reordering.
+    #
     # Usage:
     #   root = SaxBuilder.parse(xml_string, preserve_whitespace: false)
     #   # root is a Canon::Xml::Nodes::RootNode
@@ -123,26 +128,23 @@ strip_doctype: false)
           end
         end
 
-        # Push new namespace scope with declarations
+        # Push new namespace scope with declarations (own shadows
+        # inherited — the same merge the TreeBuilder scope kernel applies)
         new_scope = @namespace_stack.last.merge(ns_hash)
         @namespace_stack.push(new_scope)
 
-        # Find namespace URI from current scope
-        ns_uri = new_scope[prefix.to_s]
-
-        # Create element node
-        element = Nodes::ElementNode.new(
+        element = TreeBuilder::DEFAULT.element(
           name: local_name,
-          namespace_uri: ns_uri,
           prefix: prefix,
+          namespace_uri: new_scope[prefix.to_s],
+          namespace_scope: new_scope,
+          attributes: regular_attrs.map do |attr_name, attr_value|
+            attr_prefix, attr_local = parse_qname(attr_name)
+            attr_ns_uri = attr_prefix ? new_scope[attr_prefix] : nil
+            [attr_local, decode_character_references(attr_value || ""), attr_ns_uri, attr_prefix]
+          end,
         )
 
-        # Add namespace nodes from current scope
-        add_namespace_nodes(element, new_scope)
-
-        # Build and add attribute nodes (excluding xmlns declarations)
-        add_attribute_nodes(element, regular_attrs)
-
         parent.add_child(element)
         @stack.push(element)
       end
@@ -206,8 +208,9 @@ strip_doctype: false)
                                                       preserve_whitespace: @preserve_whitespace,
                                                       element_parent: parent.node_type == :element)
 
-        text = Nodes::TextNode.new(value: decoded_string, original: raw_string)
-        parent.add_child(text)
+        parent.add_child(
+          TreeBuilder::DEFAULT.text(decoded_string, keep: true, original: raw_string),
+        )
       end
       private :append_text
 
@@ -215,9 +218,7 @@ strip_doctype: false)
       #
       # @param string [String] Comment content
       def comment(string)
-        parent = @stack.last
-        comment_node = Nodes::CommentNode.new(value: string)
-        parent.add_child(comment_node)
+        @stack.last.add_child(TreeBuilder::DEFAULT.comment(string))
       end
 
       # Called for processing instructions
@@ -225,10 +226,9 @@ strip_doctype: false)
       # @param name [String] PI target
       # @param content [String] PI content
       def processing_instruction(name, content)
-        parent = @stack.last
-        pi = Nodes::ProcessingInstructionNode.new(target: name,
-                                                  data: content || "")
-        parent.add_child(pi)
+        @stack.last.add_child(
+          TreeBuilder::DEFAULT.processing_instruction(name, content || ""),
+        )
       end
 
       # Return the built tree
@@ -314,44 +314,7 @@ strip_doctype: false)
         [ns_decls, regular_attrs]
       end
 
-      # Add namespace nodes to element
-      #
-      # @param element [Nodes::ElementNode] Element to add namespaces to
-      # @param scope [Hash] Current namespace scope
-      def add_namespace_nodes(element, scope)
-        scope.each do |prefix, uri|
-          ns_node = Nodes::NamespaceNode.new(prefix: prefix, uri: uri)
-          element.add_namespace(ns_node)
-        end
-      end
-
-      # Add attribute nodes to element
-      #
-      # @param element [Nodes::ElementNode] Element to add attributes to
-      # @param attrs [Array] Array of [name, value] pairs
-      def add_attribute_nodes(element, attrs)
-        attrs.each do |attr_name, attr_value|
-          attr_prefix, attr_local = parse_qname(attr_name)
-
-          # Find namespace for attribute (if prefixed)
-          attr_ns_uri = attr_prefix ? @namespace_stack.last[attr_prefix] : nil
-
-          # Decode numeric character references (e.g., & → &)
-          # Nokogiri SAX leaves these as-is, but we need them decoded for C14N
-          decoded_value = decode_character_references(attr_value || "")
-
-          attr_node = Nodes::AttributeNode.new(
-            name: attr_local,
-            value: decoded_value,
-            namespace_uri: attr_ns_uri,
-            prefix: attr_prefix,
-          )
-          element.add_attribute(attr_node)
-        end
-      end
-
-      # Decode numeric character references in a string
-      # Handles both &#decimal; and &#xhex; forms
+      # Decode numeric character references (e.g., & → &)
       #
       # @param value [String] String potentially containing character references
       # @return [String] String with character references decoded

data/lib/canon/xml/tree_builder.rb

@@ -16,6 +16,9 @@ module Canon
     # repeats, libleptris deduplicates), so the builder resolves them
     # once — first occurrence wins.
     class TreeBuilder
+      # Stateless module: one shared instance serves every feed.
+      DEFAULT = new
+
       NO_ATTRIBUTES = [].freeze
       XML_NAMESPACE_PREFIX = "xml"
       XML_NAMESPACE_URI = "http://www.w3.org/XML/1998/namespace"
@@ -54,12 +57,16 @@ module Canon
         )
         attach_namespace_scope(element, namespace_scope) if namespace_scope
 
-        seen = {}
-        attributes.each do |attr_name, value, attr_namespace_uri, attr_prefix|
-          key = [attr_name, attr_namespace_uri]
-          next if seen.key?(key)
+        # Duplicate (name, namespace) pairs are invalid XML — first
+        # occurrence wins. Attributes per element are few, so a pairwise
+        # scan beats a per-element seen-hash on allocation (this is the
+        # hot SAX path).
+        attributes.each_with_index do |(attr_name, value, attr_namespace_uri, attr_prefix), index|
+          duplicate = attributes[0...index].any? do |prior_name, _v, prior_ns, _p|
+            prior_name == attr_name && prior_ns == attr_namespace_uri
+          end
+          next if duplicate
 
-          seen[key] = true
           element.add_attribute(Nodes::AttributeNode.new(
                                   name: attr_name,
                                   value: value,

data/lib/canon/xml_backend.rb

@@ -9,16 +9,14 @@ module Canon
   # - HTML support — always Nokogiri on CRuby; moxml has no HTML adapter and
   #   leptris no HTML parser (see Canon::Html::NokogiriSupport).
   #
-  # SSOT: moxml owns adapter preference (Moxml::Config prefers leptris when
-  # installed and capable; see XmlParsing.moxml_adapter_name). Canon's
-  # default engine is Nokogiri on CRuby until leptris WINS somewhere
-  # measurably: conformance parity is complete (engine_parity_spec 12/12),
-  # but the leptris SAX driver is blocked by a data-corruption bug
-  # (leptris-ruby#95) and the record-based conversion runs ~0.55x Nokogiri
-  # (CI performance gate: -42..45% on from_xml) pending lighter record
-  # emission upstream. Flipping the default is the one-line change in
-  # #detect; CANON_XML_BACKEND=moxml opts in today. Under Opal the engine
-  # is moxml (rexml adapter).
+  # SSOT: moxml owns adapter preference (Moxml::Config prefers leptris
+  # when installed; see XmlParsing.moxml_adapter_name). The SAX engine
+  # follows the resolved adapter — leptris (correct since leptris#625
+  # and leptris-ruby#99; CI perf-gated). The DOM engine stays Nokogiri
+  # until the record conversion passes the same gate (moxml#143's fix
+  # landed; still -40%/-37% from_xml on the CI runner). Conformance
+  # parity is complete (engine_parity_spec 12/12, zero pendings).
+  # CANON_XML_BACKEND=moxml opts into the leptris DOM engine today.
   #
   # HTML stays on Nokogiri on CRuby (Canon::Html::NokogiriSupport) and the
   # pretty-printers keep the Nokogiri pipeline — pretty-printed bytes are
@@ -63,6 +61,11 @@ module Canon
       def detect
         return :moxml if RUBY_ENGINE == "opal"
 
+        # The SAX engine flipped to leptris (leptris#625/#99 fixed,
+        # CI-gated — see Canon::Xml::Sax), but the DOM conversion still
+        # trails Nokogiri on the CI runner (-40%/-37% from_xml after
+        # moxml#143's emission fix landed). Nokogiri stays the DOM
+        # default until that gate passes; flipping is this one line.
         :nokogiri
       end
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: canon
 version: !ruby/object:Gem::Version
-  version: 0.3.5
+  version: 0.3.7
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-08-29 00:00:00.000000000 Z
+date: 2026-08-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: diff-lcs