leptris 1.9.162.6 → 1.9.162.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d09354998670281f8e6519fa0cf7b35c467d67e7536879b31be2b3efa634250e
-  data.tar.gz: 362d92cf0e463160f94ecab7639a60d867680e47610bed4cac408dc0e835c1fb
+  metadata.gz: 57f929ff4841376940854db6d4c56ed6e5d781ca031b2c24d6d431da168e58c5
+  data.tar.gz: 31770ff680d92ae5d6ab85ca295cab3c5786fcd443cef80acfb8b20d437d6db3
 SHA512:
-  metadata.gz: 59ee84ed455a5621ab3be63c4fb54ddf3d9b42346cb32f8f9a7c967f884bb70a04cb4e3864528718b26dfe725540f05f27ec06f64c44a252f203b40ff9484d8f
-  data.tar.gz: 66d52689d9be07a40fee5739959878556f393ec0c86fb94b5e36c95ab36c38d022be579ff7189561f96f91eac972035e77e645eff0b8dae272b345dbc2f9667d
+  metadata.gz: f3e15b12e18df6ed283c9aef8971b10a779155ca823ccffe0389493776d8c03735f1130a5c47e7c4057f8c8baf1864736971fcc9a7154dec865979544452e2ea
+  data.tar.gz: e5fcb4356b6ab0e18a97f89b14db6a7da02c49f79edb95661155c2858391a75eb27b1fb49617d325730e576dbc8896debcc91ec504543f68cdbec5b92e3a3cf4

data/CHANGELOG.md

@@ -5,6 +5,19 @@ 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.162.7] - 2026-09-14
+
+### Added
+
+- **Native builder factories (#149)**: with the opt-in native
+  layer loaded, `Document#native_create_element` /
+  `#native_create_text` / `#native_root=` and
+  `NativeNode#create_child` / `#add_child` create TypedData nodes
+  in one C call — no FFI::Pointer, no wrap_fresh path. Measured
+  create_text 746->324ns (2.3x binding), 1052-node build 1948->273µs
+  (**2.3x faster than Nokogiri**). Separate `native_cache` keeps
+  binding Node.wrap identity intact.
+
 ## [1.9.162.6] - 2026-09-14
 
 ### Fixed

data/ext/leptris/native/native.c

@@ -22,6 +22,13 @@ typedef int (*node_type_fn)(void *);
 typedef void *(*next_sibling_fn)(void *);
 typedef void *(*parent_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 *(*text_create_fn)(void *, const char *);
+typedef void *(*create_child_fn)(void *, const char *);
+typedef int (*append_child_fn)(void *, void *);
+typedef int (*set_root_fn)(void *, void *);
+typedef void (*doc_free_fn)(void *);
 
 static elem_name_fn f_elem_name;
 static text_content_fn f_text_content;
@@ -31,6 +38,13 @@ static node_type_fn f_node_type;
 static next_sibling_fn f_next_sibling;
 static parent_fn f_parent;
 static element_text_fn f_element_text;
+static doc_create_fn f_doc_create;
+static elem_create_fn f_elem_create;
+static text_create_fn f_text_create;
+static create_child_fn f_create_child;
+static append_child_fn f_append_child;
+static set_root_fn f_set_root;
+static doc_free_fn f_doc_free;
 
 static VALUE c_native_node;
 static ID id_wrapper_cache;
@@ -81,9 +95,17 @@ static void resolve_symbols(const char *lib_path)
     f_next_sibling = (next_sibling_fn)lib_sym(h, "leptris_node_next_sibling");
     f_parent = (parent_fn)lib_sym(h, "leptris_node_parent");
     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");
+    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");
+    f_set_root = (set_root_fn)lib_sym(h, "leptris_document_set_root");
+    f_doc_free = (doc_free_fn)lib_sym(h, "leptris_document_free");
     if (!f_elem_name || !f_text_content || !f_attr ||
         !f_children_ex || !f_node_type || !f_next_sibling || !f_parent ||
-        !f_element_text)
+        !f_element_text || !f_doc_create || !f_elem_create || !f_text_create ||
+        !f_create_child || !f_append_child || !f_set_root || !f_doc_free)
         rb_raise(rb_eRuntimeError, "libleptris symbols missing");
 }
 
@@ -243,6 +265,96 @@ static VALUE nn_parent(VALUE self)
     return par ? wrap_cached(n, par) : Qnil;
 }
 
+/* Wrap a freshly-created C node as a NativeNode and register it
+ * in the document's identity cache. */
+static VALUE wrap_new(VALUE document, void *ptr)
+{
+    struct native_node *n;
+    VALUE node, cache, key;
+
+    node = nn_allocate(c_native_node);
+    TypedData_Get_Struct(node, struct native_node, &nn_type, n);
+    n->ptr = ptr;
+    n->document = document;
+    cache = rb_funcall(document, id_wrapper_cache, 0);
+    key = ULL2NUM((uint64_t)(uintptr_t)ptr);
+    rb_hash_aset(cache, key, node);
+    return node;
+}
+
+/* Document address from the binding Document's #c_ptr. */
+static void *doc_ptr_of(VALUE document)
+{
+    VALUE c_ptr = rb_funcall(document, rb_intern("c_ptr"), 0);
+    if (NIL_P(c_ptr))
+        rb_raise(rb_eRuntimeError, "document has been freed");
+    return (void *)(uintptr_t)NUM2ULL(rb_funcall(c_ptr, rb_intern("address"), 0));
+}
+
+/* Builder factories (#149): create in C, wrap as NativeNode — no
+ * FFI::Pointer, no Ruby wrap_fresh path. */
+static VALUE nn_create_element(VALUE klass, VALUE document, VALUE name)
+{
+    void *ptr;
+    (void)klass;
+    ptr = f_elem_create(doc_ptr_of(document), StringValueCStr(name));
+    if (!ptr)
+        rb_raise(rb_eRuntimeError, "leptris_element_create failed");
+    return wrap_new(document, ptr);
+}
+
+static VALUE nn_create_text(VALUE klass, VALUE document, VALUE content)
+{
+    void *ptr;
+    (void)klass;
+    ptr = f_text_create(doc_ptr_of(document), StringValueCStr(content));
+    if (!ptr)
+        rb_raise(rb_eRuntimeError, "leptris_text_node_create failed");
+    return wrap_new(document, ptr);
+}
+
+static VALUE nn_create_child(VALUE self, VALUE name)
+{
+    struct native_node *n;
+    void *ptr;
+    TypedData_Get_Struct(self, struct native_node, &nn_type, n);
+    ptr = f_create_child(n->ptr, StringValueCStr(name));
+    if (!ptr)
+        rb_raise(rb_eRuntimeError, "leptris_element_create_child failed");
+    return wrap_new(n->document, ptr);
+}
+
+static VALUE nn_append_child(VALUE self, VALUE child)
+{
+    struct native_node *n, *c;
+    int rc;
+    TypedData_Get_Struct(self, struct native_node, &nn_type, n);
+    TypedData_Get_Struct(child, struct native_node, &nn_type, c);
+    rc = f_append_child(n->ptr, c->ptr);
+    if (rc != 0)
+        rb_raise(rb_eRuntimeError, "leptris_element_append_child failed (%d)", rc);
+    return child;
+}
+
+static VALUE nn_set_root(VALUE klass, VALUE document, VALUE element)
+{
+    struct native_node *n;
+    int rc;
+    (void)klass;
+    TypedData_Get_Struct(element, struct native_node, &nn_type, n);
+    rc = f_set_root(doc_ptr_of(document), n->ptr);
+    if (rc != 0)
+        rb_raise(rb_eRuntimeError, "leptris_document_set_root failed (%d)", rc);
+    return element;
+}
+
+static VALUE nn_address(VALUE self)
+{
+    struct native_node *n;
+    TypedData_Get_Struct(self, struct native_node, &nn_type, n);
+    return ULL2NUM((uint64_t)(uintptr_t)n->ptr);
+}
+
 static VALUE nn_from(VALUE klass, VALUE document, VALUE element)
 {
     /* Element address comes through the binding's #c_ptr address;
@@ -278,9 +390,16 @@ void Init_native(void)
     c_native_node = rb_define_class_under(m_xml, "NativeNode", rb_cObject);
     rb_undef_alloc_func(c_native_node);
 
-    id_wrapper_cache = rb_intern("wrapper_cache");
+    id_wrapper_cache = rb_intern("native_cache");
 
     rb_define_singleton_method(c_native_node, "from", nn_from, 2);
+    rb_define_singleton_method(c_native_node, "create_element", nn_create_element, 2);
+    rb_define_singleton_method(c_native_node, "create_text", nn_create_text, 2);
+    rb_define_singleton_method(c_native_node, "set_root", nn_set_root, 2);
+    rb_define_method(c_native_node, "create_child", nn_create_child, 1);
+    rb_define_method(c_native_node, "append_child", nn_append_child, 1);
+    rb_define_method(c_native_node, "add_child", nn_append_child, 1);
+    rb_define_method(c_native_node, "address", nn_address, 0);
     rb_define_method(c_native_node, "name", nn_name, 0);
     rb_define_method(c_native_node, "content", nn_content, 0);
     rb_define_method(c_native_node, "attribute", nn_attribute, 1);

data/lib/leptris/version.rb

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

data/lib/leptris/xml/native_layer.rb

@@ -54,9 +54,29 @@ resolved = candidates.any? do |path|
 end
 
 class Leptris::XML::Document
-  # The native-node view of the document root (opt-in read layer).
+  # Separate identity cache for NativeNodes so binding Node.wrap
+  # and the native layer never overwrite each other.
+  def native_cache
+    @native_cache ||= {}
+  end
+
   def native_node
-    root or raise Leptris::XML::Error, "document has no root element"
-    Leptris::XML::NativeNode.from(self, root.c_ptr)
+    r = root or raise Leptris::XML::Error, "document has no root element"
+    Leptris::XML::NativeNode.from(self, r.c_ptr)
+  end
+
+  # Builder factories that return NativeNodes (#149): one C call
+  # and a TypedData wrap — no FFI::Pointer, no wrap_fresh path.
+  def native_create_element(name)
+    Leptris::XML::NativeNode.create_element(self, name.to_s)
+  end
+
+  def native_create_text(content)
+    Leptris::XML::NativeNode.create_text(self, content.to_s)
+  end
+
+  def native_root=(element)
+    Leptris::XML::NativeNode.set_root(self, element)
+    element
   end
 end

metadata

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