leptris 1.9.222.1-arm-linux → 1.9.222.3-arm-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c5b4eab095e1cec2d20a2966c7d07ef6088a7d2f412f0e7e1910a54099d76416
-  data.tar.gz: 339ad816465350ca84ca28fdc4955bb047c488758fd87c43eb3f3d4c13d0b266
+  metadata.gz: 7532c10f6daec3e59677e99c9f0159e0aa724c2755a6e86f66093c86f5895ccb
+  data.tar.gz: 668e020302bd7472c9f997bf511f9492d0631265e53727b580ff45ed3a1c39a0
 SHA512:
-  metadata.gz: 5ab816b1b94f5571c59c49522192ef92dfd2cc5c7ef2bb219171edd1b726fe313cdac3a85f6199df82a2ef07c8bd35ca80977fd0df9dda0d189de385cf37dc8a
-  data.tar.gz: ae6eb3c963cddea9341e80e1b8316566f08cfa9d431b43f8feb45b51ccd84c90e1066dc9c9abb7cf7fb914221eb7dea084d596fa3e44d3274b983040c8d7c1de
+  metadata.gz: e4d37b6a7f25c6704ff4e4fce1184e69f8daace1f36e99c330985e6f4f61b1fc4fc2b1927dffd923c7d9bf95fb8009fdcebbd8c085efcd034ad93d8ee91014b0
+  data.tar.gz: 8548e4b4ea99a0ff40417f30f23ace3dcd819d2176c98f47e5ec8e7e3b973a0695b9995d87235e3b085c2853dbc005cbb4f281f9901a76567cb9278c48926939

data/ext/leptris/native/native.c

@@ -135,6 +135,9 @@ static VALUE c_iteration_scope;
 static VALUE c_leptris_error;
 static VALUE c_b_document, c_b_freed, c_ffi_pointer;
 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_structure_memoizable, id_iv_native_fast;
+static ID id_iv_pub_document, id_iv_addr_reads_fast, id_iv_node_type;
 static void check_status_c(int st);
 
 #define NT_ELEMENT 0
@@ -839,8 +842,38 @@ struct trav_state {
     VALUE err;
     void *self_ptr;
     int for_visit;
+    /* Hoisted per-walk state (was re-resolved per node): the
+     * document's wrapper cache and the iteration-scope class
+     * check. #312 item 1. */
+    VALUE cache;
+    VALUE klass_memo_flag;
 };
 
+/* Construct-or-fetch the binding wrapper for node_ptr against the
+ * per-walk hoisted cache (#312 item 1): static-ID ivar writes (no
+ * per-call string interning), the scope class check precomputed. */
+static VALUE trav_wrapper_for(struct trav_state *st, void *node_ptr,
+                              int kind)
+{
+    VALUE key = ULL2NUM((uint64_t)(uintptr_t)node_ptr);
+    VALUE node = rb_hash_aref(st->cache, key);
+    if (!NIL_P(node)) return node;
+
+    node = rb_obj_alloc(binding_klass_for(kind));
+    rb_ivar_set(node, id_iv_c_address, key);
+    rb_ivar_set(node, id_iv_document, st->document);
+    rb_ivar_set(node, id_iv_parent, Qnil);
+    VALUE fast = st->klass_memo_flag;
+    rb_ivar_set(node, id_iv_structure_memoizable, fast);
+    rb_ivar_set(node, id_iv_native_fast, fast);
+    rb_ivar_set(node, id_iv_pub_document,
+                fast == Qtrue ? st->document : Qnil);
+    rb_ivar_set(node, id_iv_addr_reads_fast, Qtrue);
+    rb_ivar_set(node, id_iv_node_type, INT2FIX(kind));
+    rb_hash_aset(st->cache, key, node);
+    return node;
+}
+
 static VALUE trav_yield_one(VALUE arg)
 {
     return rb_yield(arg);
@@ -849,33 +882,13 @@ static VALUE trav_yield_one(VALUE arg)
 static int trav_cb(void *node_ptr, void *user)
 {
     struct trav_state *st = user;
-    VALUE cache, key, node;
+    VALUE node;
     int kind, state;
 
     if (st->err != Qnil)
         return 1;
     kind = f_node_type(node_ptr);
-    cache = binding_cache_of(st->document);
-    key = ULL2NUM((uint64_t)(uintptr_t)node_ptr);
-    node = rb_hash_aref(cache, key);
-    if (NIL_P(node)) {
-        node = rb_obj_alloc(binding_klass_for(kind));
-        rb_iv_set(node, "@c_address", key);
-        rb_iv_set(node, "@document", st->document);
-        rb_iv_set(node, "@parent", Qnil);
-        if (rb_obj_class(st->document) == c_iteration_scope) {
-            rb_iv_set(node, "@structure_memoizable", Qfalse);
-            rb_iv_set(node, "@native_fast", Qfalse);
-            rb_iv_set(node, "@pub_document", Qnil);
-        } else {
-            rb_iv_set(node, "@structure_memoizable", Qtrue);
-            rb_iv_set(node, "@native_fast", Qtrue);
-            rb_iv_set(node, "@pub_document", st->document);
-        }
-        rb_iv_set(node, "@addr_reads_fast", Qtrue);
-        rb_iv_set(node, "@node_type", INT2FIX(kind));
-        rb_hash_aset(cache, key, node);
-    }
+    node = trav_wrapper_for(st, node_ptr, kind);
     rb_protect(trav_yield_one, node, &state);
     if (state) {
         st->err = rb_errinfo();
@@ -894,6 +907,9 @@ static VALUE nf_traverse_binding(VALUE self, VALUE document,
     st.document = document;
     st.err = Qnil;
     st.self_ptr = (void *)(uintptr_t)NUM2ULL(addr);
+    st.cache = binding_cache_of(document);
+    st.klass_memo_flag =
+        rb_obj_class(document) == c_iteration_scope ? Qfalse : Qtrue;
     st.for_visit = 0;
     f_node_traverse(st.self_ptr, 1 /* TRAVERSE_POST_ORDER */,
                     trav_cb, &st);
@@ -922,33 +938,13 @@ static void visit_cb(void *user, void *node_ptr, int entering,
      * happens after the walk, same observable outcome. */
     struct trav_state *st = user;
     struct visit_yield_args va;
-    VALUE cache, key, node;
+    VALUE node;
     int kind, state;
 
     if (st->err != Qnil)
         return;
     kind = f_node_type(node_ptr);
-    cache = binding_cache_of(st->document);
-    key = ULL2NUM((uint64_t)(uintptr_t)node_ptr);
-    node = rb_hash_aref(cache, key);
-    if (NIL_P(node)) {
-        node = rb_obj_alloc(binding_klass_for(kind));
-        rb_iv_set(node, "@c_address", key);
-        rb_iv_set(node, "@document", st->document);
-        rb_iv_set(node, "@parent", Qnil);
-        if (rb_obj_class(st->document) == c_iteration_scope) {
-            rb_iv_set(node, "@structure_memoizable", Qfalse);
-            rb_iv_set(node, "@native_fast", Qfalse);
-            rb_iv_set(node, "@pub_document", Qnil);
-        } else {
-            rb_iv_set(node, "@structure_memoizable", Qtrue);
-            rb_iv_set(node, "@native_fast", Qtrue);
-            rb_iv_set(node, "@pub_document", st->document);
-        }
-        rb_iv_set(node, "@addr_reads_fast", Qtrue);
-        rb_iv_set(node, "@node_type", INT2FIX(kind));
-        rb_hash_aset(cache, key, node);
-    }
+    node = trav_wrapper_for(st, node_ptr, kind);
     va.node = node;
     va.entering = entering ? Qtrue : Qfalse;
     va.depth = INT2NUM(depth);
@@ -966,6 +962,9 @@ static VALUE nf_visit_binding(VALUE self, VALUE document, VALUE addr)
     st.document = document;
     st.err = Qnil;
     st.self_ptr = (void *)(uintptr_t)NUM2ULL(addr);
+    st.cache = binding_cache_of(document);
+    st.klass_memo_flag =
+        rb_obj_class(document) == c_iteration_scope ? Qfalse : Qtrue;
     st.for_visit = 1;
     f_node_visit(st.self_ptr, visit_cb, &st);
     if (st.err != Qnil)
@@ -2150,6 +2149,34 @@ static VALUE nf_plan_structs_typed_p(VALUE self)
     return Qtrue;
 }
 
+/* ---- Bulk attribute rows (leptris-ruby#278) ----------------------
+ * One C crossing per element: walks the attribute chain and
+ * returns a flat [name, value, address, ...] array. Names
+ * interned (they repeat), values fresh UTF-8 strings, addresses
+ * as Integers for Attr c_handle reconstruction. Identical data
+ * to the per-attribute FFI chain (first/next/get_name/get_value,
+ * 4 crossings each) — the win amplifies with attribute density
+ * (40-attr elements: ~7x on the listing). */
+static VALUE nf_attribute_rows(VALUE self, VALUE document, VALUE addr)
+{
+    (void)self;
+    (void)document;
+    void *node = (void *)(uintptr_t)NUM2ULL(addr);
+    VALUE out = rb_ary_new();
+    if (f_node_type(node) != WS_NODE_ELEMENT) return out;
+
+    for (void *a = f_attr_first(node); a; a = f_attr_next(a)) {
+        const char *an = f_attr_name(a);
+        const char *av = f_attr_value(node, a);
+        rb_ary_push(out, an ? rb_enc_interned_str(an, strlen(an),
+                                                  rb_utf8_encoding())
+                            : Qnil);
+        rb_ary_push(out, av ? rb_utf8_str_new_cstr(av) : Qnil);
+        rb_ary_push(out, ULL2NUM((uintptr_t)a));
+    }
+    return out;
+}
+
 static VALUE nf_plan_structs(VALUE self, VALUE document, VALUE addr,
                              VALUE spec)
 {
@@ -2620,6 +2647,14 @@ LEPTRIS_INIT_EXPORT void Init_native(void)
     id_iv_c_address = rb_intern("@c_address");
     id_iv_native_cache = rb_intern("@native_cache");
     id_iv_binding_cache = rb_intern("@wrapper_cache");
+    id_iv_c_address = rb_intern("@c_address");
+    id_iv_document = rb_intern("@document");
+    id_iv_parent = rb_intern("@parent");
+    id_iv_structure_memoizable = rb_intern("@structure_memoizable");
+    id_iv_native_fast = rb_intern("@native_fast");
+    id_iv_pub_document = rb_intern("@pub_document");
+    id_iv_addr_reads_fast = rb_intern("@addr_reads_fast");
+    id_iv_node_type = rb_intern("@node_type");
     id_iv_version = rb_intern("@version");
     id_iv_readonly = rb_intern("@readonly");
     id_address = rb_intern("address");
@@ -2732,6 +2767,8 @@ LEPTRIS_INIT_EXPORT void Init_native(void)
                               nf_attribute_pairs, 2);
     rb_define_module_function(m_native, "plan_structs",
                               nf_plan_structs, 3);
+    rb_define_module_function(m_native, "attribute_rows",
+                              nf_attribute_rows, 2);
     rb_define_module_function(m_native, "plan_structs_typed?",
                               nf_plan_structs_typed_p, 0);
     rb_define_module_function(m_native, "doc_handle_attach",

data/lib/leptris/version.rb

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

data/lib/leptris/xml/element.rb

@@ -311,7 +311,11 @@ class Leptris::XML::Element < Leptris::XML::Node
 
   def attribute_nodes
     return @attribute_nodes if memo_hit?(@attribute_nodes_version)
-    result = each_attribute.to_a
+    result = if NATIVE_ATTR_ROWS && @c_address && @document
+               attribute_rows_native
+             else
+               each_attribute.to_a
+             end
     if @document
       @attribute_nodes = result
       @attribute_nodes_version = @document.version
@@ -319,6 +323,26 @@ class Leptris::XML::Element < Leptris::XML::Node
     result
   end
 
+  # One C crossing per element (leptris-ruby#278): the native face
+  # walks the attribute chain and returns flat [name, value,
+  # address] triples; the Attr value objects are minted from them
+  # with zero further engine crossings — identical objects to
+  # each_attribute. The win amplifies with attribute density
+  # (40-attr elements list ~7x faster than the chain).
+  def attribute_rows_native
+    ::Leptris::XML::Native.attribute_rows(@document, @c_address)
+      .each_slice(3)
+      .map do |name, value, handle|
+        ::Leptris::XML::Attr.new(name, value, self,
+                                 c_handle: ::FFI::Pointer.new(handle))
+      end
+  end
+
+  NATIVE_ATTR_ROWS =
+    defined?(::Leptris::XML::Native) &&
+    ::Leptris::XML::Native.respond_to?(:attribute_rows)
+  private_constant :NATIVE_ATTR_ROWS
+
   # The element's own namespace prefix (e.g. "foo" for <foo:child/>),
   # or nil when the element has none.
   def prefix

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: leptris
 version: !ruby/object:Gem::Version
-  version: 1.9.222.1
+  version: 1.9.222.3
 platform: arm-linux
 authors:
 - Ribose Inc.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-09-22 00:00:00.000000000 Z
+date: 2026-09-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi