moxml 0.5.153 → 0.5.154

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7f599e1c38d471ff887c23b2cccfe367a280dbbe3d70213a74dcb0ec1debe9da
-  data.tar.gz: c6d8c03cac7308e5be8e6068e5ac57da8e65c76d367b5c46711c263a5500bbc8
+  metadata.gz: 05a5f1f4e5475fe30f9d821cc2630f8c6d9d95aa38fa5d2e46e25e51605d1504
+  data.tar.gz: c47ee78ffb35d119b4a5c470e27e4dd0b9d3c4dfedba2c7d8bcc3aa17901d01b
 SHA512:
-  metadata.gz: 4849176647a258995d7d2a2dfe28908dd0b9efb3fde41a08de624a55d7bc1b06849f26d6fba0ed75797c5111f4ea8c3c42def0c1d7834a6ddec8054ad0bd46f4
-  data.tar.gz: c18c0615e863e24584066ab8f6b80f81630c574c9c17d30bca561f47211cb10dda22bb4e438f66a92e5ecafbd656621aad0df801ac1ba259913597062910ffb8
+  metadata.gz: 012cb442259cd2496eacf056b75e8ed050203eb92673b608b379305de4215f8c00c65b83b72d70027c7b2adbd9fd90d5eb2f41701de62305e291f7118fa9a44a
+  data.tar.gz: ceed6daf6824f3de929c14586b130fb014afc66b261bb3c76a92be0e09e1e33e4e41c8729f7a091dc80e71dbe36a67ffdffd66d454406e5a9a47494d634b294e

data/.github/workflows/performance-release.yml

@@ -78,11 +78,15 @@ jobs:
         env:
           GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         run: |
-          # The released version is the gemspec's at the pinned tree —
-          # NOT "latest": back-to-back releases would otherwise aim a
-          # back-aimed rerun at the newer notes.
-          VERSION=$(ruby -e 'print Gem::Specification.load("moxml.gemspec").version')
-          TAG="v${VERSION}"
+          # The notes target is the release created by the triggering
+          # run — NOT "latest" (a rerun of an old run would mis-aim)
+          # and NOT the gemspec at the pinned tree (the checkout is
+          # the pre-bump tree; the bump lands on main during the
+          # release run itself).
+          TRIGGERED_AT="${{ github.event.workflow_run.created_at }}"
+          TAG=$(gh api "repos/${GITHUB_REPOSITORY}/releases" \
+            --jq "map(select(.created_at >= \"${TRIGGERED_AT}\")) | sort_by(.created_at) | last | .tag_name")
+          TAG=${TAG:-$(gh release view --json tagName --jq .tagName)}
           echo "Reporting against $TAG"
           gh release view "$TAG" --json body --jq .body > /tmp/body.md
           ruby -e '

data/docs/_pages/divergences.adoc

@@ -137,3 +137,12 @@ parse (the engine's instruction content is trimmed); leading
 separator runs collapse per the model. Pinned in the taxonomy
 differential (`pi trailing whitespace`, face `pi_content`).
 |===
+
+| D-21
+| leptris (bindings before 1.9.360)
+| The binding exposes no `Leptris::XML::Declaration` class, so the
+document-children declaration filter resolves conditionally and is a
+no-op there (declaration nodes cannot occur). On such bindings the
+class is also absent for consumers. Pinned in
+`spec/moxml/adapter/leptris_document_children_older_binding_spec.rb`.
+|===

data/lib/moxml/adapter/leptris/document_parts.rb

@@ -39,9 +39,17 @@ module Moxml
           # leptris-ruby#459 lists the declaration among the binding
           # children; the Nokogiri-shaped facade contract never lists
           # it (the declaration is a preamble part, not a child node)
-          # — filtered at the listing seam.
+          # — filtered at the listing seam. The constant is resolved
+          # conditionally: leptris releases before the declaration
+          # node class landed (e.g. 1.9.345) carry no Declaration at
+          # all, and referencing the constant unconditionally raises
+          # NameError on every document-children listing.
+          declaration_class =
+            if ::Leptris::XML.const_defined?(:Declaration, false)
+              ::Leptris::XML::Declaration
+            end
           children.concat(
-            doc.children.to_a.grep_v(::Leptris::XML::Declaration),
+            doc.children.to_a.grep_v(declaration_class),
           )
 
           texts = attachments.get(doc, :document_text)

data/lib/moxml/adapter/leptris.rb

@@ -749,7 +749,16 @@ module Moxml
                     @children = nil
                     @children_gen = generation
                   end
-                  @children ||= if doc_entity_bearing?
+                  @children ||= if doc_entity_bearing? ||
+                      !::Moxml::Adapter::Leptris
+                          .children_read_splice_safe?
+                                  # Splice-unsafe builds (1.9.381.0,
+                                  # leptris-ruby#545): the cached face's
+                                  # child list no longer reflects
+                                  # splices — the adapter crossing is
+                                  # the correctness path, and the
+                                  # no-crossing contract is probed off
+                                  # for those builds.
                                   super
                                 else
                                   NodeSet.new(children_read, ctx, self,
@@ -1276,6 +1285,29 @@ module Moxml
           end
         end
 
+        # 1.9.381.0: the children_read face stopped reflecting
+        # post-splice state — Element#add_next_sibling lands the node
+        # in the tree (native bulk reads and walk_columnar see it) but
+        # leaves the face's child list stale. Probe the exact repro
+        # once: prime the face, splice, and require children_read to
+        # see the inserted node. Unsafe builds take the adapter
+        # children path; fixed builds restore the fast path
+        # automatically.
+        def children_read_splice_safe?
+          return @children_read_splice_safe unless @children_read_splice_safe.nil?
+
+          @children_read_splice_safe = begin
+            native_doc = ::Leptris::XML::Document.parse("<r><a/>\n<b/></r>")
+            root = native_doc.root
+            root.children_read.to_a # prime the face's child list
+            a = root.children.to_a.first
+            a.add_next_sibling(native_doc.create_element("x"))
+            root.children_read.to_a.map { |n| n.name.to_s } == %w[a x b]
+          rescue StandardError
+            false
+          end
+        end
+
         def xpath_index_document(node)
           return node if node.is_a?(::Leptris::XML::Document)
 
@@ -2719,6 +2751,7 @@ module Moxml
           doc = NN_DOCUMENT.bind_call(parent_nn)
           src = to_binding(child_nn)
           installed = copy_binding_subtree(doc, src)
+          advance_mutation_version(parent_nn)
           ::Leptris::XML::FFI.check_status(
             ::Leptris::XML::FFI.leptris_element_append_child(
               ::FFI::Pointer.new(parent_nn.address), installed.c_ptr
@@ -2767,6 +2800,7 @@ module Moxml
             end
           # The raw engine add rejects binding-family children —
           # append through the FFI face like structural_adopt.
+          advance_mutation_version(parent_nn)
           ::Leptris::XML::FFI.check_status(
             ::Leptris::XML::FFI.leptris_element_append_child(
               ::FFI::Pointer.new(parent_nn.address), rebuilt.c_ptr
@@ -3090,7 +3124,13 @@ module Moxml
 
           # Non-element receivers: raw-FFI anchor (issue #245, same
           # shape as add_next_sibling).
+          # leptris-ruby#543: the raw-FFI splice is a wrapper-visible
+          # mutation — advance the binding document's version or the
+          # walk-read memos warmed before it serve stale children.
+          node.document&.advance_version if
+            node.document.respond_to?(:advance_version)
           adopt_for_sibling_insert(new_node, node)
+          advance_mutation_version(node)
           ::Leptris::XML::FFI.check_status(
             ::Leptris::XML::FFI.leptris_element_insert_before(
               node.c_ptr, new_node.c_ptr
@@ -3134,7 +3174,13 @@ module Moxml
           # node — route through the FFI entry directly, keeping the
           # binding's namespace-lift adoption for element inserts
           # (issue #245).
+          # leptris-ruby#543: the raw-FFI splice is a wrapper-visible
+          # mutation — advance the binding document's version or the
+          # walk-read memos warmed before it serve stale children.
+          node.document&.advance_version if
+            node.document.respond_to?(:advance_version)
           adopt_for_sibling_insert(new_node, node)
+          advance_mutation_version(node)
           ::Leptris::XML::FFI.check_status(
             ::Leptris::XML::FFI.leptris_element_insert_after(
               node.c_ptr, new_node.c_ptr
@@ -3154,6 +3200,23 @@ module Moxml
           ::Leptris::XML::Element.lift_namespaces_for_adoption(new_node, scope)
         end
 
+        # The binding's version-stamped read memos (the #530
+        # walk-reads, the C content/attribute memos) key their
+        # validity on the owning Document's mutation version. The
+        # gated Ruby faces advance it (Node#ensure_writable!) and
+        # the C-bound faces bump in C — a RAW FFI write bypasses
+        # both, so every raw write in this adapter bumps here,
+        # before the call, mirroring ensure_writable!'s
+        # conservative discipline (a failed write merely discards
+        # memos). Without it, a children memo warmed before the
+        # insert serves the pre-insert tree forever.
+        def advance_mutation_version(node)
+          doc = node.respond_to?(:document) ? node.document : nil
+          doc.advance_version if doc.respond_to?(:advance_version)
+        rescue ::Leptris::XML::Error
+          nil
+        end
+
         def remove(node)
           drop_columnar_children(node)
           node = to_binding(node) if NATIVE_READ_LAYER
@@ -3225,12 +3288,14 @@ module Moxml
           prev = node.previous_sibling
           node.unlink
           if prev.is_a?(::Leptris::XML::Element)
+            advance_mutation_version(prev)
             ::Leptris::XML::FFI.check_status(
               ::Leptris::XML::FFI.leptris_element_insert_after(
                 prev.c_ptr, new_node.c_ptr
               ),
             )
           else
+            advance_mutation_version(parent)
             ::Leptris::XML::FFI.check_status(
               ::Leptris::XML::FFI.leptris_element_append_child(
                 parent.c_ptr, new_node.c_ptr
@@ -3645,8 +3710,8 @@ module Moxml
           # nil and leaves the pointer — fall through to the scalar
           # wrap, whose free owns it.
           if BULK_XPATH_ROWS &&
-             ::Leptris::XML::FFI.leptris_xpath_result_type(result_ptr) ==
-               ::Leptris::XML::FFI::XPATH_NODESET
+              ::Leptris::XML::FFI.leptris_xpath_result_type(result_ptr) ==
+                  ::Leptris::XML::FFI::XPATH_NODESET
             # The one-crossing mint is deferred: a caller that only
             # asks #size never pays for the rows (#527). The holder
             # runs Document#xpath_result_rows_bulk on first read.

data/lib/moxml/lazy_bulk_rows.rb

@@ -37,10 +37,10 @@ module Moxml
       materialize[index]
     end
 
-    def each
-      return enum_for(:each) unless block_given?
+    def each(&block)
+      return enum_for(:each) unless block
 
-      materialize.each { |row| yield row }
+      materialize.each(&block)
       self
     end
 
@@ -51,7 +51,7 @@ module Moxml
     def self.finalizer(address)
       proc do
         ::Leptris::XML::FFI.leptris_xpath_result_free(
-          ::FFI::Pointer.new(address)
+          ::FFI::Pointer.new(address),
         )
       end
     end

data/lib/moxml/version.rb

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

data/spec/moxml/adapter/leptris_contract_reads_spec.rb

@@ -136,6 +136,9 @@ RSpec.describe "leptris Identity contract reads" do
       unless Leptris::XML::NativeNode.method_defined?(:children_read)
         skip "binding #{Leptris::VERSION} has no children_read face"
       end
+      unless Moxml::Adapter::Leptris.children_read_splice_safe?
+        skip "binding #{Leptris::VERSION} lacks the splice-safe children_read face (leptris-ruby#545) — the crossing is the correctness path there"
+      end
       doc = ctx.parse("<root><item>v</item></root>")
       el = doc.root.children.first
 

data/spec/moxml/adapter/leptris_document_children_older_binding_spec.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# The document-children listing filters the declaration node, but on
+# leptris releases that predate the Declaration class entirely
+# (< 1.9.360) referencing the constant raised NameError on every
+# document-children enumeration — the first `doc.children` on any
+# document. The filter must resolve the constant conditionally.
+RSpec.describe "leptris document children on older leptris" do
+  let(:ctx) { Moxml.new(:leptris) }
+
+  it "lists document children when the release has no Declaration class" do
+    leptris_xml = Leptris::XML
+    had_declaration = leptris_xml.const_defined?(:Declaration, false)
+    declaration = had_declaration ? leptris_xml.const_get(:Declaration) : nil
+    # stub_const cannot express a MISSING constant; simulating the
+    # older binding requires the constant to be absent
+    if had_declaration
+      leptris_xml.send(:remove_const, :Declaration) # rubocop:disable RSpec/RemoveConst
+    end
+
+    begin
+      doc = ctx.create_document
+      doc.add_child(doc.create_element("root"))
+      expect(doc.children.map(&:name)).to eq(%w[root])
+    ensure
+      leptris_xml.const_set(:Declaration, declaration) if had_declaration
+    end
+  end
+
+  it "keeps filtering the declaration on releases that have the class" do
+    skip "binding #{Leptris::VERSION} has no Declaration class (D-21)" unless
+      Leptris::XML.const_defined?(:Declaration, false)
+
+    doc = ctx.parse(%(<?xml version="1.0" encoding="UTF-8"?>\n<documents></documents>))
+    expect(doc.children.map(&:node_type)).to eq(%i[element])
+  end
+end

data/spec/moxml/adapter/leptris_spec.rb

@@ -490,6 +490,12 @@ RSpec.describe Moxml::Adapter::Leptris do
       # The identity map must hold wrappers weakly: parse-and-drop
       # workloads otherwise pin wrappers, natives, and (via the
       # binding finalizer never running) the C subtrees.
+      # Splice-unsafe builds (leptris-ruby#545) walk through the
+      # adapter crossing, whose wrappers ride the strong registry —
+      # the weak-release contract is probed off there.
+      unless described_class.children_read_splice_safe?
+        skip "binding #{Leptris::VERSION} requires a splice-safe children_read face (leptris-ruby#545)"
+      end
       xml = %(<r>#{Array.new(50) { |i| "<e id=\"i#{i}\">x</e>" }.join}</r>)
       ctx = Moxml.new(:leptris)
       count = -> {

data/spec/moxml/adapter/leptris_xpath_bulk_rows_spec.rb

@@ -72,12 +72,12 @@ RSpec.describe "leptris xpath bulk rows routing" do
   # leptris-ruby#527: the count row is one evaluation plus a size
   # read — it must not pay the per-row mint.
   describe "row materialization is deferred" do
-    def bulk_calls
+    def bulk_calls(&block)
       calls = 0
       tp = TracePoint.new(:c_call) do |t|
         calls += 1 if t.method_id == :xpath_result_rows_bulk
       end
-      tp.enable { yield }
+      tp.enable(&block)
       calls
     end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: moxml
 version: !ruby/object:Gem::Version
-  version: 0.5.153
+  version: 0.5.154
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-10-22 00:00:00.000000000 Z
+date: 2026-10-23 00:00:00.000000000 Z
 dependencies: []
 description: |
   Moxml is a unified XML manipulation library that provides a common API
@@ -486,6 +486,7 @@ files:
 - spec/moxml/adapter/leptris_contract_reads_spec.rb
 - spec/moxml/adapter/leptris_detached_text_spec.rb
 - spec/moxml/adapter/leptris_doc_parts_spec.rb
+- spec/moxml/adapter/leptris_document_children_older_binding_spec.rb
 - spec/moxml/adapter/leptris_document_declaration_spec.rb
 - spec/moxml/adapter/leptris_inbody_comment_spec.rb
 - spec/moxml/adapter/leptris_parse_lint_spec.rb