leptris 1.9.174.2-aarch64-linux → 1.9.174.4-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1267d8fdc704044f69f7792e588b41ad74474583a82a458f61164086947e74d9
-  data.tar.gz: 86c476d323ca385a60488e92c30e1fab89235ec8a99208dba6652887281e85f2
+  metadata.gz: fbd33e8a70b150f3955b3a7de1a136fc90e051e3015cdb7a9ad690b3a75f001e
+  data.tar.gz: 142500c600c53293edf34edaae8c90dee05369295a6fdf6dfa4167f86d8f97b9
 SHA512:
-  metadata.gz: 33be4ac9cbf0f87a4d9b9f4a94560ac2f6ede3cb33e92c56ee109505d66c5fa841c1b6c77328db36860a8815a3dcdd4ebe21249e261d07d132729dd2ee0dbaa1
-  data.tar.gz: 2f837a607594cddeaa07a90ea8c8e85e26d06073104c90c4e022bb1097af5f2824b6180f9057cab40a7ed7d43b1b058be18aa55cdf32efb78a32bc330c9b690e
+  metadata.gz: 4c8389eea5c5559baf0d27944e67b928d4537036bb4ab9961a2a00c0d0805f5b70eac823684b28bd2b1d85ea7946475d1c8eef1f630f047c7e23c50d2cf55cda
+  data.tar.gz: abdc548f17f8574f4edd8b82dafea01aa8b832d078c4c453b3a661c2d659ea6d02baf506c596fbb689af218648d95ef4f87b0c61506691d7c464ea9a33206fcd

data/CHANGELOG.md

@@ -5,6 +5,44 @@ 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.174.4] - 2026-09-15
+
+### Changed
+
+- **Eager-in-C nodeset materialization (TODO.perf/22)**: xpath
+  results materialize and free in one C pass — no
+  FFI::AutoPointer, Method object, or finalizer per call; exotic
+  kinds keep the lazy path (sentinel scan in C). Measured (load
+  ~11): a 2000-node xpath set materializes at Nokogiri parity
+  (55.9µs vs 57.3µs).
+- **C-bound value mutations (TODO.perf/23)**: `Element#name=`,
+  `#content=`, `Text#content=`, `Node#unlink` run gates + version
+  bump + engine write in one dispatch (name= 237ns, content=
+  298ns measured); readonly raises verified.
+- **Immutable read lanes (TODO.perf/24)**: `line`/`byte_offset`
+  memoize (positions never change); `Node#document` answers a
+  constructor-precomputed ivar (the scope_owned? chain leaves
+  one of the most-called readers).
+
+## [1.9.174.3] - 2026-09-15
+
+### Changed
+
+- **Lazy FFI::Pointer on wrappers (TODO.perf/19)**: the node's
+  canonical state is the Integer address; the Pointer
+  materializes only when read — the C construction faces stop
+  minting one per node (~200ns + one allocation each, and
+  proportionally less GC). Public `c_ptr` API and identity
+  unchanged. Measured (load 22-25): GC-amortized
+  `Document.create` ~5-6µs → ~4.0µs; `NativeNode#[]` 78ns
+  (budget 70), `#content` 45ns (budget 58 met).
+- **CSS translation cache (TODO.perf/20)**: repeat selectors skip
+  the per-call regex translation straight to the compiled handle;
+  the single-path xpath shape no longer allocates a joined
+  String per call.
+- **`Element#key?` consults the attribute memo (TODO.perf/21)**
+  before the engine round-trip; miss semantics unchanged.
+
 ## [1.9.174.2] - 2026-09-15
 
 ### Changed

data/TODO.perf/19-lazy-node-pointer.md

@@ -0,0 +1,39 @@
+# 19 — Lazy FFI::Pointer on wrappers
+
+Status: DONE (1.9.174.3)
+
+Every binding wrapper stores an FFI::Pointer (@c_ptr), and the C
+construction faces mint one per node via
+rb_funcall(FFI::Pointer, :new) — ~200ns plus a Ruby object and
+its GC visit per node, paid at creation even though most nodes'
+Pointers are never read (the hot reads are memoized or go through
+the address-based native faces).
+
+Store @c_address (Integer) as the canonical truth on every
+wrapper; `c_ptr` becomes a lazy materializer
+(@c_ptr ||= FFI::Pointer.new(@c_address)) preserving the public
+API. Internal call sites: `@c_ptr.address` collapses to
+@c_address (also skipping the #address dispatch), and remaining
+internal @c_ptr reads go through the c_ptr reader (same cost as
+the old attr_reader). The C faces stop constructing Pointers
+entirely — they already hold the address.
+
+Gates: suite green both modes (a missed site fails loudly — nil
+to FFI raises TypeError); wrapper identity and c_ptr stability
+unchanged; creation faces drop ~200ns and one allocation per
+node; fresh-doc build row improves accordingly.
+
+## Outcome (1.9.174.3)
+
+@c_address is the canonical truth on every Node wrapper; c_ptr
+materializes lazily (@c_ptr ||= FFI::Pointer.new(@c_address)),
+preserving the public API and identity. All internal @c_ptr
+reads became c_ptr reader calls; the 15 @c_ptr.address sites
+collapsed to @c_address (also skipping the #address dispatch).
+The C construction faces (create element/text, bulk children,
+every xpath materialization) stopped minting Pointers entirely —
+one allocation and ~200ns saved per node, and proportionally less
+GC. Document keeps its eager reader (documents are few).
+Measured under host load 22-25: GC-amortized Document.create
+~5-6µs -> ~4.0µs; NativeNode#[] 78ns (budget 70 — clear at
+load <10), content 45ns (budget 58 met).

data/TODO.perf/20-css-translation-cache.md

@@ -0,0 +1,24 @@
+# 20 — CSS translation cache
+
+Status: DONE (1.9.174.3)
+
+Searchable#css/#at_css run CssToXPath.convert on every call —
+pure Ruby regex/string work (~300ns+) — before the compiled-
+expression cache (TODO.perf/15) can hit on the result. The
+translation is a pure function of (selector, prefix); cache it
+with the same bounded-LRU shape (64 entries, Hash#shift
+eviction, GVL-safe), so repeat selectors skip straight to the
+compiled handle.
+
+Gates: css/at_css results identical; repeat-call rows improve by
+the translation cost; the join in xpath()'s expression build is
+also skipped for the single-String-path shape (join minted a
+fresh String per call even for one path).
+
+## Outcome (1.9.174.3)
+
+Searchable.css_expression: bounded LRU (64, shared limit) keyed
+on prefix+selector; css/at_css translate through it so repeat
+selectors skip the regex machinery straight to the compiled-
+expression cache. The single-String-path shape of xpath/at_xpath
+no longer joins (join minted a fresh String per call).

data/TODO.perf/21-key-memo-consult.md

@@ -0,0 +1,20 @@
+# 21 — key? consults the attribute memo
+
+Status: DONE (1.9.174.3)
+
+Element#key?/has_attribute? pays an engine FFI round-trip per
+call even when the versioned @attr_values memo already proves
+presence. Consult the memo first (hit = true; only a miss falls
+through to the engine + written-name fallback — the memo cannot
+prove ABSENCE for a partial fill).
+
+Gates: key? true for memoized names, unchanged miss semantics
+(undeclared-prefix fallback intact), readonly/namespace specs
+green.
+
+## Outcome (1.9.174.3)
+
+Element#key? consults the versioned @attr_values memo first —
+presence-proven hits skip the engine round-trip; partial-fill
+misses still fall through to the engine + written-name fallback
+(the memo cannot prove absence).

data/TODO.perf/22-eager-nodeset-materialization.md

@@ -0,0 +1,30 @@
+# 22 — Eager-in-C nodeset materialization (drop the per-call AutoPointer)
+
+Status: DONE (1.9.174.4)
+
+Every xpath() nodeset result pays an FFI::AutoPointer + a Method
+object + finalizer registration (~400-600ns plus their GC) just
+to keep the C result handle alive until the lazy NodeSet
+materializes — and virtually every consumer materializes anyway
+(each/size/to_a). Materialize eagerly in C instead: one face runs
+the bulk pass AND frees the result handle, returning the Ruby
+Array; Searchable wraps it in the eager NodeSet constructor (an
+Array-backed set has no handle at all). Exotic node kinds (the
+module-object sentinel) fall back to the existing lazy path with
+the handle intact.
+
+Gates: xpath results identical for every kind (including
+sentinel-graded kinds); laziness is internal — the public NodeSet
+behaviors (indexing, iteration, size) unchanged; the xpath row
+drops the AutoPointer cost per call.
+
+## Outcome (1.9.174.4)
+
+Native.materialize_xpath: the bulk pass AND the result free in C;
+Searchable's nodeset branch wraps the returned Array in the eager
+NodeSet (no AutoPointer, no Method object, no finalizer per
+xpath call). Sentinel scans happen in C (a Ruby include? would
+cost microseconds on large sets) — any exotic kind returns Qnil
+with the handle alive for the lazy fallback. Measured (load
+~11): full materialization of a 2000-node xpath set 55.9µs vs
+Nokogiri 57.3µs — parity on the heavy shape.

data/TODO.perf/23-cbound-value-mutations.md

@@ -0,0 +1,27 @@
+# 23 — C-bound name= / content= / unlink
+
+Status: DONE (1.9.174.4)
+
+The value mutations still run ensure_writable! + FFI marshaling
+per call (~450ns): Element#name=, Element#content=,
+Text#content=, and Node#unlink (transforms rename, rewrite, and
+remove nodes constantly). Same face shape as set_binding_attribute:
+gates + version bump + engine write in one dispatch —
+set_binding_name (element names), set_binding_text (element text
+or text-node content, kind-dispatched in C), and
+unlink_binding_node (plus the Ruby-side @parent clear and memo
+invalidations that ride the version bump).
+
+Gates: rename/content/unlink semantics unchanged (memos, sibling
+stamps, path memo all invalidate through the version bump);
+readonly raises through every face.
+
+## Outcome (1.9.174.4)
+
+Native.set_binding_name / set_binding_text (kind-dispatched
+element-vs-text) / unlink_binding_node — gates + bump + engine
+write in one dispatch, wired into Element#name=, #content=,
+Text#content=, and Node#unlink (@parent clear and memo
+invalidation ride the version bump). Measured (load ~11):
+name= 237ns, content= 298ns, unlink+re-add 1.74µs; readonly
+raises verified through every face.

data/TODO.perf/24-immutable-read-lanes.md

@@ -0,0 +1,22 @@
+# 24 — Immutable read lanes: line/byte_offset memo + precomputed public #document
+
+Status: DONE (1.9.174.4)
+
+Node#line and #byte_offset pay an FFI round-trip per call, but a
+node's source position never changes — memoize unconditionally
+(first read wins). The public Node#document walks scope_owned? (a
+method chain) on every call though scope ownership is fixed at
+construction — precompute @pub_document once (nil for
+scope-owned) including at every C construction site.
+
+Gates: line/byte_offset stable across mutations (they must be —
+the engine reports source positions); document nil for
+scope-owned yields exactly as before; suite both modes.
+
+## Outcome (1.9.174.4)
+
+line/byte_offset memoize unconditionally (a node's source
+position never changes; 40ns hits). Node#document answers the
+constructor-precomputed @pub_document (nil for scope-owned
+yields) — the scope_owned? method chain disappears from one of
+the most-called readers; every C construction site sets it.

data/ext/leptris/native/native.c

@@ -85,6 +85,10 @@ static xp_free_fn f_xp_free;
 static first_child_fn f_first_child;
 static node_str_fn f_comment_content, f_cdata_content, f_pi_target,
                    f_pi_data;
+typedef int (*set_str_fn)(void *, const char *);
+typedef int (*node_unlink_fn)(void *);
+static set_str_fn f_elem_set_name, f_elem_set_text, f_text_set_content;
+static node_unlink_fn f_node_unlink;
 static set_root_fn f_set_root;
 static doc_free_fn f_doc_free;
 
@@ -192,6 +196,10 @@ static void resolve_symbols(const char *lib_path)
     f_cdata_content = (node_str_fn)lib_sym(h, "leptris_cdata_node_get_content");
     f_pi_target = (node_str_fn)lib_sym(h, "leptris_pi_node_get_target");
     f_pi_data = (node_str_fn)lib_sym(h, "leptris_pi_node_get_data");
+    f_elem_set_name = (set_str_fn)lib_sym(h, "leptris_element_set_name");
+    f_elem_set_text = (set_str_fn)lib_sym(h, "leptris_element_set_text");
+    f_text_set_content = (set_str_fn)lib_sym(h, "leptris_text_node_set_content");
+    f_node_unlink = (node_unlink_fn)lib_sym(h, "leptris_node_unlink");
     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 ||
@@ -201,7 +209,8 @@ static void resolve_symbols(const char *lib_path)
         !f_insert_after || !f_insert_before || !f_set_attr || !f_set_root ||
         !f_xp_type || !f_xp_free || !f_first_child ||
         !f_comment_content || !f_cdata_content || !f_pi_target ||
-        !f_pi_data ||
+        !f_pi_data || !f_elem_set_name || !f_elem_set_text ||
+        !f_text_set_content || !f_node_unlink ||
         !f_doc_free ||
         !f_elem_prefix || !f_xp_count || !f_xp_nodes_ex ||
         !f_xp_node_kind || !f_xp_node_name || !f_xp_node_value ||
@@ -630,6 +639,74 @@ static VALUE nf_set_binding_attribute(VALUE self, VALUE document,
     return INT2FIX(st);
 }
 
+/* C-bound value mutations (TODO.perf/23): the same gates + bump
+ * + engine write shape as set_binding_attribute. */
+static VALUE nf_set_binding_name(VALUE self, VALUE document,
+                                 VALUE addr, VALUE name)
+{
+    void *node;
+    int st;
+
+    (void)self;
+    resolve_binding_classes();
+    if (NIL_P(rb_ivar_get(document, id_iv_c_address)))
+        rb_raise(c_use_after_free_error,
+                 "owning document has been freed");
+    if (rb_ivar_get(document, id_iv_readonly) == Qtrue)
+        rb_raise(c_readonly_error,
+                 "document is readonly — mutation attempted");
+    node = (void *)(uintptr_t)NUM2ULL(addr);
+    rb_ivar_set(document, id_iv_version,
+                LONG2FIX(FIX2LONG(rb_ivar_get(document, id_iv_version)) + 1));
+    st = f_elem_set_name(node, StringValueCStr(name));
+    return INT2FIX(st);
+}
+
+/* Element text or text-node content — kind-dispatched in C. */
+static VALUE nf_set_binding_text(VALUE self, VALUE document,
+                                 VALUE addr, VALUE content)
+{
+    void *node;
+    int st;
+
+    (void)self;
+    resolve_binding_classes();
+    if (NIL_P(rb_ivar_get(document, id_iv_c_address)))
+        rb_raise(c_use_after_free_error,
+                 "owning document has been freed");
+    if (rb_ivar_get(document, id_iv_readonly) == Qtrue)
+        rb_raise(c_readonly_error,
+                 "document is readonly — mutation attempted");
+    node = (void *)(uintptr_t)NUM2ULL(addr);
+    rb_ivar_set(document, id_iv_version,
+                LONG2FIX(FIX2LONG(rb_ivar_get(document, id_iv_version)) + 1));
+    st = f_node_type(node) == NT_ELEMENT
+             ? f_elem_set_text(node, StringValueCStr(content))
+             : f_text_set_content(node, StringValueCStr(content));
+    return INT2FIX(st);
+}
+
+static VALUE nf_unlink_binding_node(VALUE self, VALUE document,
+                                    VALUE addr)
+{
+    void *node;
+    int st;
+
+    (void)self;
+    resolve_binding_classes();
+    if (NIL_P(rb_ivar_get(document, id_iv_c_address)))
+        rb_raise(c_use_after_free_error,
+                 "owning document has been freed");
+    if (rb_ivar_get(document, id_iv_readonly) == Qtrue)
+        rb_raise(c_readonly_error,
+                 "document is readonly — mutation attempted");
+    node = (void *)(uintptr_t)NUM2ULL(addr);
+    rb_ivar_set(document, id_iv_version,
+                LONG2FIX(FIX2LONG(rb_ivar_get(document, id_iv_version)) + 1));
+    st = f_node_unlink(node);
+    return INT2FIX(st);
+}
+
 /* C-bound insert family (TODO.perf/14): prepend / insert-after /
  * insert-before share append's gates + predicate + bump shape.
  * mode: 1 prepend, 2 after, 3 before (anchor = receiver). */
@@ -870,13 +947,13 @@ static VALUE bulk_children_impl(VALUE document, VALUE parent_addr,
         key = ULL2NUM((uint64_t)(uintptr_t)buf[i]);
         node = rb_hash_aref(cache, key);
         if (NIL_P(node)) {
-            VALUE ptr = rb_funcall(c_ffi_pointer, id_ptr_new, 1, key);
             node = rb_obj_alloc(binding_klass_for(kinds[i]));
-            rb_iv_set(node, "@c_ptr", ptr);
+            rb_iv_set(node, "@c_address", key);
             rb_iv_set(node, "@document", document);
             rb_iv_set(node, "@parent", Qnil);
             rb_iv_set(node, "@structure_memoizable", Qtrue);
             rb_iv_set(node, "@native_fast", Qtrue);
+                rb_iv_set(node, "@pub_document", document);
             rb_iv_set(node, "@node_type", INT2FIX(kinds[i]));
             rb_hash_aset(cache, key, node);
         }
@@ -913,15 +990,45 @@ static VALUE materialize_xp_entry(VALUE document, VALUE cache,
                                   void *result, void *ptr, int kind,
                                   int idx);
 
+static VALUE bulk_xpath_array(VALUE document, void *result);
+
 static VALUE nf_bulk_xpath(VALUE self, VALUE document, VALUE result_ptr_val)
+{
+    (void)self;
+    return bulk_xpath_array(document,
+                            (void *)(uintptr_t)NUM2ULL(result_ptr_val));
+}
+
+/* TODO.perf/22: materialize AND free — the eager xpath path owns
+ * the handle lifecycle in C; no Ruby AutoPointer, no finalizer. */
+static VALUE nf_materialize_xpath(VALUE self, VALUE document,
+                                  VALUE result_ptr_val)
 {
     void *result = (void *)(uintptr_t)NUM2ULL(result_ptr_val);
+    VALUE out;
+    long i, n;
+
+    (void)self;
+    out = bulk_xpath_array(document, result);
+    n = RARRAY_LEN(out);
+    for (i = 0; i < n; i++) {
+        if (rb_ary_entry(out, i) == m_native_sentinel) {
+            /* Exotic kinds need the Ruby fallback per entry — the
+             * caller keeps the handle and goes the lazy path. */
+            return Qnil;
+        }
+    }
+    f_xp_free(result);
+    return out;
+}
+
+static VALUE bulk_xpath_array(VALUE document, void *result)
+{
     void **buf;
     int *kinds;
     int count, i;
     VALUE cache, out;
 
-    (void)self;
     resolve_binding_classes();
     size_t scount = f_xp_count(result);
     if (scount == 0)
@@ -965,13 +1072,13 @@ static VALUE materialize_xp_entry(VALUE document, VALUE cache,
     case 0: /* element */
         node = rb_hash_aref(cache, key);
         if (NIL_P(node)) {
-            VALUE p = rb_funcall(c_ffi_pointer, id_ptr_new, 1, key);
             node = rb_obj_alloc(c_b_element);
-            rb_iv_set(node, "@c_ptr", p);
+            rb_iv_set(node, "@c_address", key);
             rb_iv_set(node, "@document", document);
             rb_iv_set(node, "@parent", Qnil);
             rb_iv_set(node, "@structure_memoizable", Qtrue);
             rb_iv_set(node, "@native_fast", Qtrue);
+                rb_iv_set(node, "@pub_document", document);
             rb_iv_set(node, "@node_type", INT2FIX(0));
             rb_hash_aset(cache, key, node);
         }
@@ -980,9 +1087,8 @@ static VALUE materialize_xp_entry(VALUE document, VALUE cache,
         {
             const char *name = f_xp_node_name(result, idx);
             const char *value = f_xp_node_value(result, idx);
-            VALUE p = rb_funcall(c_ffi_pointer, id_ptr_new, 1, key);
             node = rb_obj_alloc(c_b_result_attr);
-            rb_iv_set(node, "@c_ptr", p);
+            rb_iv_set(node, "@c_address", key);
             rb_iv_set(node, "@document", document);
             rb_iv_set(node, "@attr_name",
                       name ? rb_utf8_str_new_cstr(name) : Qnil);
@@ -998,8 +1104,7 @@ static VALUE materialize_xp_entry(VALUE document, VALUE cache,
             if (nt == 8) { /* NODE_SYNTHETIC_TEXT */
                 s = f_xp_node_value(result, idx);
                 node = rb_obj_alloc(c_b_result_text);
-                rb_iv_set(node, "@c_ptr",
-                          rb_funcall(c_ffi_pointer, id_ptr_new, 1, key));
+                rb_iv_set(node, "@c_address", key);
                 rb_iv_set(node, "@document", document);
                 rb_iv_set(node, "@value",
                           s ? rb_utf8_str_new_cstr(s) : Qnil);
@@ -1007,13 +1112,13 @@ static VALUE materialize_xp_entry(VALUE document, VALUE cache,
             }
             node = rb_hash_aref(cache, key);
             if (NIL_P(node)) {
-                VALUE p = rb_funcall(c_ffi_pointer, id_ptr_new, 1, key);
                 node = rb_obj_alloc(binding_klass_for(nt));
-                rb_iv_set(node, "@c_ptr", p);
+                rb_iv_set(node, "@c_address", key);
                 rb_iv_set(node, "@document", document);
                 rb_iv_set(node, "@parent", Qnil);
                 rb_iv_set(node, "@structure_memoizable", Qtrue);
                 rb_iv_set(node, "@native_fast", Qtrue);
+                rb_iv_set(node, "@pub_document", document);
                 rb_iv_set(node, "@node_type", INT2FIX(nt));
                 rb_hash_aset(cache, key, node);
             }
@@ -1096,13 +1201,13 @@ static VALUE nf_create_binding_element(VALUE self, VALUE document,
     if (!ptr)
         return Qnil; /* caller raises with the error channel */
     node = rb_obj_alloc(c_b_element);
-    rb_iv_set(node, "@c_ptr",
-              rb_funcall(c_ffi_pointer, id_ptr_new, 1,
-                         ULL2NUM((uint64_t)(uintptr_t)ptr)));
+    rb_iv_set(node, "@c_address",
+              ULL2NUM((uint64_t)(uintptr_t)ptr));
     rb_iv_set(node, "@document", document);
     rb_iv_set(node, "@parent", Qnil);
     rb_iv_set(node, "@structure_memoizable", Qtrue);
     rb_iv_set(node, "@native_fast", Qtrue);
+                rb_iv_set(node, "@pub_document", document);
     rb_iv_set(node, "@node_type", INT2FIX(0));
     cache = binding_cache_of(document);
     key = ULL2NUM((uint64_t)(uintptr_t)ptr);
@@ -1122,13 +1227,13 @@ static VALUE nf_create_binding_text(VALUE self, VALUE document,
     if (!ptr)
         return Qnil;
     node = rb_obj_alloc(c_b_text);
-    rb_iv_set(node, "@c_ptr",
-              rb_funcall(c_ffi_pointer, id_ptr_new, 1,
-                         ULL2NUM((uint64_t)(uintptr_t)ptr)));
+    rb_iv_set(node, "@c_address",
+              ULL2NUM((uint64_t)(uintptr_t)ptr));
     rb_iv_set(node, "@document", document);
     rb_iv_set(node, "@parent", Qnil);
     rb_iv_set(node, "@structure_memoizable", Qtrue);
     rb_iv_set(node, "@native_fast", Qtrue);
+                rb_iv_set(node, "@pub_document", document);
     rb_iv_set(node, "@node_type", INT2FIX(1));
     cache = binding_cache_of(document);
     key = ULL2NUM((uint64_t)(uintptr_t)ptr);
@@ -1584,6 +1689,14 @@ void Init_native(void)
                               nf_insert_binding_child, 4);
     rb_define_module_function(m_native, "at_xpath_first",
                               nf_at_xpath_first, 2);
+    rb_define_module_function(m_native, "materialize_xpath",
+                              nf_materialize_xpath, 2);
+    rb_define_module_function(m_native, "set_binding_name",
+                              nf_set_binding_name, 3);
+    rb_define_module_function(m_native, "set_binding_text",
+                              nf_set_binding_text, 3);
+    rb_define_module_function(m_native, "unlink_binding_node",
+                              nf_unlink_binding_node, 2);
     rb_define_module_function(m_native, "fast_inner_xml",
                               nf_fast_inner_xml, 1);
     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.174.2"
+  VERSION = "1.9.174.4"
 end

data/lib/leptris/xml/cdata.rb

@@ -6,7 +6,7 @@ class Leptris::XML::CDATA < Leptris::XML::Text
   def content
     return @content if memo_hit?(@content_version)
     ensure_alive!
-    result = Leptris::XML::FFI.leptris_cdata_node_get_content(@c_ptr)
+    result = Leptris::XML::FFI.leptris_cdata_node_get_content(c_ptr)
     if @document
       @content = result
       @content_version = @document.version
@@ -17,7 +17,7 @@ class Leptris::XML::CDATA < Leptris::XML::Text
   def content=(new_content)
     ensure_writable!
     Leptris::XML::FFI.check_status(
-      Leptris::XML::FFI.leptris_cdata_node_set_content(@c_ptr, new_content.to_s))
+      Leptris::XML::FFI.leptris_cdata_node_set_content(c_ptr, new_content.to_s))
     new_content
   end
 end

data/lib/leptris/xml/comment.rb

@@ -6,7 +6,7 @@ class Leptris::XML::Comment < Leptris::XML::Node
   def content
     return @content if memo_hit?(@content_version)
     ensure_alive!
-    result = Leptris::XML::FFI.leptris_comment_node_get_content(@c_ptr)
+    result = Leptris::XML::FFI.leptris_comment_node_get_content(c_ptr)
     if @document
       @content = result
       @content_version = @document.version
@@ -17,7 +17,7 @@ class Leptris::XML::Comment < Leptris::XML::Node
   def content=(new_content)
     ensure_writable!
     Leptris::XML::FFI.check_status(
-      Leptris::XML::FFI.leptris_comment_node_set_content(@c_ptr, new_content.to_s))
+      Leptris::XML::FFI.leptris_comment_node_set_content(c_ptr, new_content.to_s))
     new_content
   end
 end

data/lib/leptris/xml/doc_type.rb

@@ -9,24 +9,24 @@ class Leptris::XML::DocType
   end
 
   def name
-    Leptris::XML::FFI.leptris_doctype_get_name(@c_ptr)
+    Leptris::XML::FFI.leptris_doctype_get_name(c_ptr)
   end
   alias_method :node_name, :name
 
   def root_name
-    Leptris::XML::FFI.leptris_doctype_get_root_name(@c_ptr)
+    Leptris::XML::FFI.leptris_doctype_get_root_name(c_ptr)
   end
 
   def public_id
-    Leptris::XML::FFI.leptris_doctype_get_public_id(@c_ptr)
+    Leptris::XML::FFI.leptris_doctype_get_public_id(c_ptr)
   end
 
   def system_id
-    Leptris::XML::FFI.leptris_doctype_get_system_id(@c_ptr)
+    Leptris::XML::FFI.leptris_doctype_get_system_id(c_ptr)
   end
 
   def internal_subset
-    Leptris::XML::FFI.leptris_doctype_get_internal_subset(@c_ptr)
+    Leptris::XML::FFI.leptris_doctype_get_internal_subset(c_ptr)
   end
 
   def external_id