leptris 1.9.379.2-aarch64-linux → 1.9.379.3-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b235f58e7de7780990dc11862d1bce77ee33220cb3f0ee61e9124ded829f080d
-  data.tar.gz: be5340e4be9d94703638eb74f13f80ccef66f5a8eac3ddb28f9fd9857ef1db95
+  metadata.gz: 1eb86fa70776ca573401c3ce7ce1527c99cb53f77de2ac5cbeeb885b411eca1f
+  data.tar.gz: e646310bc3c27e611d3a214ca2066c25333a8af911b005a6776c6c813661a6ec
 SHA512:
-  metadata.gz: 1423256a4aa9d071f1441beb8cd48bbc0a5733d8d4bf7363f7135f9872dba50edae6b30e1ddc4353665fa06502087d07e5451a69e8be130cfd05327a33b42bc6
-  data.tar.gz: c59457e85190260d802ecf401d088c0f789235549c20350310d1dfd013dd370d556719507c16673818b2cbf07d2f532e4df4471125090ca1c4bcaa172cfa8d7d
+  metadata.gz: c3cc002aa4ebd2122e636e1e6aff445ffbcab4acf5af84272e0e0d0d1082d6f8b665cd76291383aed71581eeedf5f47bebc71b04ab1c42ded249c7c6e63ff2e9
+  data.tar.gz: 22e6b9b866b6652786edb988295dddd97c7d7ab7b9e41c67cb51f07e9853f29c5315c2f88239536fc9ff57ccb22d8637c443939df66862549049d8bdbe0fb7e7

data/CHANGELOG.md

@@ -1,3 +1,20 @@
+## [1.9.379.3] - 2026-10-22
+
+### Fixed
+
+- **attribute_nodes desync after interleaved bare-name writes
+  (leptris/leptris-ruby#526, PR #533)**: a cold bare-name `[]` read
+  nil'd the attribute_nodes/keys/values memos but restamped only the
+  attributes version, so the sibling faces served a stamped nil.
+  Dropped faces now drop their stamps; a `key?` partial-fill hole
+  found by the same 2000-trial sweep is fixed too.
+
+### Added — native layer
+
+- **Bulk XPath materialization (PR #531)**:
+  `xpath_result_rows_bulk` returns the whole node-set as registered
+  NativeNodes in one C crossing.
+
 ## [1.9.379.2] - 2026-10-21
 
 ### Added — native layer

data/ext/leptris/native/native.c

@@ -1925,6 +1925,89 @@ static VALUE nf_at_xpath_first(VALUE self, VALUE document,
     return node;
 }
 
+/* ---- Bulk XPath rows as registered NativeNodes (#529) ----------
+ * The consumer's iterate-every-row lane pays ONE FFI crossing and
+ * one Ruby wrapper mint PER result row. This face materializes the
+ * whole nodeset in a single call: every real tree node mints
+ * through the document's registered wrapper klasses (#340) and the
+ * native identity cache — the same mint the walk and create faces
+ * use, cache-checked so one address is one Ruby object — so rows
+ * arrive already carrying the consumer's contract, with no
+ * Ruby-visible per-row call. Entries the consumer-klass path can't
+ * represent (synthetic attribute rows, sequence-carrier text,
+ * namespaces, unregistered documents) keep the shared per-entry
+ * binding materializer, exactly what the eager path minted before.
+ * 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)
+{
+    void *result = (void *)(uintptr_t)NUM2ULL(result_addr);
+    void **buf;
+    int *kinds;
+    size_t scount;
+    long i, n;
+    VALUE cache, out;
+
+    (void)self;
+    resolve_binding_classes();
+    if (f_xp_type(result) != 0) /* XPATH_NODESET only */
+        return Qnil;
+
+    scount = f_xp_count(result);
+    if (scount == 0) {
+        f_xp_free(result);
+        return rb_ary_new2(0);
+    }
+    buf = ruby_xmalloc(scount * sizeof(void *));
+    kinds = ruby_xmalloc(scount * sizeof(int));
+    /* The batch accessor compacts (invalid pointers skip) — n is
+     * the row count AND the index space the name/value accessors
+     * answer on. */
+    scount = f_xp_nodes_ex(result, buf, kinds, scount);
+    n = (long)scount;
+    out = rb_ary_new_capa(n);
+    cache = binding_cache_of(document);
+    for (i = 0; i < n; i++) {
+        void *ptr = buf[i];
+        int tag;
+        VALUE node, key;
+
+        if (ptr == NULL)
+            continue;
+        /* The unified tag space (#477) classifies every entry from
+         * the node word itself: 0..5 real tree kinds — the same
+         * ints the doc-klass map is indexed by — 6/7/8 synthetic
+         * attribute/namespace/text. */
+        tag = (int)f_node_type(ptr);
+        key = ULL2NUM((uint64_t)(uintptr_t)ptr);
+        if (tag >= WS_NODE_ELEMENT && tag <= WS_NODE_DOCTYPE) {
+            VALUE mk = doc_klass_for_kind(document, tag);
+            if (!NIL_P(mk)) {
+                node = rb_hash_aref(native_cache_of(document), key);
+                if (NIL_P(node))
+                    node = mint_consumer_node(mk, document, ptr);
+                rb_ary_push(out, node);
+                continue;
+            }
+        }
+        node = materialize_xp_entry(document, cache, result, ptr,
+                                    kinds[i], (int)i);
+        if (node == m_native_sentinel) {
+            /* Rare kind the entry materializer defers (namespace
+             * rows): mint the plain native twin instead of leaking
+             * the module sentinel into consumer-visible rows. */
+            node = wrap_new(document, ptr);
+        }
+        rb_ary_push(out, node);
+    }
+    ruby_xfree(buf);
+    ruby_xfree(kinds);
+    f_xp_free(result);
+    return out;
+}
+
 /* ---- Bulk attribute materialization (TODO.perf/10) ---------------
  * Element#attributes / #keys / #values walk the attribute list
  * one FFI call per row (name + value). One C pass builds the
@@ -2444,6 +2527,92 @@ static VALUE nf_snapshot_rows(VALUE self, VALUE document, VALUE addr)
     return out;
 }
 
+/* ---- Columnar preorder walk (leptris-ruby#527) -------------------
+ * The moxml cold walk crossed the boundary once per element
+ * (children_read + name_read per node, ~23% of cold-walk
+ * samples). walk_columnar returns a WHOLE subtree's walk data in
+ * ONE crossing: [names, handles, depths] — three parallel arrays,
+ * preorder, the addressed node at depth 0.
+ *
+ * names: interned (frozen, shared) fstrings for elements, nil for
+ * the child kinds with no name (text/comment/cdata/pi) — the same
+ * discipline as nn_name, so repeat names allocate zero.
+ * handles: NativeNodes (TypedData path) minted through the
+ * doc-klass map (#340) when the document registered wrapper
+ * klasses, else the kind-resolved NativeNode subclasses — every
+ * mint lands in the document's native-cache identity, so handles
+ * here ARE the children_read/visit wrappers and re-walks return
+ * identical objects.
+ * depths: root-relative ints; document/doctype receivers walk
+ * their children at depth 0 (same entry rule as snapshot_rows). */
+static VALUE columnar_node_for(VALUE document, VALUE owner_klass,
+                               void *ptr, int kind)
+{
+    VALUE key = ULL2NUM((uint64_t)(uintptr_t)ptr);
+    VALUE cache = native_cache_of(document);
+    VALUE node = rb_hash_aref(cache, key);
+    struct native_node *n;
+
+    if (!NIL_P(node)) return node;
+    VALUE mk = doc_klass_for_kind(document, kind);
+    if (!NIL_P(mk))
+        return mint_consumer_node(mk, document, ptr);
+    node = nn_allocate(klass_for_kind(owner_klass, kind));
+    TypedData_Get_Struct(node, struct native_node, &nn_type, n);
+    n->ptr = ptr;
+    n->document = document;
+    rb_hash_aset(cache, key, node);
+    return node;
+}
+
+static void walk_columnar_impl(VALUE document, VALUE owner_klass,
+                               void *node, int depth, VALUE names,
+                               VALUE handles, VALUE depths)
+{
+    int kind = f_node_type(node);
+    void *c;
+
+    if (kind == WS_NODE_ELEMENT) {
+        const char *name = f_elem_name(node);
+        rb_ary_push(names, name
+                               ? rb_enc_interned_str(name, strlen(name),
+                                                     rb_utf8_encoding())
+                               : Qnil);
+        rb_ary_push(handles, columnar_node_for(document, owner_klass,
+                                               node, kind));
+        rb_ary_push(depths, INT2NUM(depth));
+        for (c = f_first_child(node); c; c = f_next_sibling(c)) {
+            walk_columnar_impl(document, owner_klass, c, depth + 1,
+                               names, handles, depths);
+        }
+    } else if (kind == WS_NODE_TEXT || kind == WS_NODE_COMMENT ||
+               kind == WS_NODE_CDATA || kind == WS_NODE_PI) {
+        rb_ary_push(names, Qnil);
+        rb_ary_push(handles, columnar_node_for(document, owner_klass,
+                                               node, kind));
+        rb_ary_push(depths, INT2NUM(depth));
+    } else if (kind == WS_NODE_DOCTYPE || kind == 9 /* DOCUMENT */) {
+        for (c = f_first_child(node); c; c = f_next_sibling(c)) {
+            walk_columnar_impl(document, owner_klass, c, depth,
+                               names, handles, depths);
+        }
+    }
+}
+
+static VALUE nf_walk_columnar(VALUE self, VALUE root)
+{
+    struct native_node *n;
+    VALUE names, handles, depths;
+    (void)self;
+    TypedData_Get_Struct(root, struct native_node, &nn_type, n);
+    names = rb_ary_new();
+    handles = rb_ary_new();
+    depths = rb_ary_new();
+    walk_columnar_impl(n->document, rb_obj_class(root), n->ptr, 0,
+                       names, handles, depths);
+    return rb_ary_new3(3, names, handles, depths);
+}
+
 /* ---- Struct plan executor (moxml "miles faster" round) ------------
  * The consumer's shape compiles to spec: name (interned String) ->
  * [Struct class, attrs Hash (name -> slot Symbol), text slot Symbol
@@ -3653,6 +3822,8 @@ LEPTRIS_INIT_EXPORT void Init_native(void)
                               nf_at_xpath_first, 2);
     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);
     rb_define_module_function(m_native, "set_binding_name",
                               nf_set_binding_name, 3);
     rb_define_module_function(m_native, "set_binding_text",
@@ -3697,6 +3868,8 @@ LEPTRIS_INIT_EXPORT void Init_native(void)
                               nf_snapshot_subtree, 2);
     rb_define_module_function(m_native, "snapshot_rows",
                               nf_snapshot_rows, 2);
+    rb_define_module_function(m_native, "walk_columnar",
+                              nf_walk_columnar, 1);
     rb_define_module_function(m_native, "attribute_pairs",
                               nf_attribute_pairs, 2);
     rb_define_module_function(m_native, "plan_structs",

data/lib/leptris/version.rb

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

data/lib/leptris/xml/element.rb

@@ -117,6 +117,14 @@ class Leptris::XML::Element < Leptris::XML::Node
       # Drop any full-face memos from a prior version — otherwise a
       # post-mutation cold [] would stamp the new version onto a
       # stale @attributes hash and attributes would serve it.
+      # ruby#526: only @attributes shares @attributes_version with
+      # @attr_values (both restamped below), so only it needs the
+      # drop; @attribute_nodes/@keys/@values carry their OWN stamps.
+      # Niling those WITHOUT restamping left a nil memo whose stamp
+      # still matched the (unadvanced) document version — the next
+      # attribute_nodes/keys/values call memo-hit the nil and served
+      # it (consumers reading `attribute_nodes || []` saw []).
+      # Dropping a face means dropping both halves.
       ensure_alive!
       v = if @addr_reads_fast
             Leptris::XML::Native.fast_attribute(@c_address, name)
@@ -126,8 +134,11 @@ class Leptris::XML::Element < Leptris::XML::Node
       @attr_values = { name => v }
       @attributes = nil
       @attribute_nodes = nil
+      @attribute_nodes_version = nil
       @keys = nil
+      @keys_version = nil
       @values = nil
+      @values_version = nil
       @attributes_version = @document.version
       return v
     end
@@ -188,10 +199,14 @@ class Leptris::XML::Element < Leptris::XML::Node
     # Versioned attribute memo first (TODO.perf/21): a hit proves
     # presence without the engine round-trip; the memo cannot
     # prove absence for a partial fill, so misses fall through.
+    # ruby#526 sibling: a PARTIAL fill's key proves only "queried"
+    # — the cold [] caches queried-absent names as nil, so a nil
+    # entry without the full face is ambiguous exactly as in #[]'
+    # version-matched read and must fall through to the engine.
     n = name.to_s
     values = @attr_values
     if @document && values && @attributes_version == @document.version &&
-       values.key?(n)
+       values.key?(n) && (!values[n].nil? || @attributes)
       return true
     end
     return true if Leptris::XML::FFI.leptris_element_has_attribute(

data/lib/leptris/xml/native_layer.rb

@@ -109,6 +109,21 @@ class Leptris::XML::Document
     Leptris::XML::Native.register_doc_klasses(self, map)
   end
 
+  # leptris-ruby#529: the whole XPath node-set result as an Array of
+  # NativeNodes in ONE C call — the iterate-every-row lane's bulk
+  # face. Rows mint through the registered wrapper klasses (#340)
+  # with native-cache identity; synthetic attribute/sequence rows
+  # keep the ResultAttr/ResultText wrappers the eager path minted.
+  # Takes the raw result pointer eval_ptrs returned and CONSUMES it
+  # (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)
+    Leptris::XML::Native.xpath_result_rows_bulk(
+      self, result_ptr.respond_to?(:address) ? result_ptr.address
+                                             : result_ptr)
+  end
+
   # Builder factories that return NativeNodes (#149): one C call
   # and a TypedData wrap — no FFI::Pointer, no wrap_fresh path.
   # (context, adapter) pre-writes the consumer's contract ivars in

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: leptris
 version: !ruby/object:Gem::Version
-  version: 1.9.379.2
+  version: 1.9.379.3
 platform: aarch64-linux
 authors:
 - Ribose Inc.