canon 0.3.6 → 0.3.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 04012234db38cae77206ba33f856aca1262a0ad0111e7d233d5b814e90c22187
-  data.tar.gz: 3700758afcb5619f59ba7e2f896963bc63695d534f60af7d922dfce8c26076ec
+  metadata.gz: 7e6a28999cdd57c9fb642e7f334546ef2ebe4802057481ef9c9bcf93252b8590
+  data.tar.gz: 072ae76310a6f936b81a73f2305bac61cb0b1100f36509724f67c5a763fb718f
 SHA512:
-  metadata.gz: c6452b462325e65c3f38f31438656b1cf60790646413314d8e835f6a27f78026bc10de2474065627b26a602962c424fd6858e1bc97ed3bca43e8a009b1779291
-  data.tar.gz: 749b78e282b4b2c7d440f9dff4a2361ee8d7742afcdab54b490bf836ae9417afc5f677e2039143020a6e50eceaf12d42950372c7a5f62dfcd335223243962fef
+  metadata.gz: '049a48f66a243b20993f677e8789eff4b08ed72f0b22fa9288453d3806718f2a9f7414c7774e51de30290d19d5b012419f50eb8cdf75762944b4f5c28ed6d54b'
+  data.tar.gz: b57afbf6f649b27c8a4833742673f2ae7dea0a4608610795d8ae38c76398ed66e833d4a5d29f832e45ecb1f5ced1e23125afc6b383f45ffc545b6257aca986bb

data/lib/canon/version.rb

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

data/lib/canon/xml/data_model.rb

@@ -205,9 +205,15 @@ 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)
-        check_moxml_relative_namespace_uris(doc)
+        # 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)
         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
@@ -216,23 +222,6 @@ inherited_namespaces: nil)
         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
         skip_types = [Moxml::Doctype]
@@ -260,32 +249,52 @@ preserve_whitespace: false)
         frames = []
         own_namespaces = {}.compare_by_identity
 
-        moxml_element.materialize do |record|
+        # materialize_fields: the zero-allocation hot path (moxml#143).
+        # Flat reused buffers — attributes stride 4, namespaces stride
+        # 2 — valid only inside the block, so the element builder
+        # copies them into pairs before returning.
+        moxml_element.materialize_fields do |kind, qname, prefix, namespace_uri, namespaces, attributes, text, depth|
           # 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 also covers; one
           # integer compare per record keeps those working.
-          next if record[:depth].zero? && record[:kind] != :element
+          next if depth.zero? && kind != :element
+
+          # Relative-namespace validation rides the stream (the
+          # namespaces buffer is the element's own declarations) — no
+          # separate wrapper-tree walk per parse.
+          if kind == :element
+            i = 1
+            while i < namespaces.size
+              href = namespaces[i]
+              if !href.nil? && !href.empty? && relative_uri?(href)
+                raise Canon::Error,
+                      "Relative namespace URI not allowed: #{href}"
+              end
+              i += 2
+            end
+          end
 
-          node = case record[:kind]
+          node = case kind
                  when :element
-                   build_moxml_element_from_record(record, frames,
-                                                   own_namespaces)
+                   build_moxml_element_from_fields(
+                     qname, prefix, namespace_uri, namespaces, attributes,
+                     depth, frames, own_namespaces
+                   )
                  when :text, :cdata
-                   content = record[:text].to_s
+                   content = text.to_s
                    TreeBuilder::DEFAULT.text(content,
                                              keep: WhitespacePolicy.keep_dom_text?(
                                                content, preserve_whitespace: preserve_whitespace
                                              ))
                  when :comment
-                   TreeBuilder::DEFAULT.comment(record[:text])
+                   TreeBuilder::DEFAULT.comment(text)
                  when :processing_instruction
-                   TreeBuilder::DEFAULT.processing_instruction(record[:qname],
-                                                               record[:text] || "")
+                   TreeBuilder::DEFAULT.processing_instruction(qname, text || "")
                  end
 
-          frames.push([record[:depth], node]) if node
+          frames.push([depth, node]) if node
         end
 
         top = frames.last
@@ -295,21 +304,24 @@ preserve_whitespace: false)
         top[1]
       end
 
-      def self.build_moxml_element_from_record(record, frames, own_namespaces)
+      def self.build_moxml_element_from_fields(qname, prefix, namespace_uri,
+                                               namespaces, attributes, depth,
+                                               frames, own_namespaces)
         element = TreeBuilder::DEFAULT.element(
-          name: record[:qname],
-          prefix: record[:prefix],
-          namespace_uri: record[:namespace_uri],
-          attributes: record[:attributes],
+          name: qname,
+          prefix: prefix,
+          namespace_uri: namespace_uri,
+          attributes: attributes.each_slice(4).to_a,
         )
 
         # Adopt completed children: they pop in reverse order; reversing
         # once is O(n) (unshift per child would be O(n^2) on wide trees).
         children = []
-        children << frames.pop[1] while frames.any? && frames.last[0] > record[:depth]
+        children << frames.pop[1] while frames.any? && frames.last[0] > depth
         children.reverse_each { |child| element.add_child(child) }
 
-        own_namespaces[element] = record[:namespaces]
+        # Copy the declarations out of the reused buffer.
+        own_namespaces[element] = namespaces.each_slice(2).to_a
         element
       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_backend.rb

@@ -9,16 +9,13 @@ 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). Both engines
+  # follow the resolved adapter: SAX since leptris#625/#99 were fixed,
+  # DOM since moxml#143's materialize_fields stream (zero-allocation
+  # flat buffers) made the conversion competitive. Conformance parity
+  # is complete (engine_parity_spec 12/12). CANON_XML_BACKEND forces
+  # either engine; the CI performance gate is the standing referee.
   #
   # HTML stays on Nokogiri on CRuby (Canon::Html::NokogiriSupport) and the
   # pretty-printers keep the Nokogiri pipeline — pretty-printed bytes are
@@ -63,7 +60,11 @@ module Canon
       def detect
         return :moxml if RUBY_ENGINE == "opal"
 
-        :nokogiri
+        # Both engines now run leptris: SAX since leptris#625/#99
+        # (CI-gated), DOM since moxml#143's zero-allocation
+        # materialize_fields stream made the conversion competitive.
+        # The CI performance gate is the standing referee.
+        XmlParsing.moxml_adapter_name == :nokogiri ? :nokogiri : :moxml
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: canon
 version: !ruby/object:Gem::Version
-  version: 0.3.6
+  version: 0.3.8
 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