leptris 1.9.380.1 → 1.9.380.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 691f29770b6ab11fe0b36b1de8d4119839aea55e77fa7aa484df208e7f2242a3
-  data.tar.gz: 9cab3c91a664ca30ab2252db2c7a3c4e6846461b767391ebdf4fb9a695bf65b7
+  metadata.gz: 213b5096ca73813ee05e8816632f5f3f0e0cbae5744b477b5cecb7acae15ad2b
+  data.tar.gz: 23ea9d5f3ddb5f067e5bc90b29599e47df1418336bff8caa1b3fb139202079fe
 SHA512:
-  metadata.gz: 6b6abc7e9b311595fc66e17422fcfceb6cf58ac50dafadfa92c6cd3cfead022c8beb7c1875f9cb2e3a0db39696b6160e8d51abaf2fad671ad7a5cef60ef670c6
-  data.tar.gz: 723cdf249ab1fec0f6f8c0e52549e37366ac605c131fb7b23b6e430db995699297b01445c34e2b6ab08c1ab8d538c180526aa508410339dfb67cbbba05278c83
+  metadata.gz: ca38fd56c66cf502830190aed494c9371571477c2d4609d93dcc942ff98b7c34503ffe34f61dda5148aa63306f1386b4b99c022d587be5cb6b19e79e103ef8f2
+  data.tar.gz: 07ff974cc3fee133d576d76cbf205422235d6cc7656ade52f0d50453c8cc0232f6d648969e6aa2d3778f15e3417f1a30b75b07e93e8124054b75b47a0c876f62

data/CHANGELOG.md

@@ -10,6 +10,13 @@
   model. Released 1.9.380.0 with the pin still at 1.9.379 (the
   vendored dylib missed the fix); this pin bump is the real ride.
 
+### Fixed — engine ride (1.9.380.2)
+
+- **Bulk XPath priming face rides (leptris/leptris-ruby#537)**:
+  `xpath_result_rows_bulk` gains the mx_context/mx_adapter birth-prime
+  parameters and marks all-native results; 1.9.380.1 shipped before
+  the PR merged, so the face rides in 1.9.380.2.
+
 ## [1.9.379.3] - 2026-10-22
 
 ### Fixed

data/ext/leptris/native/native.c

@@ -203,6 +203,10 @@ static VALUE binding_klass_for(int kind);
 static VALUE c_iteration_scope;
 static VALUE c_leptris_error;
 static VALUE c_b_document, c_b_freed, c_ffi_pointer;
+/* BulkIdentityRows resolves lazily like the binding classes: the
+ * module lives in native_layer.rb, which optional consumers load. */
+static VALUE c_bulk_rows_mark = Qundef;
+static ID id_bulk_rows_mark;
 static ID id_ptr_new, id_freed_new, id_alive;
 static ID id_iv_c_address, id_iv_document, id_iv_parent;
 static ID id_iv_mx_context, id_iv_mx_adapter, id_iv_mx_native;
@@ -221,8 +225,23 @@ struct native_node {
      * Slot beats the hash memo on repeat reads of one name. */
     VALUE attr_key, attr_val, attr_ver;
     VALUE content_val, content_ver;
+    /* Walk-read memos (leptris-ruby#530): the element name and the
+     * children list, the two reads a tree walk pays per node. The
+     * children memo is what the subtree prime (#527 machinery)
+     * fills; the version stamp retires both on any mutation. The
+     * children list is SHARED with callers until the version moves
+     * (the mutation that would invalidate it also retires the
+     * memo) — treat it as read-only, like an interned String. */
+    VALUE name_val, name_ver;
+    VALUE children_val, children_ver;
 };
 
+static VALUE columnar_node_for(VALUE document, VALUE owner_klass,
+                               void *ptr, int kind);
+static VALUE doc_klass_for_kind(VALUE document, int kind);
+static VALUE nn_prime_children_of(VALUE document, VALUE owner_klass,
+                                  void *node, VALUE ver);
+
 static void nn_mark(void *p)
 {
     struct native_node *n = p;
@@ -234,6 +253,10 @@ static void nn_mark(void *p)
         rb_gc_mark(n->attr_val);
     if (n->content_val != Qnil)
         rb_gc_mark(n->content_val);
+    if (n->name_val != Qnil)
+        rb_gc_mark(n->name_val);
+    if (n->children_val != Qnil)
+        rb_gc_mark(n->children_val);
 }
 
 static size_t nn_size(const void *p) { (void)p; return sizeof(struct native_node); }
@@ -367,7 +390,19 @@ static VALUE nn_name(VALUE self)
 {
     struct native_node *n;
     const char *s;
+    VALUE doc, ver;
+
     TypedData_Get_Struct(self, struct native_node, &nn_type, n);
+    /* Walk-memo hit (leptris-ruby#530): a repeat name read is two
+     * struct reads and a Fixnum compare — the subtree prime fills
+     * this slot ahead of the walk, so walked names never recompute
+     * (or re-intern) until the next mutation. */
+    doc = n->document;
+    if (doc != Qnil) {
+        ver = rb_ivar_get(doc, id_iv_version);
+        if (n->name_ver == ver)
+            return n->name_val;
+    }
     s = f_elem_name(n->ptr);
     /* Interned (shared, frozen) fstring: element names repeat
      * massively across a document — one RString per distinct name
@@ -375,7 +410,13 @@ static VALUE nn_name(VALUE self)
      * ~18% of consumer materialize allocations were fresh name
      * strings). Names are identifiers; nothing downstream mutates
      * them in place (renames mint new strings). */
-    return s ? rb_enc_interned_str(s, strlen(s), rb_utf8_encoding()) : Qnil;
+    VALUE name = s ? rb_enc_interned_str(s, strlen(s), rb_utf8_encoding())
+                   : Qnil;
+    if (doc != Qnil) {
+        n->name_val = name;
+        n->name_ver = ver;
+    }
+    return name;
 }
 
 static VALUE nn_content(VALUE self)
@@ -563,14 +604,43 @@ static VALUE nn_children(VALUE self)
     void **buf;
     int *kinds;
     int count, i;
-    VALUE cache, out, owner_klass;
+    VALUE cache, out, owner_klass, doc, ver;
 
     TypedData_Get_Struct(self, struct native_node, &nn_type, n);
+    /* Walk-memo hit (leptris-ruby#530): the subtree prime (or an
+     * earlier read) filled this node's list against the current
+     * mutation version — serve it, engine walk skipped. */
+    doc = n->document;
+    if (doc != Qnil) {
+        ver = rb_ivar_get(doc, id_iv_version);
+        if (n->children_ver == ver)
+            return n->children_val;
+        /* Registered-consumer documents (#340 doc-klass map = the
+         * moxml mint registration) walk whole subtrees top-down:
+         * the FIRST cold children_read trades itself for ONE
+         * subtree crossing that fills every node's name + children
+         * memo (walk_columnar machinery, native-cache identity —
+         * the primed wrappers ARE the answers later reads give).
+         * Unregistered documents keep the per-node fetch; both
+         * paths memo-store below. */
+        if (!NIL_P(doc_klass_for_kind(doc, NT_ELEMENT))) {
+            out = nn_prime_children_of(doc, rb_obj_class(self), n->ptr,
+                                       ver);
+            n->children_val = out;
+            n->children_ver = ver;
+            return out;
+        }
+    }
     count = fetch_children_two_call(n->ptr, &buf, &kinds);
     if (count <= 0) {
         ruby_xfree(buf);
         ruby_xfree(kinds);
-        return rb_ary_new2(0);
+        out = rb_ary_new2(0);
+        if (doc != Qnil) {
+            n->children_val = out;
+            n->children_ver = ver;
+        }
+        return out;
     }
 
     cache = native_cache_of(n->document);
@@ -592,6 +662,10 @@ static VALUE nn_children(VALUE self)
     }
     ruby_xfree(buf);
     ruby_xfree(kinds);
+    if (doc != Qnil) {
+        n->children_val = out;
+        n->children_ver = ver;
+    }
     return out;
 }
 
@@ -1940,18 +2014,28 @@ static VALUE nf_at_xpath_first(VALUE self, VALUE document,
  * Nodesets free the handle here (TODO.perf/22 eager discipline);
  * non-nodeset results return Qnil UNFREED — the caller keeps the
  * scalar path, whose wrap owns the free. */
-static VALUE nf_xpath_result_rows_bulk(VALUE self, VALUE document,
-                                       VALUE result_addr)
+static VALUE nf_xpath_result_rows_bulk(int argc, VALUE *argv, VALUE self)
 {
-    void *result = (void *)(uintptr_t)NUM2ULL(result_addr);
+    VALUE document, result_addr, mx_context, mx_adapter;
+    void *result;
     void **buf;
     int *kinds;
     size_t scount;
     long i, n;
     VALUE cache, out;
+    int all_native;
 
     (void)self;
     resolve_binding_classes();
+    /* Optional (context, adapter): when the consumer passes its
+     * contract state, every registered-klass row is born primed
+     * (@native is the node itself, @context/@adapter written here)
+     * and an all-native result extends with BulkIdentityRows —
+     * the consumer's per-row wrap prime disappears from the
+     * iterate-every-result lane (same triple as nn_create_element). */
+    rb_scan_args(argc, argv, "22", &document, &result_addr,
+                 &mx_context, &mx_adapter);
+    result = (void *)(uintptr_t)NUM2ULL(result_addr);
     if (f_xp_type(result) != 0) /* XPATH_NODESET only */
         return Qnil;
 
@@ -1969,6 +2053,7 @@ static VALUE nf_xpath_result_rows_bulk(VALUE self, VALUE document,
     n = (long)scount;
     out = rb_ary_new_capa(n);
     cache = binding_cache_of(document);
+    all_native = !NIL_P(mx_context);
     for (i = 0; i < n; i++) {
         void *ptr = buf[i];
         int tag;
@@ -1988,10 +2073,17 @@ static VALUE nf_xpath_result_rows_bulk(VALUE self, VALUE document,
                 node = rb_hash_aref(native_cache_of(document), key);
                 if (NIL_P(node))
                     node = mint_consumer_node(mk, document, ptr);
+                if (all_native &&
+                    !rb_ivar_defined(node, id_iv_mx_context)) {
+                    rb_ivar_set(node, id_iv_mx_native, node);
+                    rb_ivar_set(node, id_iv_mx_context, mx_context);
+                    rb_ivar_set(node, id_iv_mx_adapter, mx_adapter);
+                }
                 rb_ary_push(out, node);
                 continue;
             }
         }
+        all_native = 0;
         node = materialize_xp_entry(document, cache, result, ptr,
                                     kinds[i], (int)i);
         if (node == m_native_sentinel) {
@@ -2005,6 +2097,22 @@ static VALUE nf_xpath_result_rows_bulk(VALUE self, VALUE document,
     ruby_xfree(buf);
     ruby_xfree(kinds);
     f_xp_free(result);
+    if (all_native) {
+        /* Certificate for the consumer's fast row loop: every row
+         * is a born-primed, registered-klass identity native. The
+         * module lives in the Ruby layer (native_layer.rb) and may
+         * not be loaded on faces used without it — an unresolved
+         * mark degrades to the unmarked Array, never an error. */
+        if (c_bulk_rows_mark == Qundef) {
+            VALUE m_xml = rb_path2class("Leptris::XML");
+            c_bulk_rows_mark =
+                rb_const_defined_at(m_xml, id_bulk_rows_mark)
+                    ? rb_const_get_at(m_xml, id_bulk_rows_mark)
+                    : Qnil;
+        }
+        if (c_bulk_rows_mark != Qnil)
+            rb_extend_object(out, c_bulk_rows_mark);
+    }
     return out;
 }
 
@@ -2599,6 +2707,58 @@ static void walk_columnar_impl(VALUE document, VALUE owner_klass,
     }
 }
 
+/* ---- Subtree memo priming (leptris-ruby#530) ---------------------
+ * Registered-consumer documents (the #340 doc-klass map — moxml's
+ * mint registration) walk whole subtrees top-down, so the FIRST
+ * cold children_read fills every ELEMENT's name + children read
+ * memos in ONE crossing, reusing the walk_columnar machinery and
+ * minting through columnar_node_for (native-cache identity — the
+ * primed wrappers ARE the answers later reads hand back). Memos
+ * are version-stamped like the content memo: any mutation bumps
+ * @version and retires them subtree-wide.
+ *
+ * Conservative by construction: only ELEMENT descendants get their
+ * memos filled here (the one kind whose f_first_child chain IS its
+ * children list, the #527 contract); leaf and shell kinds keep the
+ * per-node fetch, which memo-stores the same way. The receiver's
+ * own name memo is left to nn_name (one node, once). */
+static VALUE nn_prime_children_of(VALUE document, VALUE owner_klass,
+                                  void *node, VALUE ver)
+{
+    VALUE out = rb_ary_new();
+    void *c;
+
+    for (c = f_first_child(node); c; c = f_next_sibling(c)) {
+        int kind = f_node_type(c);
+        VALUE wrapper = columnar_node_for(document, owner_klass, c, kind);
+        struct native_node *nn;
+
+        TypedData_Get_Struct(wrapper, struct native_node, &nn_type, nn);
+        if (kind == WS_NODE_ELEMENT) {
+            const char *name = f_elem_name(c);
+            nn->name_val = name ? rb_enc_interned_str(name, strlen(name),
+                                                      rb_utf8_encoding())
+                                : Qnil;
+            nn->name_ver = ver;
+            nn->children_val = nn_prime_children_of(document, owner_klass,
+                                                    c, ver);
+            nn->children_ver = ver;
+        } else if (kind != WS_NODE_DOCTYPE && kind != 9 /* DOCUMENT */) {
+            /* leaf kinds: memo the name exactly as nn_name computes
+             * it (f_elem_name answers "" for nameless kinds); their
+             * (empty) children keep the fetch path, which
+             * memo-stores the same way. */
+            const char *name = f_elem_name(c);
+            nn->name_val = name ? rb_enc_interned_str(name, strlen(name),
+                                                      rb_utf8_encoding())
+                                : Qnil;
+            nn->name_ver = ver;
+        }
+        rb_ary_push(out, wrapper);
+    }
+    return out;
+}
+
 static VALUE nf_walk_columnar(VALUE self, VALUE root)
 {
     struct native_node *n;
@@ -3715,6 +3875,7 @@ LEPTRIS_INIT_EXPORT void Init_native(void)
     id_iv_mx_context = rb_intern("@context");
     id_iv_mx_native = rb_intern("@native");
     id_iv_mx_adapter = rb_intern("@adapter");
+    id_bulk_rows_mark = rb_intern("BulkIdentityRows");
     id_iv_parent = rb_intern("@parent");
     id_iv_structure_memoizable = rb_intern("@structure_memoizable");
     id_iv_native_fast = rb_intern("@native_fast");
@@ -3823,7 +3984,7 @@ LEPTRIS_INIT_EXPORT void Init_native(void)
     rb_define_module_function(m_native, "materialize_xpath",
                               nf_materialize_xpath, 2);
     rb_define_module_function(m_native, "xpath_result_rows_bulk",
-                              nf_xpath_result_rows_bulk, 2);
+                              nf_xpath_result_rows_bulk, -1);
     rb_define_module_function(m_native, "set_binding_name",
                               nf_set_binding_name, 3);
     rb_define_module_function(m_native, "set_binding_text",

data/lib/leptris/version.rb

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

data/lib/leptris/xml/native_layer.rb

@@ -59,6 +59,19 @@ rescue LoadError => e
   MSG
 end
 
+# Certificate module for the bulk XPath rows face: an Array extended
+# with this carries ONLY born-primed registered-klass identity natives
+# (xpath_result_rows_bulk answered with a consumer context+adapter, so
+# @native is the node itself and @context/@adapter are already set).
+# Consumers with a per-row wrap in their result loop can key a fast
+# path on it (moxml's NodeSet#each); one object per native address
+# remains the binding's native-cache contract (#529) either way.
+module Leptris::XML::BulkIdentityRows
+  def bulk_identity_rows?
+    true
+  end
+end
+
 module Leptris::XML::Native
   # FFI.libleptris_candidates is the single source of truth — the
   # native layer MUST dlsym the exact image the FFI layer loaded,
@@ -118,10 +131,15 @@ class Leptris::XML::Document
   # (nodesets free the handle in C); a non-nodeset result answers
   # nil and leaves the pointer with the caller — route it through
   # Searchable.wrap_xpath_result for the scalar faces.
-  def xpath_result_rows_bulk(result_ptr)
+  # Optional (context, adapter): when the consumer passes its
+  # contract state, every registered-klass row is born primed and an
+  # all-native result extends with BulkIdentityRows — the consumer's
+  # per-row wrap prime disappears from the iterate-every-result lane.
+  def xpath_result_rows_bulk(result_ptr, mx_context = nil, mx_adapter = nil)
     Leptris::XML::Native.xpath_result_rows_bulk(
       self, result_ptr.respond_to?(:address) ? result_ptr.address
-                                             : result_ptr)
+                                             : result_ptr,
+      mx_context, mx_adapter)
   end
 
   # Builder factories that return NativeNodes (#149): one C call

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: leptris
 version: !ruby/object:Gem::Version
-  version: 1.9.380.1
+  version: 1.9.380.2
 platform: ruby
 authors:
 - Ribose Inc.