leptris 1.9.312.0-ppc64le-linux → 1.9.313.0-ppc64le-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e2900f7f134a39a0179cd94477602e1220628f66052bc01b8bd20eeb16299b4a
-  data.tar.gz: 47af52166c780c8a40e3490624d1938370719cf443d9b809c58d5fda27fd918c
+  metadata.gz: 5b0d75571e6bca74bbc0fda795a056ef0d06ee890c01a7702f4bafecf04b13b9
+  data.tar.gz: 00e7e1b1e4725cedbd9fed583ff3bed73766c48221920bc2e7444bf5d2c3b277
 SHA512:
-  metadata.gz: 3138aa1b0b779c8a8526d84fc2b5c21a3969a354145b5150754e82f40fc2d41469620a5394fd7a752c922b2d2f9512a6b5bff0f023f1b2f11fc836cb121600f4
-  data.tar.gz: 00652dec2cfaf2255dae922394a660139de114d385ab6cd0db07d3a9ba088b9f921da130ccbf065db6856822d8e9cfb673a7a8251b17589fecab7a9a9d72e68f
+  metadata.gz: a809fbb6ee0f7bf05ac4af11985ee50f5ec82410f65635bb1af97dd41bcefafc7d96a5a91e175585799c1418a5b459cd5b25fb1fb6728282a1f3ff7258f03a8b
+  data.tar.gz: 7e77d333407d8005739346eff63f9f1f3ca94bba8390b76c1e2d99db28a8db9bf001ebdf2640e71be7152e9f94661967c3deccd1c3a782c14d55c9b6f79a06bd

data/CHANGELOG.md

@@ -1,3 +1,35 @@
+## [1.9.313.0] - 2026-10-07
+
+### Fixed — engine sync (libleptris 1.9.313)
+
+- **Absorption-aware release at the C ABI (#1557, engine #1566)**:
+  the follow-up to the #386 mitigation — `leptris_document_free`
+  now consults the absorption state itself. The anchor dying while
+  `absorbed_handle > 0` detaches the source and defers its release
+  to the outstanding holder's free (`absorbed_deferred`); handles
+  released before the anchor keep the #1548 handle-only no-op. C
+  consumers no longer need to mirror the absorbed flag at their own
+  release sites; the binding's 1.9.311.2 mitigation stays as
+  defense-in-depth. Both release orderings spec-pinned.
+
+## [1.9.312.1] - 2026-10-07
+
+### Added
+
+- **Document#build / Element#build — the builder face (#374 lever
+  2)**: markup-accumulating construction. The block turns into
+  well-formed markup in Ruby (method_missing element dispatch
+  with attrs/text, `#text`/`#cdata`/`#comment`/`#raw`, one-pass
+  escaping of `& < > "`), and the flush performs ONE native
+  crossing for the whole subtree — parse + `root=` adoption for
+  document sinks (exactly one root, the parser enforces it;
+  returns the installed root wrapper), `append_markup` for
+  element sinks (returns the added NodeSet). Measured DSL-vs-DSL
+  under load (interleaved CPU-time medians, build(500)):
+  leptris builder 2.68 ms vs nokogiri's builder 5.29 ms —
+  **~2.0x** — and ~1.2x over our own object face (3.19 ms,
+  itself ~1.7x nokogiri after the 1.9.311.3 trim).
+
 ## [1.9.312.0] - 2026-10-07
 
 ### Added — engine sync (libleptris 1.9.312)

data/Rakefile

@@ -8,7 +8,7 @@ RSpec::Core::RakeTask.new(:spec)
 # Pin for `rake compile` and the platform-gem builds. Keep in lockstep
 # with .github/workflows/build.yml (which calls `rake compile`) and the
 # CHANGELOG when libleptris releases.
-LIBLEPTRIS_VERSION = "1.9.312"
+LIBLEPTRIS_VERSION = "1.9.313"
 # Vendored alongside libleptris for fn:normalize-unicode (TODO
 # .restructure/20): built per platform with a RELOCATABLE @rpath
 # install name, loaded by ffi.rb before libleptris so the

data/lib/leptris/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Leptris
-  VERSION = "1.9.312.0"
+  VERSION = "1.9.313.0"
 end

data/lib/leptris/xml/builder.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+# Markup-accumulating subtree construction (#374 lever 2): the
+# builder turns a Ruby block into well-formed markup in a plain
+# String (Ruby-side cost only), and the flush performs ONE native
+# crossing — parse + attach — for the whole subtree. The
+# per-element FFI crossing that dominated the object-face build
+# profile collapses to one per #build call.
+#
+#     doc.build do |b|
+#       b.catalog(id: "c") do
+#         b.item(id: 7) { b.name "Item 7" }
+#       end
+#     end
+#
+# Element names arriving through method_missing are identifier-
+# shaped by construction (Ruby method names cannot carry markup
+# metacharacters); the explicit #element path checks NAME_RE.
+# Text and attribute values escape in one pass per string.
+class Leptris::XML::Builder
+  NAME_RE = /\A[a-zA-Z_][\w.-]*\z/
+
+  ESCAPE = {
+    "&" => "&",
+    "<" => "&lt;",
+    ">" => "&gt;",
+    '"' => "&quot;",
+  }.freeze
+  ESCAPE_RE = /[&<>"]/
+  private_constant :ESCAPE, :ESCAPE_RE
+
+  # +sink+ receives the flushed markup (a Document or Element).
+  def initialize(sink)
+    @sink = sink
+    @buf = +""
+    @depth = 0
+  end
+
+  def element(name, attributes = nil)
+    name = name.to_s
+    unless name =~ NAME_RE
+      raise ArgumentError,
+        "element name must match #{NAME_RE.inspect}, got #{name.inspect}"
+    end
+    @buf << "<" << name
+    write_attributes(attributes) if attributes
+    if block_given?
+      @buf << ">"
+      @depth += 1
+      begin
+        yield self
+      ensure
+        @depth -= 1
+      end
+      @buf << "</" << name << ">"
+    else
+      @buf << "/>"
+    end
+    self
+  end
+
+  def text(content)
+    @buf << escape_text(content.to_s)
+    self
+  end
+
+  def cdata(content)
+    @buf << "<![CDATA[" << content.to_s << "]]>"
+    self
+  end
+
+  def comment(content)
+    @buf << "<!--" << escape_text(content.to_s) << "-->"
+    self
+  end
+
+  # Verbatim markup — the escape hatch for pre-serialized
+  # fragments; the caller owns well-formedness.
+  def raw(markup)
+    @buf << markup.to_s
+    self
+  end
+
+  def method_missing(name, *args, &block)
+    # Method names are identifier-shaped: they cannot carry <, >,
+    # &, quotes, or whitespace, so they need no NAME_RE round-trip
+    # (trailing = / ? / ! are legal Ruby but never legal XML
+    # name tails here — reject them explicitly).
+    return super if name.to_s.end_with?("=", "?", "!")
+    case args.length
+    when 0
+      element(name.to_s, &block)
+    when 1
+      arg = args[0]
+      if arg.is_a?(Hash)
+        element(name.to_s, arg, &block)
+      else
+        element(name.to_s) { |b| b.text(arg); block&.call(b) }
+      end
+    when 2
+      attrs, txt = args
+      return super unless attrs.is_a?(Hash)
+      element(name.to_s, attrs) { |b| b.text(txt); block&.call(b) }
+    else
+      super
+    end
+  end
+
+  def respond_to_missing?(name, include_private = false)
+    !name.to_s.end_with?("=", "?", "!") || super
+  end
+
+  # One native crossing for the accumulated subtree: the flush
+  # parses + attaches. Document sinks take exactly one root
+  # (set_root_ex adopts the parsed root); element sinks append
+  # every fragment child.
+  def flush
+    unless @depth.zero?
+      raise Leptris::XML::Error,
+        "unbalanced builder — unclosed elements remain (depth #{@depth})"
+    end
+    markup = @buf
+    return @sink if markup.empty?
+    case @sink
+    when Leptris::XML::Document
+      parsed = Leptris::XML::Document.parse(markup)
+      root = parsed.root
+      if root.nil?
+        raise Leptris::XML::Error,
+          "builder markup produced no root element"
+      end
+      @sink.root = root
+      @buf = +""
+      # The INSTALLED root — the same wrapper #root now yields
+      # (root= returns the parsed source, not the adoption copy).
+      @sink.root
+    when Leptris::XML::Element
+      added = @sink.add_child(markup)
+      @buf = +""
+      added
+    else
+      raise ArgumentError,
+        "builder sink must be a Document or Element, got #{@sink.class}"
+    end
+  end
+
+  private
+
+  def write_attributes(attributes)
+    case attributes
+    when Hash
+      attributes.each do |k, v|
+        @buf << " " << k.to_s << '="' << escape_attr(v) << '"'
+      end
+    when nil then # nothing
+    else
+      raise ArgumentError,
+        "attributes must be a Hash, got #{attributes.class}"
+    end
+  end
+
+  def escape_text(value)
+    value.gsub(ESCAPE_RE, ESCAPE)
+  end
+
+  def escape_attr(value)
+    value.to_s.gsub(ESCAPE_RE, ESCAPE)
+  end
+end

data/lib/leptris/xml/document.rb

@@ -232,6 +232,20 @@ class Leptris::XML::Document
     wrap(raw)
   end
 
+  # Markup-accumulating construction (#374 lever 2): the block
+  # accumulates well-formed markup in Ruby; the flush performs
+  # ONE native crossing for the whole subtree. Exactly one root
+  # element — the parsed root is adopted with set_root_ex.
+  # Returns the flush's value (the installed root element).
+  #
+  #     doc = Leptris::XML::Document.create
+  #     doc.build { |b| b.catalog(id: "c") { b.item { b.name "x" } } }
+  def build
+    builder = Leptris::XML::Builder.new(self)
+    yield builder
+    builder.flush
+  end
+
   # Deep copy of +node+ in a NEW document — the one authority
   # behind Node#dup / Element#dup and the indent-unit path.
   # Elements deep-copy through the C copier (every child kind and

data/lib/leptris/xml/element.rb

@@ -665,6 +665,17 @@ class Leptris::XML::Element < Leptris::XML::Node
     Leptris::XML::Node.wrap_fresh(ptr, @document, Leptris::XML::FFI::NODE_ELEMENT)
   end
 
+  # Markup-accumulating child construction (#374 lever 2): the
+  # block accumulates well-formed child markup in Ruby; the flush
+  # appends every fragment child in ONE native crossing
+  # (append_markup). Returns the flush's value (the NodeSet of
+  # added children).
+  def build
+    builder = Leptris::XML::Builder.new(self)
+    yield builder
+    builder.flush
+  end
+
   def add_child(node_or_markup)
     case node_or_markup
     when Leptris::XML::Node

data/lib/leptris/xml.rb

@@ -14,6 +14,7 @@ module Leptris
     autoload :Namespace, "leptris/xml/namespace"
     autoload :Document, "leptris/xml/document"
     autoload :DocumentFragment, "leptris/xml/document_fragment"
+    autoload :Builder, "leptris/xml/builder"
     autoload :DocType, "leptris/xml/doc_type"
     autoload :NodeSet, "leptris/xml/node_set"
     autoload :Searchable, "leptris/xml/searchable"

data/vendor-src/README.md

@@ -1,7 +1,7 @@
 Sources vendored in this gem (recompile rights; the ruby
 variant builds them at install via extconf.rb):
 
-- libleptris v1.9.312
+- libleptris v1.9.313
 - utf8proc v2.11.0
 
 Rebuild by hand:

data/vendor-src/libleptris/CHANGELOG.md

@@ -1,5 +1,27 @@
 ## [Unreleased]
 
+## [1.9.313] - 2026-10-07
+
+### Fixed
+
+- **Absorbed sources defer their release to outstanding handles
+  (#1557, PR #1566).** Follow-up to #1548's
+  `leptris_document_absorb`: the absorber's free cleared the
+  absorbed state before recursing, so a source handle that
+  OUTLIVED the absorber read the cleared flag and re-released the
+  already-destroyed pool — heap corruption (glibc abort /
+  `malloc_zone_error`), deterministic under exit-time finalizers
+  (leptris-ruby#386, 50-iteration repro). When the anchor dies
+  while `absorbed_handle > 0` it now detaches the source and marks
+  `absorbed_deferred`: the holder's `leptris_document_free`
+  performs the FULL release; handles released before the anchor
+  keep the #1548 handle-only no-op. Consumers no longer need to
+  mirror the absorbed flag at their own release sites. Gates: the
+  repro red under ASAN at leptris.c:937, green after; mutation
+  suite 27/27 ASAN + Release; full ctest 1866/1866; leaks 0.
+
+
+
 ## [1.9.312] - 2026-10-06
 
 ### Added

data/vendor-src/libleptris/CMakeLists.txt

@@ -3,7 +3,7 @@
 cmake_minimum_required(VERSION 3.20)
 
 project(leptris
-    VERSION 1.9.312
+    VERSION 1.9.313
     DESCRIPTION "Fast XML parser and XPath evaluator in pure C"
     LANGUAGES C CXX
 )

data/vendor-src/libleptris/src/leptris/leptris.c

@@ -933,9 +933,11 @@ LEPTRIS_API void leptris_document_free(struct leptris_document* doc) {
 
     /* #1548: an absorbed document's MEMORY belongs to its absorber
      * (it rides the absorber's child_docs chain). A caller free
-     * releases only the outstanding handle. */
-    if (doc->absorbed_by) {
-        doc->absorbed_handle = 0;
+     * releases only the outstanding handle. #1557: unless the
+     * anchor died first and DEFERRED the release to this holder —
+     * then this free is the real one. */
+    if (doc->absorbed_by && !doc->absorbed_deferred) {
+        if (doc->absorbed_handle > 0) doc->absorbed_handle--;
         return;
     }
 
@@ -1021,12 +1023,24 @@ LEPTRIS_API void leptris_document_free(struct leptris_document* doc) {
                                        * doesn't try to walk the
                                        * adopted subtree. */
             ch->root = NULL;
-            /* #1548: the anchor's free is the REAL one — clear the
-             * absorbed state so the early handle-return above does
-             * not swallow it. */
-            ch->absorbed_by = NULL;
-            ch->absorbed_handle = 0;
-            leptris_document_free(ch);
+            if (ch->absorbed_by && ch->absorbed_handle > 0) {
+                /* #1557: a caller still holds this absorbed handle.
+                 * Freeing here would strand it on freed memory (its
+                 * later free read the cleared flag and re-released
+                 * the pool — the leptris-ruby#386 double free).
+                 * DEFER: detach from our chain and hand the release
+                 * to the holder's leptris_document_free, which sees
+                 * absorbed_deferred and runs the full release. */
+                ch->absorbed_deferred = 1;
+                ch->next_adopted = NULL;
+            } else {
+                /* #1548: the anchor's free is the REAL one — clear
+                 * the absorbed state so the early handle-return
+                 * above does not swallow it. */
+                ch->absorbed_by = NULL;
+                ch->absorbed_handle = 0;
+                leptris_document_free(ch);
+            }
             ch = next;
         }
         doc->child_docs = NULL;

data/vendor-src/libleptris/src/leptris/leptris_internal.h

@@ -195,6 +195,11 @@ struct leptris_document {
      * (the anchor frees the memory later). */
     struct leptris_document* absorbed_by;
     int absorbed_handle;
+    /* #1557: the absorber died while this handle was outstanding —
+     * the anchor deferred the pool release to THIS holder's free,
+     * so leptris_document_free must run the full release (not the
+     * handle-only early return). */
+    int absorbed_deferred;
     /* XML Declaration support */
     char* xml_version;              /* "1.0", "1.1", etc. or NULL if not present */
     int standalone;                 /* -1=not set, 0=no, 1=yes */

data/vendor-src/libleptris/test/abi/test_dom_mutation_bugs.cpp

@@ -670,6 +670,32 @@ TEST(CrossDocumentLeafAdoption, RootLevelLeafArgumentAdoptsByKind) {
     }
 }
 
+// #1557: an absorbed source's handle may OUTLIVE the absorber. The
+// anchor's free used to clear the absorbed state, so the holder's
+// later free re-released the same pool — heap corruption. The anchor
+// now defers the release to the outstanding handle.
+TEST(AbsorbAdoption, SourceHandleMayOutliveAnchor) {
+    for (int i = 0; i < 50; i++) {
+        LeptrisDocument dest = Parse("<main><keep/></main>");
+        ASSERT_NE(dest, nullptr);
+        LeptrisDocument src = Parse("<scratch><a/></scratch>");
+        ASSERT_NE(src, nullptr);
+        ASSERT_EQ(leptris_document_absorb(dest, src), LEPTRIS_OK);
+        leptris_document_free(dest);   /* anchor dies first */
+        leptris_document_free(src);    /* holder releases after */
+    }
+}
+
+TEST(AbsorbAdoption, SourceHandleFreedBeforeAnchorStillNoOp) {
+    LeptrisDocument dest = Parse("<main><keep/></main>");
+    ASSERT_NE(dest, nullptr);
+    LeptrisDocument src = Parse("<scratch><a/></scratch>");
+    ASSERT_NE(src, nullptr);
+    ASSERT_EQ(leptris_document_absorb(dest, src), LEPTRIS_OK);
+    leptris_document_free(src);    /* handle-only: memory stays with anchor */
+    leptris_document_free(dest);   /* releases everything incl. the source */
+}
+
 TEST(AbsorbAdoption, SpliceAfterAbsorbIsZeroCopy) {
     LeptrisDocument dst = Parse("<main><keep/></main>");
     ASSERT_NE(dst, nullptr);

data/vendor-src/libleptris/vcpkg.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://raw.githubusercontent.com/microsoft/vcpkg/master/scripts/vcpkg.schema.json",
   "name": "leptris",
-  "version": "1.9.312",
+  "version": "1.9.313",
   "description": "High-performance XML parser and XPath 1.0 engine in C (libleptris)",
   "homepage": "https://github.com/leptris/leptris",
   "license": "MIT",

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: leptris
 version: !ruby/object:Gem::Version
-  version: 1.9.312.0
+  version: 1.9.313.0
 platform: ppc64le-linux
 authors:
 - Ribose Inc.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-10-06 00:00:00.000000000 Z
+date: 2026-10-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -144,6 +144,7 @@ files:
 - lib/leptris/version.rb
 - lib/leptris/xml.rb
 - lib/leptris/xml/attr.rb
+- lib/leptris/xml/builder.rb
 - lib/leptris/xml/c_string_array.rb
 - lib/leptris/xml/cdata.rb
 - lib/leptris/xml/comment.rb