leptris 1.9.174.1 → 1.9.174.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cd97282aa1d1c93dd600491c6209a122c436effa4cf65e9c3f5e71d830343aac
-  data.tar.gz: 28e2d7a97cb72d10059674d512ffc657b3a22d3c2be28b1002c45192c05cb11a
+  metadata.gz: 741e98553c4d88169d4c2f8ec0fb793eeebd80ffd8b00771fcfb0be218721f64
+  data.tar.gz: 5e02a23549a4e1c708dc40710b499e64fcd83150772dd08c8bbeac7fc77f0718
 SHA512:
-  metadata.gz: 687c5a22ea2c1bff192be56174588d1fdcb6cf6441bee2071e197950cbd095f123761bb92e15da497d0c30d9cdc394ca5c75514be82bcc98fde0ad449a80c44c
-  data.tar.gz: 468d6e81dbb1c7716da5bff232cde73cf247d04d0f895a842be8511aef07abfb8b2ad2f2f872bca25a8995397be27b2b89fc43d21c2cebb172622856dd106eac
+  metadata.gz: b1a3b25cd5b770b6edfb06bc2d448dacd691dc7e5af3fb301454fb1057e419c5fc779e4c9556a3f3b4be654ea5ec36be8f8e5c4e0f7ab16af380b6986da3bcb5
+  data.tar.gz: 85e81207c2abaca9a80af5dcfb33ae4e4f83c2ec24950b16d38fcb239bf7fa4d01b40d4d88b7fa19e019ba35a9ce58984c823e3f049fc47492459ebde53aa47b

data/CHANGELOG.md

@@ -5,6 +5,39 @@ 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.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
+
+- **The native layer returns to Windows, one DLL per Ruby minor
+  (#227)**: a PE DLL must bind its build Ruby's runtime, so the
+  Windows platform gems now ship `native-3.3.so` / `native-3.4.so`
+  / `native-4.0.so` and the loader picks by `RUBY_VERSION` at
+  require. The release workflow compiles each minor's artifact on
+  the Windows legs (a minor unavailable on a runner degrades to
+  the loud FFI fallback for that cell); local `rake compile` on
+  Windows builds the current minor's DLL. Windows test legs now
+  exercise the full native suite instead of FFI-only.
+
 ## [1.9.174.1] - 2026-09-15
 
 ### Fixed

data/Rakefile

@@ -128,12 +128,14 @@ task :compile do
   # the library — no compile at install; resolves libleptris at
   # require time via dlsym.
   if Gem.win_platform?
-    # #207: a PE DLL cannot leave Ruby imports unresolved — the
-    # bundle would bind to the build Ruby's x64-ucrt-rubyNNN.dll
-    # and fail on every other minor. No bundle ships for
-    # Windows; the FFI surface is the Windows contract (the
-    # auto-enable warns and falls back).
-    puts "Windows: native read layer not built — FFI is the Windows surface (#207)"
+    # #207: a PE DLL cannot leave Ruby imports unresolved — it
+    # binds the build Ruby's x64-ucrt-rubyNNN.dll. The Windows
+    # gems therefore ship one DLL per supported Ruby minor
+    # (native-<minor>.so), and native_layer picks by RUBY_VERSION
+    # (#227). Local compile builds just the current minor's DLL;
+    # the release workflow runs the build script under 3.3/3.4/
+    # 4.0 to produce the full set.
+    sh "#{RbConfig.ruby} ext/build_windows_native.rb"
   else
     ext_dir = "ext/leptris/native"
     Dir.chdir(ext_dir) do
@@ -283,9 +285,10 @@ platforms.each do |platform|
     spec.platform = Gem::Platform.new(platform)
     spec.files += Dir.glob("lib/libleptris.{dll,so,dylib}")
     spec.files += Dir.glob("lib/{libutf8proc.3.dylib,libutf8proc.so.3,libutf8proc.so,utf8proc.dll}")
-    # #207: no native bundle in Windows gems (PE cannot resolve
-    # Ruby imports without binding the build Ruby's DLL).
-    unless platform.include?("mingw")
+    if platform.include?("mingw")
+      # #207/#227: per-Ruby-minor DLLs (PE must bind its Ruby).
+      spec.files += Dir.glob("lib/leptris/xml/native-*.so")
+    else
       spec.files += Dir.glob("lib/leptris/xml/native.{bundle,so,dll}")
     end
     task = Gem::PackageTask.new(spec)

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/ext/build_windows_native.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+# Builds the native read layer DLL for the CURRENT Ruby and
+# installs it under its minor-versioned name
+# (lib/leptris/xml/native-<major.minor>.so).
+#
+# #207/#227: a PE DLL cannot resolve Ruby imports lazily — it
+# must bind the build Ruby's x64-ucrt-rubyNNN.dll. One DLL per
+# supported minor therefore ships in the Windows platform gems,
+# and native_layer picks by RUBY_VERSION at require.
+#
+# Standalone by design: the release workflow runs this under each
+# Ruby minor (3.3/3.4/4.0) with no bundler context.
+
+require "rbconfig"
+require "fileutils"
+
+root = File.expand_path("..", __dir__)
+ext_dir = File.join(root, "ext", "leptris", "native")
+minor = RUBY_VERSION[/\A\d+\.\d+/]
+
+Dir.chdir(ext_dir) do
+  system(RbConfig.ruby, "extconf.rb") or abort "extconf failed under #{RUBY_VERSION}"
+  # mkmf's link binds the CURRENT Ruby's runtime DLL — exactly
+  # what the versioned naming is for.
+  success = system("make")
+  abort "make failed under #{RUBY_VERSION}" unless success
+  so = Dir.glob("native.{so,dll}").first
+  abort "native bundle not produced under #{RUBY_VERSION}" unless so
+  dest = File.join(root, "lib", "leptris", "xml", "native-#{minor}.so")
+  # The artifact must reference only this minor's Ruby DLL.
+  imported = `strings #{so} 2>/dev/null`[/[a-z0-9-]*ruby\d{3,}\.dll/i]
+  if imported && !imported.include?("ruby#{minor.delete('.')}")
+    abort "#{so} imports #{imported} but was built under #{RUBY_VERSION} — refuse to mis-name it"
+  end
+  FileUtils.cp(so, dest)
+  puts "Installed native layer for Ruby #{minor} -> #{dest} (#{imported || 'no ruby dll string found'})"
+end

data/ext/leptris/native/native.c

@@ -870,9 +870,8 @@ 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);
@@ -965,9 +964,8 @@ 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);
@@ -980,9 +978,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 +995,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,9 +1003,8 @@ 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);
@@ -1096,9 +1091,8 @@ 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);
@@ -1122,9 +1116,8 @@ 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);

data/lib/leptris/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Leptris
-  VERSION = "1.9.174.1"
+  VERSION = "1.9.174.3"
 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

data/lib/leptris/xml/document.rb

@@ -32,9 +32,9 @@ class Leptris::XML::Document
 
   def initialize(c_ptr = nil, freed = Freed.new(:alive))
     @c_ptr = c_ptr
-    # Plain-Integer address twin of @c_ptr: the native layer reads
+    # Plain-Integer address twin of c_ptr: the native layer reads
     # this ivar directly (no method dispatch), nil'ed exactly when
-    # @c_ptr is.
+    # c_ptr is.
     @c_address = c_ptr&.address
     @freed = freed
     @readonly = false
@@ -209,13 +209,13 @@ class Leptris::XML::Document
 
   def root
     raise Leptris::XML::UseAfterFreeError if @freed.state == :freed
-    return nil if @c_ptr.nil?
+    return nil if c_ptr.nil?
     # Version-stamped memo (TODO.perf/13): root changes only
     # through mutations that advance @version (root=, unlink) or
-    # #free (which nils @c_ptr above) — the entry point of every
+    # #free (which nils c_ptr above) — the entry point of every
     # pipeline stops paying FFI + wrap per call.
     return @root if @root_version == @version
-    ptr = Leptris::XML::FFI.leptris_document_root(@c_ptr)
+    ptr = Leptris::XML::FFI.leptris_document_root(c_ptr)
     result = ptr.null? ? nil : Leptris::XML::Node.wrap(ptr, self)
     @root = result
     @root_version = @version
@@ -231,7 +231,7 @@ class Leptris::XML::Document
   def node
     raise Leptris::XML::UseAfterFreeError if @freed.state == :freed
     @node ||= Leptris::XML::Node.wrap(
-      Leptris::XML::FFI.leptris_document_node(@c_ptr), self)
+      Leptris::XML::FFI.leptris_document_node(c_ptr), self)
   end
 
   # The document's children, via the document node: prolog
@@ -250,7 +250,7 @@ class Leptris::XML::Document
     doc_node = node
     return Leptris::XML::NodeSet.new(self, []) if doc_node.nil?
     kids = doc_node.children.to_a
-    root_ptr = Leptris::XML::FFI.leptris_document_root(@c_ptr)
+    root_ptr = Leptris::XML::FFI.leptris_document_root(c_ptr)
     return kids if root_ptr.null?
     return kids if kids.any? { |child| child.c_ptr == root_ptr }
     root = Leptris::XML::Node.wrap(root_ptr, self)
@@ -289,7 +289,7 @@ class Leptris::XML::Document
       Leptris::XML::Element.lift_namespaces_for_adoption(element, {})
     end
     Leptris::XML::FFI.check_status(
-      Leptris::XML::FFI.leptris_document_set_root(@c_ptr, element.c_ptr))
+      Leptris::XML::FFI.leptris_document_set_root(c_ptr, element.c_ptr))
     @version += 1
     # Seed the root memo through wrap: a cross-document element
     # must enter THIS document's identity cache with @document
@@ -308,7 +308,7 @@ class Leptris::XML::Document
       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 = Leptris::XML::FFI.leptris_element_create(c_ptr, name)
     raise Leptris::XML::Error, "leptris_element_create failed" if ptr.null?
     Leptris::XML::Node.wrap_fresh(ptr, self, Leptris::XML::FFI::NODE_ELEMENT)
   end
@@ -319,25 +319,25 @@ class Leptris::XML::Document
       raise Leptris::XML::Error, "leptris_text_node_create failed" if node.nil?
       return node
     end
-    ptr = Leptris::XML::FFI.leptris_text_node_create(@c_ptr, content.to_s)
+    ptr = Leptris::XML::FFI.leptris_text_node_create(c_ptr, content.to_s)
     raise Leptris::XML::Error, "leptris_text_node_create failed" if ptr.null?
     Leptris::XML::Node.wrap_fresh(ptr, self, Leptris::XML::FFI::NODE_TEXT)
   end
 
   def create_comment(content)
-    ptr = Leptris::XML::FFI.leptris_comment_node_create(@c_ptr, content.to_s)
+    ptr = Leptris::XML::FFI.leptris_comment_node_create(c_ptr, content.to_s)
     raise Leptris::XML::Error, "leptris_comment_node_create failed" if ptr.null?
     Leptris::XML::Node.wrap_fresh(ptr, self, Leptris::XML::FFI::NODE_COMMENT)
   end
 
   def create_cdata(content)
-    ptr = Leptris::XML::FFI.leptris_cdata_node_create(@c_ptr, content.to_s)
+    ptr = Leptris::XML::FFI.leptris_cdata_node_create(c_ptr, content.to_s)
     raise Leptris::XML::Error, "leptris_cdata_node_create failed" if ptr.null?
     Leptris::XML::Node.wrap_fresh(ptr, self, Leptris::XML::FFI::NODE_CDATA)
   end
 
   def create_processing_instruction(target, data = "")
-    ptr = Leptris::XML::FFI.leptris_pi_node_create(@c_ptr, target.to_s, data.to_s)
+    ptr = Leptris::XML::FFI.leptris_pi_node_create(c_ptr, target.to_s, data.to_s)
     raise Leptris::XML::Error, "leptris_pi_node_create failed" if ptr.null?
     Leptris::XML::Node.wrap_fresh(ptr, self, Leptris::XML::FFI::NODE_PI)
   end
@@ -347,14 +347,14 @@ class Leptris::XML::Document
   end
 
   def dup
-    raw = Leptris::XML::FFI.leptris_document_copy(@c_ptr)
+    raw = Leptris::XML::FFI.leptris_document_copy(c_ptr)
     raise Leptris::XML::Error, "leptris_document_copy failed" if raw.null?
     self.class.wrap(raw)
   end
   alias_method :clone, :dup
 
   def doctype
-    ptr = Leptris::XML::FFI.leptris_document_internal_subset(@c_ptr)
+    ptr = Leptris::XML::FFI.leptris_document_internal_subset(c_ptr)
     return nil if ptr.null?
     Leptris::XML::DocType.new(ptr, self)
   end
@@ -368,18 +368,18 @@ class Leptris::XML::Document
   # display-oriented and not round-trip-guaranteed).
   def to_xml(indent: 0, no_decl: false, encoding: nil, indent_text: false)
     raise Leptris::XML::UseAfterFreeError if @freed.state == :freed
-    return "" if @c_ptr.nil?
+    return "" if c_ptr.nil?
     case indent_text
     when String
       return Leptris::XML::Serialization.to_xml_indent_unit(
-        @c_ptr, indent_text, indent: indent, no_decl: no_decl,
+        c_ptr, indent_text, indent: indent, no_decl: no_decl,
         encoding: encoding)
     when true
       return Leptris::XML::Serialization.to_xml_display(
-        @c_ptr, indent: indent, no_decl: no_decl, encoding: encoding)
+        c_ptr, indent: indent, no_decl: no_decl, encoding: encoding)
     end
     Leptris::XML::Serialization.to_xml(
-      Leptris::XML::Serialization::DOCUMENT_SERIALIZE_INTO, @c_ptr,
+      Leptris::XML::Serialization::DOCUMENT_SERIALIZE_INTO, c_ptr,
       indent: indent, no_decl: no_decl, encoding: encoding)
   end
   alias_method :to_s, :to_xml
@@ -391,7 +391,7 @@ class Leptris::XML::Document
       no_decl: opts.fetch(:no_decl, false),
       encoding: opts[:encoding])
     status = Leptris::XML::FFI.leptris_document_save_file(
-      @c_ptr, path, opts_struct.pointer)
+      c_ptr, path, opts_struct.pointer)
     Leptris::XML::FFI.check_status(status)
     self
   end
@@ -402,11 +402,11 @@ class Leptris::XML::Document
                    exclusive: false,
                    mode: nil)
     raise Leptris::XML::UseAfterFreeError if @freed.state == :freed
-    return "" if @c_ptr.nil?
+    return "" if c_ptr.nil?
     resolved_mode = mode || (exclusive ? Leptris::XML::FFI::C14N_MODE_EXCLUSIVE
                                        : Leptris::XML::FFI::C14N_MODE_CANONICAL)
     Leptris::XML::Serialization.canonicalize(
-      Leptris::XML::FFI.method(:leptris_c14n_canonicalize_ex), @c_ptr,
+      Leptris::XML::FFI.method(:leptris_c14n_canonicalize_ex), c_ptr,
       version: version, mode: resolved_mode,
       inclusive_namespaces: inclusive_namespaces,
       with_comments: with_comments)
@@ -416,7 +416,7 @@ class Leptris::XML::Document
   def free
     return if @freed.state == :freed
     @freed.state = :freed
-    Leptris::XML::FFI.leptris_document_free(@c_ptr) unless @c_ptr.nil?
+    Leptris::XML::FFI.leptris_document_free(c_ptr) unless c_ptr.nil?
     @c_ptr = nil
     @c_address = nil
     @wrapper_cache&.clear
@@ -432,7 +432,7 @@ class Leptris::XML::Document
   # handlers. Returns self for chaining.
   def exslt
     Leptris::XML::FFI.check_status(
-      Leptris::XML::FFI.leptris_exslt_enable(@c_ptr))
+      Leptris::XML::FFI.leptris_exslt_enable(c_ptr))
     self
   end
 
@@ -440,11 +440,11 @@ class Leptris::XML::Document
   # an array of [target, data] pairs in document order.
   def processing_instructions
     return @processing_instructions if @pi_version == @version
-    count = Leptris::XML::FFI.leptris_document_pi_count(@c_ptr)
+    count = Leptris::XML::FFI.leptris_document_pi_count(c_ptr)
     result = count.times.map do |i|
-      [Leptris::XML::FFI.leptris_document_pi_target(@c_ptr, i),
+      [Leptris::XML::FFI.leptris_document_pi_target(c_ptr, i),
        Leptris::XML::FFI.read_pi_data(
-         Leptris::XML::FFI.leptris_document_pi_data(@c_ptr, i)).to_s]
+         Leptris::XML::FFI.leptris_document_pi_data(c_ptr, i)).to_s]
     end
     @processing_instructions = result
     @pi_version = @version
@@ -460,10 +460,10 @@ class Leptris::XML::Document
     raise Leptris::XML::UseAfterFreeError if @freed.state == :freed
     if target_or_index.is_a?(Integer)
       ptr = Leptris::XML::FFI.leptris_document_remove_pi(
-        @c_ptr, nil, target_or_index)
+        c_ptr, nil, target_or_index)
     else
       ptr = Leptris::XML::FFI.leptris_document_remove_pi(
-        @c_ptr, target_or_index.to_s, 0)
+        c_ptr, target_or_index.to_s, 0)
     end
     return nil if ptr.null?
     @version += 1
@@ -473,7 +473,7 @@ class Leptris::XML::Document
   # Append a document-level processing instruction. Returns self.
   def add_pi(target, data = "")
     witness = Leptris::XML::FFI.leptris_document_add_pi(
-      @c_ptr, target.to_s, data.to_s)
+      c_ptr, target.to_s, data.to_s)
     raise Leptris::XML::Error, "leptris_document_add_pi failed" if witness.null?
     @version += 1
     self
@@ -485,7 +485,7 @@ class Leptris::XML::Document
   # this is the writer). Returns self.
   def add_comment(content)
     witness = Leptris::XML::FFI.leptris_document_add_comment(
-      @c_ptr, content.to_s)
+      c_ptr, content.to_s)
     raise Leptris::XML::Error,
       "leptris_document_add_comment failed" if witness.null?
     @version += 1
@@ -497,7 +497,7 @@ class Leptris::XML::Document
   # (names, content, children, attributes) since they can never go
   # stale. The C document is also frozen (advisory upstream). One-way.
   def readonly!
-    Leptris::XML::FFI.leptris_document_freeze(@c_ptr)
+    Leptris::XML::FFI.leptris_document_freeze(c_ptr)
     @readonly = true
     self
   end
@@ -509,7 +509,7 @@ class Leptris::XML::Document
   # True once #free has run (or the GC finalizer fired) — borrowed
   # handles check this before dereferencing their c_ptr.
   def freed?
-    @freed.state == :freed || @c_ptr.nil?
+    @freed.state == :freed || c_ptr.nil?
   end
 
   # Document-level comments — parsed <!-- ... --> outside the
@@ -518,9 +518,9 @@ class Leptris::XML::Document
   # 1.9.3, upstream #578). Version-memoized like the PI list.
   def comments
     return @comments if @comments_version == @version
-    count = Leptris::XML::FFI.leptris_document_comment_count(@c_ptr)
+    count = Leptris::XML::FFI.leptris_document_comment_count(c_ptr)
     result = Array.new(count) do |i|
-      Leptris::XML::FFI.leptris_document_comment_content(@c_ptr, i)
+      Leptris::XML::FFI.leptris_document_comment_content(c_ptr, i)
     end
     @comments = result
     @comments_version = @version
@@ -545,15 +545,15 @@ class Leptris::XML::Document
 
   # The most recent error recorded against this document, or nil.
   def last_error
-    msg = Leptris::XML::FFI.leptris_document_last_error(@c_ptr)
+    msg = Leptris::XML::FFI.leptris_document_last_error(c_ptr)
     msg.nil? || msg.empty? ? nil : msg
   end
 
   def name; "document"; end
   def document; self; end
   def encoding
-    return nil if @c_ptr.nil?
-    Leptris::XML::FFI.leptris_document_encoding(@c_ptr)
+    return nil if c_ptr.nil?
+    Leptris::XML::FFI.leptris_document_encoding(c_ptr)
   end
 
   include Leptris::XML::Searchable

data/lib/leptris/xml/document_fragment.rb

@@ -25,7 +25,7 @@ class Leptris::XML::DocumentFragment
   end
 
   def children
-    pointers, kinds = Leptris::XML::FFI.fetch_children(@c_ptr)
+    pointers, kinds = Leptris::XML::FFI.fetch_children(c_ptr)
     nodes = Array.new(pointers.size) do |i|
       Leptris::XML::Node.wrap(pointers[i], @document, node_type: kinds[i])
     end