moxml 0.5.150 → 0.5.151

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 73b67b633933c60095bdeafd744a8f7a827066edf478245e9c2f49aadf1d75e6
-  data.tar.gz: 92320b13e8bb745cd5b650e85d4fa7b8397e082871a7c255cb61f637595c6048
+  metadata.gz: 2d27f78bba118e07aa9790336f2d7cbc0545e48217fcaf7ec93b222a170cc398
+  data.tar.gz: 6095220fc10e1f483d1ee3aed9b83c70ea1a61f0f304e00f4863a7fd52aca90c
 SHA512:
-  metadata.gz: c34b4df4cf09797b5a28ec909e0df41c970897676154fa1b66dc9ebbd18cdccb13408b83f5647c44d41cfda7ebcbf09571314d0bfe71b572a58dde972e78994b
-  data.tar.gz: d926c442a8b0dc0f9d159f27f42772a3af48358fbbd67d62d7cec1cdd51c609110def03466fa93c5b95b2eccfdaa7ab34e26c818b30b2651a996b9879c63d699
+  metadata.gz: 7fec02ca86ee8bbe73cd220363316147d35f94c010399c3b8163bc616460f0b03382c249befa262304e5182532c1e2abca6852707345b64edfab1c8c1d1661d9
+  data.tar.gz: 47f9e080e840c83a0b006d906bbf5e526d12324812c8d1a63c49cb12f2c3f0610078f98120a326080d6ba189bac7fe0131d82e628e58ad28878e1537bd1df96c

data/docs/_pages/ecosystem.adoc

@@ -21,7 +21,7 @@ validation target, never a stand-in.
 
 | `lutaml/lutaml-model` | — | 6213+ examples green on the released pair
 
-| `lutaml/canon` | — | 2573 examples, 0 failures locally; in CI the Windows leg fails one JSON-engine parity example (`yaml_engine_parity_spec.rb:123`, the resolved json gem's duplicate-key verdict) — unrelated to XML processing, owner-held in canon
+| `lutaml/canon` | — | 2573 examples, 0 failures (a transient Windows failure of one JSON-engine parity example — yeptris 0.6.34.2's undefined `MARSHAL_STRICT_DUP_KEYS` under json 3 — cleared with yeptris 0.6.34.3)
 
 | `metanorma/metanorma-standoc` | ghostscript | 627 examples green in CI on main (the boilerplate-fixture failure seen during the 04/05 validation was resolved by the 06 adapter fixes; a few local-only failures still need generated assets)
 
@@ -42,7 +42,7 @@ a declared, decided lane.
 |===
 | Consumer | Use | Disposition
 
-| canon | HTML5 parse-lint (`parse_html(collect_errors:)`) | **Facade capability shipped**: `Moxml::Context#parse_html` forwards `collect_errors` and `Document#parse_diagnostics` answers the §13.2.5 token stream with code/line/column. canon adopts it in canon#281, which is owner-held (moxml does not merge canon PRs).
+| canon | HTML5 parse-lint (`parse_html(collect_errors:)`) | **Retired** (canon#281, merged): `Moxml::Context#parse_html` forwards `collect_errors` and `Document#parse_diagnostics` answers the §13.2.5 token stream with code/line/column; canon rides the facade.
 
 | canon | c14n native delegation (`doc.native.c14n`) | **Decided lane**: canon owns the c14n reference implementation and byte-probes the engine against its Ruby path; it is the backend behind moxml's own native delegation.
 

data/lib/moxml/adapter/base.rb

@@ -580,6 +580,13 @@ namespace_validation_mode: :strict)
           false
         end
 
+        # Whether the mint pre-writes the consumer's contract ivars
+        # in C (create_primed_element), letting Document#create_element
+        # skip its Ruby prime pass. Base: never.
+        def mints_primed?
+          false
+        end
+
         # Whether add_child can keep tracking the same native —
         # adapters that may recreate the node on attach (libxml's
         # doc.root=) override to false so the wrapper refresh path

data/lib/moxml/adapter/leptris.rb

@@ -1193,14 +1193,26 @@ module Moxml
         # entry are correct; upstream bug filed). Track the state per
         # binding document and route XPath to the reference Ruby
         # engine until a child insertion rebuilds the engine index.
+        #
+        # FIXED upstream in libleptris 1.9.378 (leptris/leptris#1802):
+        # every splice path invalidates the index, so the guard is
+        # dead weight on modern engines — and it sat on the builder
+        # hot path (one Monitor-synchronized attachment set plus a
+        # document hop per add_child). Retirement is probed, not
+        # version-gated: any build that passes the #519 repro opts
+        # itself out, no moxml release needed.
         XPATH_INDEX_STALE = :xpath_index_stale
 
         def mark_xpath_index_stale(node)
+          return if native_xpath_index_fixed?
+
           doc = xpath_index_document(node)
           attachments.set(doc, XPATH_INDEX_STALE, true) if doc
         end
 
         def clear_xpath_index_stale(node)
+          return if native_xpath_index_fixed?
+
           doc = xpath_index_document(node)
           attachments.set(doc, XPATH_INDEX_STALE, false) if doc
         end
@@ -1762,6 +1774,23 @@ module Moxml
           (owner_doc || create_document).create_element(name.to_s)
         end
 
+        # MINT_PRIMED: the compiled ext's create_element takes
+        # optional (context, adapter) and pre-writes the contract
+        # ivars in C — arity -1 vs the old 2. Self-gating: no
+        # version floor, the probe reads the loaded ext.
+        MINT_PRIMED = defined?(::Leptris::XML::NativeNode) &&
+          ::Leptris::XML::NativeNode
+            .method(:create_element).arity == -1
+
+        def mints_primed?
+          MINT_PRIMED
+        end
+
+        def create_primed_element(name, owner_doc:, context:, adapter:)
+          validate_element_name(name)
+          owner_doc.native_create_element(name.to_s, context, adapter)
+        end
+
         def create_native_text(content, owner_doc = nil)
           if NATIVE_MUTATIONS_COHERENT && owner_doc
             return owner_doc.native_create_text(content)
@@ -2408,6 +2437,7 @@ module Moxml
         # callers fall back to create_element + set_attribute +
         # add_child when absent.
         def create_element_with_attrs(parent, name, attrs)
+          validate_element_name(name)
           binding_parent = to_binding(parent)
           doc = binding_parent.document or return nil
           return nil unless ::Leptris::XML::Native.respond_to?(:create_element_with_attrs)
@@ -3129,7 +3159,32 @@ module Moxml
           end.join
         end
 
+        # SET_TEXT_NATIVE: bindings with the unshadowed C alias
+        # (the add_child_native pattern — set_text_native aliases
+        # content= on the TypedData self) take the one-frame write:
+        # no doc_for climb, no address read, no module dispatch.
+        # Self-gating by respond_to? — older exts fall through to
+        # the set_binding_text face.
+        SET_TEXT_NATIVE = defined?(::Leptris::XML::NativeNode) &&
+          ::Leptris::XML::NativeNode.method_defined?(:set_text_native)
+
         def set_text_content(node, content)
+          if SET_TEXT_NATIVE && node.is_a?(::Leptris::XML::NativeNode)
+            begin
+              node.set_text_native(content.to_s)
+              return
+            rescue ::Leptris::XML::Error => e
+              # Same #401 contract as the fallback below: a detached
+              # (parentless) node re-raises as the named Moxml::Error.
+              raise if node.parent
+
+              raise Moxml::Error,
+                    "cannot set text content on a detached " \
+                    "(parentless) node — attach it to a document " \
+                    "first (issue #401): #{e.message}"
+            end
+          end
+
           # Native-layer fast path (leptris-ruby#460): the C setter
           # takes document+address directly — no binding twin mint
           # per write. The Identity wrapper's own content= would

data/lib/moxml/attribute_resolver.rb

@@ -109,6 +109,10 @@ module Moxml
       # over-invalidate (global bump instead of local) — a no-op
       # for correctness.
       if name.start_with?("xmlns")
+        # Introducing (or rewriting) a namespace declaration: mark the
+        # context BEFORE the invalidation, so this write's generation
+        # bump fans out to every wrapper's memoized scope reads.
+        element.context.mark_namespaces_active!
         adapter.set_attribute(element.native, name, value)
         element.invalidate_attribute_cache!
         return value

data/lib/moxml/context.rb

@@ -90,7 +90,10 @@ module Moxml
     end
 
     def bump_children_generation
-      @children_generation = children_generation + 1
+      # One dispatch, not two: children_generation re-dispatched just
+      # to default nil. Shared counter — node wrappers' children memos
+      # key on it.
+      @children_generation = @children_generation.to_i + 1
     end
 
     def namespace_scope_generation
@@ -101,6 +104,22 @@ module Moxml
       @namespace_scope_generation += 1
     end
 
+    # Namespace scopes only need the per-mutation generation bump
+    # while namespaces can exist. A builder-only document (no parse,
+    # no xmlns write) never has one, and the bump sat on the attach
+    # hot path (deletion experiment: build row 2.128x -> 1.923x).
+    # Every namespace introduction route marks the context active
+    # first — parse faces and the xmlns attribute-write face — so
+    # the sticky flag never misses an introduction.
+    def namespace_scopes_active?
+      @namespace_scopes_active = false if @namespace_scopes_active.nil?
+      @namespace_scopes_active
+    end
+
+    def mark_namespaces_active!
+      @namespace_scopes_active = true
+    end
+
     def entity_registry
       @entity_registry ||= build_entity_registry
     end
@@ -128,6 +147,7 @@ module Moxml
       # Parse with adapter, passing self (context) so adapter can use our config
       parsed_options = default_options.merge(options)
       doc = config.adapter.parse(xml_string, parsed_options, self)
+      mark_namespaces_active!
 
       # Set declaration flag on Document wrapper (proper OOP)
       doc.has_xml_declaration = has_declaration if doc.is_a?(Document)
@@ -233,7 +253,9 @@ module Moxml
     # are the result either way.
     def parse_fragment(xml)
       adapter = config.adapter
-      adapter.parse_fragment(xml, self).map do |node|
+      nodes = adapter.parse_fragment(xml, self)
+      mark_namespaces_active!
+      nodes.map do |node|
         # Adapters that tie a parent_node lifetime chain (#245)
         # return wrapped nodes — pass them through untouched;
         # re-wrapping would race the weak wrapper map.
@@ -242,6 +264,7 @@ module Moxml
     end
 
     def iterparse(xml, mode: :top_level, &block)
+      mark_namespaces_active!
       config.adapter.iterparse(xml, mode, self, &block)
     end
 

data/lib/moxml/document.rb

@@ -163,7 +163,17 @@ module Moxml
     end
 
     def create_element(name)
-      native = adapter.create_element(name, owner_doc: @native)
+      # The preprimed mint (leptris binding with the C-primed
+      # create_element): the mint already wrote @context/@adapter in
+      # C, so the returned node IS the finished wrapper and the Ruby
+      # prime pass disappears from the build path.
+      native = if adapter.mints_primed?
+                 adapter.create_primed_element(name, owner_doc: @native,
+                                                     context: context,
+                                                     adapter: adapter)
+               else
+                 adapter.create_element(name, owner_doc: @native)
+               end
       # leptris-ruby#508 mints registered klasses at create: the node
       # IS a contract-carrying identity (@native is self) — prime it
       # in place instead of shelling a second wrapper (a raw mint

data/lib/moxml/element.rb

@@ -276,6 +276,7 @@ module Moxml
     def add_namespace(prefix, uri)
       adapter.create_namespace(@native, prefix, uri,
                                namespace_validation_mode: context.config.namespace_validation_mode)
+      context.mark_namespaces_active!
       invalidate_namespace_cache!
       self
     rescue ValidationError => e
@@ -530,8 +531,19 @@ module Moxml
 
     # Clear the namespace caches and bump the context's scope
     # generation so every wrapper — including ones not reachable from
-    # any children cache — recomputes on next read.
+    # any children cache — recomputes on next read. While namespaces
+    # cannot exist (context.namespace_scopes_active? is false) the
+    # memos can only hold namespace-free reads, so skipping the whole
+    # body is exact — and the nil-assignment form would MATERIALIZE
+    # three unset ivars per attached node, which is the cost this
+    # gate exists to remove. Every introduction route — parse faces
+    # and the xmlns write face — marks the context BEFORE its own
+    # invalidation, so the introducing mutation still clears and
+    # bumps; in-scope reads are generation-keyed, so other wrappers
+    # recompute on the bump.
     def invalidate_namespace_cache!
+      return unless context.namespace_scopes_active?
+
       @namespaces = nil
       @namespace_definitions = nil
       @in_scope_namespaces = nil

data/lib/moxml/node.rb

@@ -30,9 +30,11 @@ module Moxml
     def prime_contract(native, context, adapter = nil, node_type = nil)
       @context = context
       @native = native
-      @parent_node = nil
-      @adapter = adapter
-      @node_type_cached = node_type
+      # @parent_node and @node_type_cached stay UNSET when empty —
+      # every reader is nil-tolerant, and a nil write materializes the
+      # ivar (object-shape transition) on every created node.
+      @adapter = adapter unless adapter.nil?
+      @node_type_cached = node_type unless node_type.nil?
       self
     end
 
@@ -214,10 +216,16 @@ module Moxml
     def attach_child(node)
       context.bump_children_generation
       node = prepare_node(node)
-      adapter.add_child(@native, node.native)
+      oc = node.context
+      if !oc.nil? && !oc.equal?(context) &&
+          oc.namespace_scopes_active?
+        context.mark_namespaces_active!
+      end
+      a = adapter
+      a.add_child(@native, node.native)
       # Refresh native in case adapter changed identity (e.g., LibXML
       # doc.root=); stable-identity adapters skip the round trip.
-      unless adapter.native_identity_stable?
+      unless a.native_identity_stable?
         refreshed = adapter.actual_native(node.native, @native)
         node.refresh_native!(refreshed) if refreshed && refreshed != node.native
       end
@@ -231,6 +239,7 @@ module Moxml
     def attach_previous_sibling(node)
       context.bump_children_generation
       node = prepare_node(node)
+      absorb_namespace_activity(node)
       inserted = adapter.add_previous_sibling(@native, node.native)
       refresh_inserted_native(node, inserted)
       # Invalidate the parent's memoized children list. The wrapper-side
@@ -245,6 +254,7 @@ module Moxml
     def attach_next_sibling_to(anchor, node)
       context.bump_children_generation
       node = prepare_node(node)
+      absorb_namespace_activity(node)
       inserted = adapter.add_next_sibling(anchor.native, node.native)
       refresh_inserted_native(node, inserted)
       anchor.parent&.invalidate_children_cache!
@@ -252,6 +262,16 @@ module Moxml
       self
     end
 
+    # A node adopted from ANOTHER context can carry namespaces this
+    # context's own faces (parse, xmlns writes) never saw; import the
+    # source context's activity flag so the gated scope-generation
+    # bump stays armed here too.
+    def absorb_namespace_activity(node)
+      oc = node.context
+      return if oc.nil? || oc.equal?(context)
+      context.mark_namespaces_active! if oc.namespace_scopes_active?
+    end
+
     def refresh_inserted_native(node, inserted)
       return unless adapter.add_sibling_returns_inserted?
       return if inserted.nil? || inserted.equal?(node.native)
@@ -773,7 +793,10 @@ module Moxml
     protected
 
     def invalidate_children_cache!
-      @children = nil
+      # Only nil an EXISTING memo: nil-assignment materializes an
+      # unset ivar (object-shape transition), and the builder hot
+      # path invalidates parents whose children memo was never read.
+      @children = nil unless @children.nil?
     end
 
     # Invalidate parent's cached children when this node

data/lib/moxml/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Moxml
-  VERSION = "0.5.150"
+  VERSION = "0.5.151"
 end

data/spec/moxml/adapter/leptris_spec.rb

@@ -865,5 +865,95 @@ RSpec.describe Moxml::Adapter::Leptris do
       expect(native).not_to be_nil
       expect(native.to_a.map { |n| n.name.to_s }).to eq(%w[a c b])
     end
+
+    it "never arms the guard on engines that invalidate on splice" do
+      skip "requires an engine whose node-set index survives sibling insertion (leptris-ruby#519)" unless described_class.native_xpath_index_fixed?
+
+      doc = ctx.parse("<root><anchor/></root>")
+      doc.xpath("//ext") # prime the engine index
+      doc.root.add_child(doc.create_element("ext"))
+      expect(doc.xpath("//ext").size).to eq(1)
+
+      expect(
+        described_class.attachments.get(
+          described_class.xpath_index_document(doc.root.native),
+          described_class.singleton_class.const_get(:XPATH_INDEX_STALE),
+        ),
+      ).to be_nil
+    end
+  end
+
+  describe "namespace scope-generation gate" do
+    let(:ctx) { Moxml.new(:leptris) }
+
+    # The per-attach scope-generation bump only matters once
+    # namespaces exist; the builder hot path must not pay it.
+    it "does not bump the scope generation while namespaces are absent" do
+      doc = ctx.create_document
+      root = doc.create_element("r")
+      doc.root = root
+      gen = ctx.namespace_scope_generation
+      root.add_child(doc.create_element("a"))
+      root.add_child(doc.create_element("b"))
+      expect(ctx.namespace_scope_generation).to eq(gen)
+      expect(ctx.namespace_scopes_active?).to be(false)
+    end
+
+    it "arms the gate when a write introduces a namespace" do
+      doc = ctx.create_document
+      root = doc.create_element("r")
+      doc.root = root
+      root["xmlns:foo"] = "urn:x"
+      expect(ctx.namespace_scopes_active?).to be(true)
+      expect(root.namespaces.map { |n| [n.prefix, n.uri] })
+        .to include(%w[foo urn:x])
+    end
+
+    it "is armed by parsed documents" do
+      doc = ctx.parse("<r xmlns:foo='urn:x'><foo:a/></r>")
+      expect(ctx.namespace_scopes_active?).to be(true)
+      expect(doc.xpath("//foo:a", "foo" => "urn:x").size).to eq(1)
+    end
+
+    it "imports the flag from a foreign context on adoption" do
+      donor_ctx = Moxml.new(:leptris)
+      donor = donor_ctx.parse("<x xmlns:foo='urn:x'/>")
+      doc = ctx.create_document
+      root = doc.create_element("r")
+      doc.root = root
+      expect(ctx.namespace_scopes_active?).to be(false)
+      root.add_child(donor.root)
+      expect(ctx.namespace_scopes_active?).to be(true)
+      expect(root.children.first.namespaces.map(&:uri))
+        .to include("urn:x")
+    end
+  end
+
+  # The README error-handling contract: an invalid element name must
+  # raise Moxml::ValidationError at CREATE time. The adapter's native
+  # fast paths (create_primed_element, create_element_with_attrs) mint
+  # from a name without passing through Base#create_element, where
+  # validate_element_name lives — the failure then surfaced late, at
+  # add_child, as Moxml::Error "Document already has a root element".
+  describe "element name validation on the create seam" do
+    let(:ctx) { Moxml.new(:leptris) }
+
+    it "raises ValidationError when create_element mints an invalid name" do
+      doc = ctx.parse("<root/>")
+      expect { doc.create_element("wrong,name") }
+        .to raise_error(Moxml::ValidationError, /Invalid XML element name/)
+    end
+
+    it "raises ValidationError when add_element mints an invalid name" do
+      doc = ctx.create_document
+      expect { doc.add_element("bad,name", id: "1") }
+        .to raise_error(Moxml::ValidationError, /Invalid XML element name/)
+    end
+
+    it "still mints valid names with punctuation allowed in XML Names" do
+      doc = ctx.parse("<root/>")
+      element = doc.create_element("ns:my-element.v2")
+      expect(element).to be_a(Moxml::Element)
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: moxml
 version: !ruby/object:Gem::Version
-  version: 0.5.150
+  version: 0.5.151
 platform: ruby
 authors:
 - Ribose Inc.