leptris 1.9.232.0-arm-linux → 1.9.237.0-arm-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '059fd6d664035f84522042a8f01d847000b9a03bd6b379c635df6de21c78966b'
-  data.tar.gz: f28cdfb00cb59d3077965ac76eb98c7a8804594b2b0695ff562f9c086ab8be60
+  metadata.gz: deb8e8ccbebd0bcca9030a8c605a7590e8a035b1c59422a29762b90d2834cc1c
+  data.tar.gz: 3124a00c5d8c965dd798c84ee19b3d6d0a020b1ff624a38c2ea5eb3002e58520
 SHA512:
-  metadata.gz: b255f974356722b350c48ea587590308c548f53d7b27686594d139b40202c028e609a4981bfab2db28adbf1375c3a5bc2f75ee86c060573342ba41c5122ef7c1
-  data.tar.gz: 7f08ae010ae2909f75b12a396a370b8c36d70833182c5af515f05b0776e61d34d55396bd3e8b05d431644359a2a1bbe648d7ddb415fb49152f2ae44e07c35b55
+  metadata.gz: 240fa4a1440c291f6cdbc8093fc8a14f43cd38ae81ef1a84519b7ae38be84c5d6ef1a3223c911035aa3f8b52811557829dd4aed456a2524cf55799034dffcf93
+  data.tar.gz: 69e0a10c76deb0970fd40b5bdd81ab57799c9d4ef090b1a4545414b8b0aa7fe343bdf28fa420c613f56946421367cc8898795e88661c19a5bb639019ba6e993c

data/CHANGELOG.md

@@ -5,6 +5,31 @@ All notable changes to Leptris will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.9.237.0] - 2026-09-24
+
+### Added
+
+- `Document#create_element` accepts an attributes hash:
+  `doc.create_element("book", "id" => "1", "lang" => "en")` creates
+  the element with every attribute in ONE engine crossing
+  (leptris_element_new_with_attributes, #1344) — builder paths
+  collapse from 1 + N crossings to one. Duplicate names replace,
+  last wins; `nil` values store the empty string (engine
+  semantics). The native face falls back to create + per-pair sets
+  on pins predating #1344.
+
+### Performance — engine sync (1.9.237)
+
+- Vendored libleptris 1.9.237: typed atoms for QT3 equality
+  (typed constructors, float32, the xs: constructor surface),
+  per-function equality semantics (index-of/distinct-values/
+  deep-equal), the F&O fn:subsequence window with NaN safety and
+  member-type preservation, the xpath per-eval registry init fix,
+  QT3 slice 3 (405 gated cases), the matched-shape traversal
+  benchmark correction (#1341: the structural gap vs libxml2 is
+  1.5-1.7x, not 1.8-4.2x), and the single-crossing element
+  constructor (#1344).
+
 ## [1.9.232.0] - 2026-09-24
 
 ### Added

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.232"
+LIBLEPTRIS_VERSION = "1.9.237"
 # 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/ext/leptris/native/native.c

@@ -42,6 +42,8 @@ typedef size_t (*node_offset_fn)(void *);
 typedef const char *(*element_text_fn)(void *);
 typedef void *(*doc_create_fn)(void);
 typedef void *(*elem_create_fn)(void *, const char *);
+typedef void *(*elem_new_attrs_fn)(void *, const char *, const char **,
+                                   const char **, size_t);
 typedef void *(*text_create_fn)(void *, const char *);
 typedef void *(*create_child_fn)(void *, const char *);
 typedef int (*append_child_fn)(void *, void *);
@@ -75,10 +77,14 @@ static node_offset_fn f_node_offset;
 static element_text_fn f_element_text;
 static doc_create_fn f_doc_create;
 static elem_create_fn f_elem_create;
+static elem_new_attrs_fn f_elem_new_with_attrs;
 static text_create_fn f_text_create;
 static create_child_fn f_create_child;
 static append_child_fn f_append_child;
 static append_child_fn f_prepend_child, f_insert_after, f_insert_before;
+typedef void *(*elem_new_attrs_fn)(void *, const char *, const char **,
+                                   const char **, size_t);
+static elem_new_attrs_fn f_elem_new_with_attrs;
 static set_attr_fn f_set_attr;
 typedef int (*xp_type_fn)(void *);
 typedef void (*xp_free_fn)(void *);
@@ -218,6 +224,11 @@ static void resolve_symbols(const char *lib_path)
     f_element_text = (element_text_fn)lib_sym(h, "leptris_element_text");
     f_doc_create = (doc_create_fn)lib_sym(h, "leptris_document_create");
     f_elem_create = (elem_create_fn)lib_sym(h, "leptris_element_create");
+    /* Single-crossing element construction (libleptris 1.9.237,
+     * #1344): NULL in older engine pins; the create path falls
+     * back to create + per-pair sets. */
+    f_elem_new_with_attrs =
+        (elem_new_attrs_fn)lib_sym(h, "leptris_element_new_with_attributes");
     f_text_create = (text_create_fn)lib_sym(h, "leptris_text_node_create");
     f_create_child = (create_child_fn)lib_sym(h, "leptris_element_create_child");
     f_append_child = (append_child_fn)lib_sym(h, "leptris_element_append_child");
@@ -225,6 +236,11 @@ static void resolve_symbols(const char *lib_path)
     f_insert_after = (append_child_fn)lib_sym(h, "leptris_element_insert_after");
     f_insert_before = (append_child_fn)lib_sym(h, "leptris_element_insert_before");
     f_set_attr = (set_attr_fn)lib_sym(h, "leptris_element_set_attribute");
+    /* Engine single-crossing construction (leptris#1344, 1.9.236+):
+     * optional; absent engines use the create_child + set_attr
+     * loop, which is still one Ruby->C crossing. */
+    f_elem_new_with_attrs =
+        (elem_new_attrs_fn)lib_sym(h, "leptris_element_new_with_attributes");
     f_xp_type = (xp_type_fn)lib_sym(h, "leptris_xpath_result_type");
     f_xp_free = (xp_free_fn)lib_sym(h, "leptris_xpath_result_free");
     f_first_child = (first_child_fn)lib_sym(h, "leptris_node_first_child");
@@ -1638,15 +1654,88 @@ static VALUE nf_bulk_attributes(VALUE self, VALUE addr)
 /* ---- Binding create via C (TODO.perf/09): one call creates the
  * node AND constructs the binding wrapper (class dispatch, ivars,
  * identity-cache store) — no FFI marshaling, no wrap_fresh path. */
+static int set_attr_pair(VALUE key, VALUE value, VALUE data)
+{
+    void *elem =
+        (void *)(uintptr_t)NUM2ULL(rb_ary_entry(data, 0));
+    VALUE k = RB_TYPE_P(key, T_STRING) ? key : rb_obj_as_string(key);
+    VALUE v = NIL_P(value) ? rb_usascii_str_new(0, 0)
+                           : (RB_TYPE_P(value, T_STRING) ? value
+                                                         : rb_obj_as_string(value));
+
+    rb_ary_push(rb_ary_entry(data, 1), k);
+    rb_ary_push(rb_ary_entry(data, 2), v);
+    f_set_attr(elem, RSTRING_PTR(k), RSTRING_PTR(v));
+    return ST_CONTINUE;
+}
+
 static VALUE nf_create_binding_element(VALUE self, VALUE document,
-                                       VALUE name)
+                                       VALUE name, VALUE attrs)
 {
     void *doc = doc_ptr_of(document);
-    void *ptr = f_elem_create(doc, RSTRING_PTR(StringValue(name)));
+    void *ptr;
+    VALUE name_str = StringValue(name);
     VALUE node, cache, key;
 
     (void)self;
     resolve_binding_classes();
+    if (attrs == Qnil ||
+        (RB_TYPE_P(attrs, T_HASH) && RHASH_SIZE(attrs) == 0)) {
+        ptr = f_elem_create(doc, RSTRING_PTR(name_str));
+    } else if (f_elem_new_with_attrs != NULL) {
+        /* #1344: element + every attribute in ONE crossing.
+         * Duplicate names replace, last wins; NULL values store
+         * the empty string — engine semantics, identical to
+         * per-pair set_attribute.
+         *
+         * Iteration goes through keys + aref (no rb_hash_foreach
+         * state pointer): every converted key/value is pushed into
+         * Ruby arrays BEFORE its pointer enters the C arrays, so
+         * temporaries (non-String keys, nil -> "") survive until
+         * the engine call returns — no C pointer rides through a
+         * boxed VALUE (long is 32-bit on Windows/LLP64; the
+         * foreach+boxed-struct shape truncated it and segfaulted
+         * the windows CI leg). */
+        VALUE keys, names, values;
+        const char **np, **vp;
+        long cap, i;
+        Check_Type(attrs, T_HASH);
+        cap = (long)RHASH_SIZE(attrs);
+        keys = rb_funcall(attrs, rb_intern("keys"), 0);
+        names = rb_ary_new_capa(cap);
+        values = rb_ary_new_capa(cap);
+        np = ruby_xmalloc(sizeof(char *) * (cap + 1));
+        vp = ruby_xmalloc(sizeof(char *) * (cap + 1));
+        for (i = 0; i < cap; i++) {
+            VALUE k = rb_ary_entry(keys, i);
+            VALUE v = rb_hash_aref(attrs, k);
+            k = RB_TYPE_P(k, T_STRING) ? k : rb_obj_as_string(k);
+            v = NIL_P(v) ? rb_usascii_str_new(0, 0)
+                         : (RB_TYPE_P(v, T_STRING) ? v
+                                                   : rb_obj_as_string(v));
+            rb_ary_push(names, k);
+            rb_ary_push(values, v);
+            np[i] = RSTRING_PTR(k);
+            vp[i] = RSTRING_PTR(v);
+        }
+        ptr = f_elem_new_with_attrs(doc, RSTRING_PTR(name_str),
+                                    np, vp, (size_t)cap);
+        ruby_xfree(np);
+        ruby_xfree(vp);
+    } else {
+        /* Older pin: create + per-pair sets (N+1 crossings). */
+        VALUE addr = Qnil;
+        VALUE anchor;
+        Check_Type(attrs, T_HASH);
+        anchor = rb_ary_new_capa((long)RHASH_SIZE(attrs));
+        ptr = f_elem_create(doc, RSTRING_PTR(name_str));
+        if (!ptr)
+            return Qnil;
+        addr = ULL2NUM((uint64_t)(uintptr_t)ptr);
+        rb_hash_foreach(attrs, set_attr_pair,
+                        rb_ary_new3(3, addr, anchor,
+                                    rb_ary_new_capa(0)));
+    }
     if (!ptr)
         return Qnil; /* caller raises with the error channel */
     node = rb_obj_alloc(c_b_element);
@@ -2194,6 +2283,56 @@ static VALUE nf_plan_structs_typed_p(VALUE self)
  * 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). */
+/* ---- Single-crossing element construction (leptris#1344) --------
+ * Creates an element attached under parent (parent_addr 0 = free
+ *floating, owner document only) with all attributes set — ONE
+ * Ruby->C crossing for the whole construction. Internal calls are
+ * C->C dlsym dispatches (create_child = create+attach in one
+ * engine call; set_attr per attribute). Returns the new node's
+ * address for wrapper minting. */
+static VALUE nf_create_element_with_attrs(VALUE self, VALUE document,
+                                          VALUE parent_addr, VALUE name,
+                                          VALUE attrs)
+{
+    (void)self;
+    (void)document;
+    void *parent = NIL_P(parent_addr)
+                       ? NULL
+                       : (void *)(uintptr_t)NUM2ULL(parent_addr);
+    const char *cname = StringValueCStr(name);
+
+    if (f_elem_new_with_attrs && parent && RARRAY_LEN(attrs) > 0 &&
+        RARRAY_LEN(attrs) % 2 == 0) {
+        /* Engine single-crossing construction (1.9.236+): arena
+         * create + all attributes with no per-attr calls at all. */
+        long n = RARRAY_LEN(attrs) / 2;
+        const char **names = ALLOCA_N(const char *, n);
+        const char **values = ALLOCA_N(const char *, n);
+        for (long i = 0; i < n; i++) {
+            /* Hoist to lvalues: truffleruby's StringValueCStr takes
+             * the address of its argument (RARRAY_AREF is not one). */
+            VALUE an = RARRAY_AREF(attrs, 2 * i);
+            VALUE av = RARRAY_AREF(attrs, 2 * i + 1);
+            names[i] = StringValueCStr(an);
+            values[i] = StringValueCStr(av);
+        }
+        void *elem = f_elem_new_with_attrs(parent, cname, names, values,
+                                           n);
+        return elem ? ULL2NUM((uintptr_t)elem) : Qnil;
+    }
+
+    void *elem = parent ? f_create_child(parent, cname) : NULL;
+    if (!elem) return Qnil;
+
+    long i, n = RARRAY_LEN(attrs);
+    for (i = 0; i + 1 < n; i += 2) {
+        VALUE an = RARRAY_AREF(attrs, i);
+        VALUE av = RARRAY_AREF(attrs, i + 1);
+        f_set_attr(elem, StringValueCStr(an), StringValueCStr(av));
+    }
+    return ULL2NUM((uintptr_t)elem);
+}
+
 static VALUE nf_attribute_rows(VALUE self, VALUE document, VALUE addr)
 {
     (void)self;
@@ -2808,6 +2947,8 @@ LEPTRIS_INIT_EXPORT void Init_native(void)
                               nf_plan_structs, 3);
     rb_define_module_function(m_native, "attribute_rows",
                               nf_attribute_rows, 2);
+    rb_define_module_function(m_native, "create_element_with_attrs",
+                              nf_create_element_with_attrs, 4);
     rb_define_module_function(m_native, "plan_structs_typed?",
                               nf_plan_structs_typed_p, 0);
     rb_define_module_function(m_native, "doc_handle_attach",
@@ -2822,7 +2963,7 @@ LEPTRIS_INIT_EXPORT void Init_native(void)
     rb_define_module_function(m_native, "bulk_attr_faces",
                               nf_bulk_attr_faces, 2);
     rb_define_module_function(m_native, "create_binding_element",
-                              nf_create_binding_element, 2);
+                              nf_create_binding_element, 3);
     rb_define_module_function(m_native, "create_binding_text",
                               nf_create_binding_text, 2);
     rb_define_module_function(m_native, "bulk_children", nf_bulk_children, 2);

data/lib/leptris/version.rb

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

data/lib/leptris/xml/document.rb

@@ -389,15 +389,32 @@ class Leptris::XML::Document
     element
   end
 
-  def create_element(name)
+  # attributes: optional Hash of {name => value} applied in the
+  # SAME engine crossing as construction
+  # (leptris_element_new_with_attributes, #1344) — builder paths
+  # collapse from 1 + N crossings to one. nil values store the
+  # empty string; duplicate names replace, last wins (engine
+  # semantics, identical to per-pair set_attribute).
+  def create_element(name, attributes = nil)
     # TODO.perf/09: one C call creates + wraps when the ext is
     # loaded — no FFI marshaling, no wrap_fresh frames.
     if defined?(Leptris::XML::NATIVE_FAST)
-      node = Leptris::XML::Native.create_binding_element(self, name.to_s)
+      node = Leptris::XML::Native.create_binding_element(
+        self, name.to_s, attributes)
       raise Leptris::XML::Error, "leptris_element_create failed" if node.nil?
       return node
     end
-    ptr = Leptris::XML::FFI.leptris_element_create(c_ptr, name)
+    ptr =
+      if attributes && !attributes.empty?
+        names = attributes.map { |k, _| k.to_s }
+        values = attributes.map { |_, v| v.nil? ? "" : v.to_s }
+        nb, na = Leptris::XML::CStringArray.to_c(names)
+        vb, va = Leptris::XML::CStringArray.to_c(values)
+        Leptris::XML::FFI.leptris_element_new_with_attributes(
+          c_ptr, name.to_s, nb, vb, names.size)
+      else
+        Leptris::XML::FFI.leptris_element_create(c_ptr, name)
+      end
     raise Leptris::XML::Error, "leptris_element_create failed" if ptr.null?
     Leptris::XML::Node.wrap_fresh(ptr, self, Leptris::XML::FFI::NODE_ELEMENT)
   end