leptris 1.9.162.1 → 1.9.162.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7a0d781b64373e54b12695b3729ee006b1fd142cc72b2d46db4a6f7314e0c0e8
-  data.tar.gz: 23acc9e2a5d5c9a014e0d480729d7f569f662274956c56fcc22e54795f050b57
+  metadata.gz: d09354998670281f8e6519fa0cf7b35c467d67e7536879b31be2b3efa634250e
+  data.tar.gz: 362d92cf0e463160f94ecab7639a60d867680e47610bed4cac408dc0e835c1fb
 SHA512:
-  metadata.gz: 559c4771c00c196028387b1f9376581227792f3f979bbb11960807b2ce3f2f51f231fd67d1131034362eb5bd80a8ad062d5c1da59b5ad45805a68c4e2f1561da
-  data.tar.gz: 5cb77399413c18c75ea0256a3ac6b62c98d2a4988c72b952337d0f047eee0fd4820e52961a4a4e16a1bbf09a188878e953429f24816ad7c431193e67b4bdfdde
+  metadata.gz: 59ee84ed455a5621ab3be63c4fb54ddf3d9b42346cb32f8f9a7c967f884bb70a04cb4e3864528718b26dfe725540f05f27ec06f64c44a252f203b40ff9484d8f
+  data.tar.gz: 66d52689d9be07a40fee5739959878556f393ec0c86fb94b5e36c95ab36c38d022be579ff7189561f96f91eac972035e77e645eff0b8dae272b345dbc2f9667d

data/CHANGELOG.md

@@ -5,7 +5,72 @@ 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.1] - 2026-09-14
+## [1.9.162.6] - 2026-09-14
+
+### Fixed
+
+- **Native layer linkage, resolved**: setup-ruby's custom rubies
+  link libruby by absolute runner path through mkmf no matter
+  which RbConfig entries are cleared (and a post-link
+  install_name_tool rewrite rebinds every Ruby symbol to the
+  replacement — 1.9.162.5's "Symbol not found: rb_cObject"). The
+  darwin bundle is now linked directly in the Rakefile: compile
+  via the Makefile, link with pure -undefined dynamic_lookup and
+  -mmacosx-version-min=11.0 — no libruby LC_LOAD_DYLIB can exist.
+  Build log prints otool -L as the standing contract check.
+\n## [1.9.162.5] - 2026-09-14
+
+### Fixed
+
+- **Native layer linkage, third round**: the runner-side
+  libruby reference came from setup-ruby's LIBRUBYARG_SHARED
+  (an absolute runner path recorded as LC_LOAD_DYLIB —
+  unresolvable on user machines), not from the link flags. The
+  extconf now clears the libruby link args for the bundle target
+  (Ruby symbols resolve from the loading interpreter); the
+  Rakefile prints otool -L into the build log as the standing
+  linkage contract check.
+\n## [1.9.162.4] - 2026-09-14
+
+### Fixed
+
+- **Native layer linkage, second round**: 1.9.162.3's
+  -undefined dynamic_lookup rode $LDFLAGS, which the release
+  runner's Ruby 3.3 mkmf drops from the bundle link line. The
+  extconf now pins BOTH $LDFLAGS and $DLDFLAGS (plus
+  -mmacosx-version-min in the compile flags) — verified locally:
+  minos 11.0, libSystem-only linkage.
+\n## [1.9.162.3] - 2026-09-14
+
+### Fixed
+
+- **Native layer bundle linkage**: the 1.9.162.2 platform gems'
+  native.bundle linked the BUILDING runner's libruby by absolute
+  path and targeted the runner's macOS — failing to load on user
+  machines. The ext now links with -undefined dynamic_lookup
+  (Ruby symbols resolve from the loading interpreter, the standard
+  C-extension convention) and a conservative deployment target;
+  the bundle references only libSystem.
+\n## [1.9.162.2] - 2026-09-14
+
+### Added
+
+- **Opt-in native read layer** (#185 / TODO.restructure/21 round
+  2): `require "leptris/xml/native_layer"` activates
+  `Document#native_node` — TypedData node wrappers with the C
+  pointer and owning document embedded in one RVALUE, hot reads
+  (#name, #content, #[]/#attribute, #children, #element_children,
+  #next_sibling, #parent, #node_type) bound directly in C over the
+  dlsym-resolved library, and children constructed in bulk (one
+  wrapper-cache round-trip, zero Ruby frames, zero per-node
+  FFI::Pointer). Measured **~5x on raw walks** vs the binding path
+  and **~45 kB/doc held wrappers**; identity is shared with the
+  binding through the per-document wrapper cache, so both views
+  of one document interoperate. The default require path never
+  loads the compiled bundle; installs without it (ruby-platform
+  gem) get a clear LoadError. The ext ships vendored in platform
+  gems (no compile at install).
+\n## [1.9.162.1] - 2026-09-14
 
 ### Performance
 

data/Rakefile

@@ -85,6 +85,37 @@ task :compile do
   raise "utf8proc shared library not found after build" unless u8_lib
   cp(u8_lib, "lib/#{File.basename(u8_lib)}")
   puts "Vendored #{File.basename(lib)} + #{File.basename(u8_lib)} into lib/"
+
+  # Opt-in native read layer ext (#185): built and vendored beside
+  # the library — no compile at install; resolves libleptris at
+  # require time via dlsym.
+  ext_dir = "ext/leptris/native"
+  Dir.chdir(ext_dir) do
+    sh "ruby extconf.rb"
+    if RUBY_PLATFORM =~ /darwin/
+      # Link the bundle ourselves: setup-ruby's custom rubies make
+      # mkmf link libruby by absolute runner path no matter which
+      # RbConfig entries are cleared, and any libruby
+      # LC_LOAD_DYLIB is unresolvable on user machines. Compile
+      # via the Makefile, link with pure -undefined dynamic_lookup
+      # (Ruby symbols resolve from the loading interpreter) and a
+      # conservative deployment target.
+      sh "make native.o"
+      sh "cc -dynamic -bundle -undefined dynamic_lookup " \
+         "-mmacosx-version-min=#{ENV['MACOSX_DEPLOYMENT_TARGET'] || '11.0'} " \
+         "-o native.bundle native.o"
+    else
+      sh "make"
+    end
+  end
+  bundle = Dir.glob("#{ext_dir}/native.{bundle,so,dll}").first
+  raise "native layer bundle not found after build" unless bundle
+  if RUBY_PLATFORM =~ /darwin/
+    # Build-log proof of the linkage contract: libSystem only.
+    puts `otool -L #{bundle}`
+  end
+  cp(bundle, "lib/leptris/xml/#{File.basename(bundle)}")
+  puts "Vendored native layer (#{File.basename(bundle)}) into lib/leptris/xml/"
 end
 
 task spec: :compile unless ENV.key?("LEPTRIS_LIB_PATH")
@@ -189,6 +220,7 @@ 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}")
+    spec.files += Dir.glob("lib/leptris/xml/native.{bundle,so,dll}")
     task = Gem::PackageTask.new(spec)
     task.define
   end

data/TODO.restructure/21-typeddata-variant-prototype.md

@@ -1,6 +1,11 @@
 # 21 — #147 option B: TypedData wrapper variant (owner greenlit)
 
-Status: PROTOTYPE DONE — hypothesis VALIDATED (114 B/node measured)
+Status: round 2 PASSED (2026-09-14) — branch proto/native-nodes
+is the reference implementation; build phase remains (full read
+surface, seam, 9-platform packaging). Round 1 handle-level spike
+(feat/typed-wrapper-variant, never merged) FAILED its gate — held
+-8% vs walks +40% because per-call FFI::Pointer marshaling
+dominates; the fix was C-binding the reads themselves.
 
 The greenlight arrived ("proceed with all"); the execution plan,
 in verification order:
@@ -24,3 +29,14 @@ in verification order:
       compilation per platform, packaging).
 - [ ] If NOT validated (win < ~15%): record the negative result on
       #147 and close option B with data.
+
+## Round 2 (2026-09-14): converged native nodes — PASSED
+
+ext/leptris/native/native.c: TypedData wrappers (ptr + document
+embedded), C-bound hot reads via dlsym (no FFI marshaling), bulk
+children (one cache round-trip, zero Ruby frames). Measured: walk
+17.2 -> 2.8 ms (6.2x, interleaved best-of under load ~148 — ratio
+conservative); held wrappers ~54 kB/doc (RSS, load-independent).
+Identity shared through the binding wrapper_cache. Data on #185.
+Remaining: full read surface, variant seam, compiled-ext
+packaging (9-platform), release.

data/ext/leptris/native/extconf.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+# The bundle must load into ANY Ruby (not the building runner's):
+# macOS links with -undefined dynamic_lookup (Ruby symbols resolve
+# from the loading interpreter — the standard C-ext convention)
+# and a conservative deployment target; libruby is never linked.
+ENV["MACOSX_DEPLOYMENT_TARGET"] ||= "11.0"
+require "mkmf"
+if RUBY_PLATFORM =~ /darwin/
+  # Robust across mkmf versions: older rubies drop $(ldflags)
+  # from the bundle link line, so pin BOTH the compile and link
+  # variables. -undefined dynamic_lookup is the standard C-ext
+  # convention (Ruby symbols resolve from the loading
+  # interpreter); -mmacosx-version-min keeps the bundle loadable
+  # on older user OSes than the building runner.
+  min = " -mmacosx-version-min=#{ENV['MACOSX_DEPLOYMENT_TARGET']}"
+  lookup = " -undefined dynamic_lookup"
+  [$LDFLAGS, $DLDFLAGS, $CFLAGS, $CXXFLAGS].each do |var|
+    var << min unless var.include?(min.strip)
+  end
+  [$LDFLAGS, $DLDFLAGS].each do |var|
+    var << lookup unless var.include?("dynamic_lookup")
+  end
+  # setup-ruby builds carry the RUNNER's absolute libruby path in
+  # LIBRUBYARG_SHARED — recorded as an LC_LOAD_DYLIB in the
+  # bundle, unresolvable on user machines. A Ruby extension
+  # resolves Ruby symbols from the loading interpreter; never
+  # link libruby.
+  # BOTH maps: mkmf's Makefile interpolates from MAKEFILE_CONFIG,
+  # not CONFIG — clearing only CONFIG is a silent no-op (caught via
+  # the build-log otool on the runner).
+  RbConfig::CONFIG["LIBRUBYARG_SHARED"] = ""
+  RbConfig::CONFIG["LIBRUBYARG_STATIC"] = ""
+  RbConfig::MAKEFILE_CONFIG["LIBRUBYARG_SHARED"] = ""
+  RbConfig::MAKEFILE_CONFIG["LIBRUBYARG_STATIC"] = ""
+end
+create_makefile("leptris/xml/native")

data/ext/leptris/native/native.c

@@ -0,0 +1,295 @@
+/* Native TypedData node prototype (#185/#147/#187 converged):
+ * wrapper objects with the C pointer embedded (no FFI::Pointer per
+ * node), hot reads (name/content/attribute) called directly in C
+ * via dlsym on the FFI-loaded library, and children constructed in
+ * bulk — one cache round-trip, zero Ruby frames, zero FFI
+ * marshaling per node. */
+#include <ruby.h>
+#include <stdint.h>
+#include <string.h>
+
+#ifdef _WIN32
+#include <windows.h>
+#else
+#include <dlfcn.h>
+#endif
+
+typedef const char *(*elem_name_fn)(void *);
+typedef const char *(*text_content_fn)(void *);
+typedef const char *(*attr_fn)(void *, const char *);
+typedef int (*children_ex_fn)(void *, void **, int *, int);
+typedef int (*node_type_fn)(void *);
+typedef void *(*next_sibling_fn)(void *);
+typedef void *(*parent_fn)(void *);
+typedef const char *(*element_text_fn)(void *);
+
+static elem_name_fn f_elem_name;
+static text_content_fn f_text_content;
+static attr_fn f_attr;
+static children_ex_fn f_children_ex;
+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 VALUE c_native_node;
+static ID id_wrapper_cache;
+
+#define NT_ELEMENT 0
+
+struct native_node {
+    void *ptr;
+    VALUE document;
+};
+
+static void nn_mark(void *p)
+{
+    struct native_node *n = p;
+    if (n->document != Qnil)
+        rb_gc_mark(n->document);
+}
+
+static size_t nn_size(const void *p) { (void)p; return sizeof(struct native_node); }
+
+static const rb_data_type_t nn_type = {
+    "Leptris/XML/NativeNode",
+    { nn_mark, RUBY_TYPED_DEFAULT_FREE, nn_size, },
+    0, 0, RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+#ifdef _WIN32
+static void *lib_open(const char *path) { return (void *)LoadLibraryA(path); }
+static void *lib_sym(void *h, const char *name)
+{
+    return (void *)GetProcAddress((HMODULE)h, name);
+}
+#else
+static void *lib_open(const char *path) { return dlopen(path, RTLD_NOW); }
+static void *lib_sym(void *h, const char *name) { return dlsym(h, name); }
+#endif
+
+static void resolve_symbols(const char *lib_path)
+{
+    void *h = lib_open(lib_path);
+    if (!h)
+        rb_raise(rb_eRuntimeError, "cannot load library %s", lib_path);
+    f_elem_name = (elem_name_fn)lib_sym(h, "leptris_element_name");
+    f_text_content = (text_content_fn)lib_sym(h, "leptris_text_node_get_content");
+    f_attr = (attr_fn)lib_sym(h, "leptris_element_attribute");
+    f_children_ex = (children_ex_fn)lib_sym(h, "leptris_node_children_ex");
+    f_node_type = (node_type_fn)lib_sym(h, "leptris_node_get_type");
+    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");
+    if (!f_elem_name || !f_text_content || !f_attr ||
+        !f_children_ex || !f_node_type || !f_next_sibling || !f_parent ||
+        !f_element_text)
+        rb_raise(rb_eRuntimeError, "libleptris symbols missing");
+}
+
+static VALUE nn_name(VALUE self)
+{
+    struct native_node *n;
+    const char *s;
+    TypedData_Get_Struct(self, struct native_node, &nn_type, n);
+    s = f_elem_name(n->ptr);
+    return s ? rb_str_new_cstr(s) : Qnil;
+}
+
+static VALUE nn_content(VALUE self)
+{
+    struct native_node *n;
+    const char *s;
+    TypedData_Get_Struct(self, struct native_node, &nn_type, n);
+    /* elements aggregate their text (leptris_element_text); text
+     * nodes carry it directly. */
+    s = f_node_type(n->ptr) == 0 ? f_element_text(n->ptr)
+                                 : f_text_content(n->ptr);
+    return s ? rb_str_new_cstr(s) : Qnil;
+}
+
+static VALUE nn_attribute(VALUE self, VALUE name)
+{
+    struct native_node *n;
+    const char *s;
+    TypedData_Get_Struct(self, struct native_node, &nn_type, n);
+    s = f_attr(n->ptr, StringValueCStr(name));
+    return s ? rb_str_new_cstr(s) : Qnil;
+}
+
+static VALUE nn_allocate(VALUE klass)
+{
+    struct native_node *n;
+    return TypedData_Make_Struct(klass, struct native_node, &nn_type, n);
+}
+
+/* Bulk children: one native pass; cache check/store inline; the
+ * document's wrapper_cache (a Ruby Hash keyed by address) provides
+ * identity for nodes seen through other paths. */
+static VALUE nn_children(VALUE self)
+{
+    struct native_node *n;
+    void *buf[512];
+    int kinds[512];
+    int count, i;
+    VALUE cache, out;
+
+    TypedData_Get_Struct(self, struct native_node, &nn_type, n);
+    count = f_children_ex(n->ptr, buf, kinds, 512);
+    if (count <= 0)
+        return rb_ary_new2(0);
+
+    cache = rb_funcall(n->document, id_wrapper_cache, 0);
+    out = rb_ary_new2(count);
+    for (i = 0; i < count; i++) {
+        uint64_t addr = (uint64_t)(uintptr_t)buf[i];
+        VALUE key = ULL2NUM(addr);
+        VALUE child = rb_hash_aref(cache, key);
+        if (NIL_P(child)) {
+            struct native_node *cn;
+            child = nn_allocate(c_native_node);
+            TypedData_Get_Struct(child, struct native_node, &nn_type, cn);
+            cn->ptr = buf[i];
+            cn->document = n->document;
+            rb_hash_aset(cache, key, child);
+        }
+        rb_ary_push(out, child);
+    }
+    return out;
+}
+
+static VALUE nn_type_sym(VALUE self)
+{
+    struct native_node *n;
+    TypedData_Get_Struct(self, struct native_node, &nn_type, n);
+    switch (f_node_type(n->ptr)) {
+    case 0: return ID2SYM(rb_intern("element"));
+    case 1: return ID2SYM(rb_intern("text"));
+    case 2: return ID2SYM(rb_intern("comment"));
+    case 3: return ID2SYM(rb_intern("cdata"));
+    case 4: return ID2SYM(rb_intern("pi"));
+    default: return ID2SYM(rb_intern("node"));
+    }
+}
+
+/* Bulk children filtered to elements — the walk shape consumers
+ * actually iterate (#185's element_children parity). */
+static VALUE nn_element_children(VALUE self)
+{
+    struct native_node *n;
+    void *buf[512];
+    int kinds[512];
+    int count, i;
+    VALUE cache, out;
+
+    TypedData_Get_Struct(self, struct native_node, &nn_type, n);
+    count = f_children_ex(n->ptr, buf, kinds, 512);
+    if (count <= 0)
+        return rb_ary_new2(0);
+
+    cache = rb_funcall(n->document, id_wrapper_cache, 0);
+    out = rb_ary_new();
+    for (i = 0; i < count; i++) {
+        if (kinds[i] != NT_ELEMENT)
+            continue;
+        VALUE key = ULL2NUM((uint64_t)(uintptr_t)buf[i]);
+        VALUE child = rb_hash_aref(cache, key);
+        if (NIL_P(child)) {
+            struct native_node *cn;
+            child = nn_allocate(c_native_node);
+            TypedData_Get_Struct(child, struct native_node, &nn_type, cn);
+            cn->ptr = buf[i];
+            cn->document = n->document;
+            rb_hash_aset(cache, key, child);
+        }
+        rb_ary_push(out, child);
+    }
+    return out;
+}
+
+static VALUE wrap_cached(struct native_node *owner, void *ptr)
+{
+    VALUE cache, key, node;
+    struct native_node *n;
+
+    cache = rb_funcall(owner->document, id_wrapper_cache, 0);
+    key = ULL2NUM((uint64_t)(uintptr_t)ptr);
+    node = rb_hash_aref(cache, key);
+    if (!NIL_P(node))
+        return node;
+    node = nn_allocate(c_native_node);
+    TypedData_Get_Struct(node, struct native_node, &nn_type, n);
+    n->ptr = ptr;
+    n->document = owner->document;
+    rb_hash_aset(cache, key, node);
+    return node;
+}
+
+static VALUE nn_next_sibling(VALUE self)
+{
+    struct native_node *n;
+    void *sib;
+    TypedData_Get_Struct(self, struct native_node, &nn_type, n);
+    sib = f_next_sibling(n->ptr);
+    return sib ? wrap_cached(n, sib) : Qnil;
+}
+
+static VALUE nn_parent(VALUE self)
+{
+    struct native_node *n;
+    void *par;
+    TypedData_Get_Struct(self, struct native_node, &nn_type, n);
+    par = f_parent(n->ptr);
+    return par ? wrap_cached(n, par) : Qnil;
+}
+
+static VALUE nn_from(VALUE klass, VALUE document, VALUE element)
+{
+    /* Element address comes through the binding's #c_ptr address;
+     * registered in the shared identity cache so parent/sibling
+     * round-trips return the same object. */
+    struct native_node *n;
+    VALUE node = nn_allocate(klass);
+    void *ptr = (void *)(uintptr_t)NUM2ULL(
+        rb_funcall(element, rb_intern("address"), 0));
+    TypedData_Get_Struct(node, struct native_node, &nn_type, n);
+    n->ptr = ptr;
+    n->document = document;
+    rb_hash_aset(rb_funcall(document, id_wrapper_cache, 0),
+                 ULL2NUM((uint64_t)(uintptr_t)ptr), node);
+    return node;
+}
+
+/* Ruby-side bootstrap: resolve the libleptris symbols once, from
+ * the path the FFI layer loaded. */
+static VALUE leptris_native_resolve_rb(VALUE self, VALUE lib_path)
+{
+    (void)self;
+    resolve_symbols(StringValueCStr(lib_path));
+    return Qnil;
+}
+
+void Init_native(void)
+{
+    VALUE m_leptris, m_xml;
+
+    m_leptris = rb_define_module("Leptris");
+    m_xml = rb_define_module_under(m_leptris, "XML");
+    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");
+
+    rb_define_singleton_method(c_native_node, "from", nn_from, 2);
+    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);
+    rb_define_alias(c_native_node, "[]", "attribute");
+    rb_define_method(c_native_node, "children", nn_children, 0);
+    rb_define_method(c_native_node, "element_children", nn_element_children, 0);
+    rb_define_method(c_native_node, "next_sibling", nn_next_sibling, 0);
+    rb_define_method(c_native_node, "parent", nn_parent, 0);
+    rb_define_method(c_native_node, "node_type", nn_type_sym, 0);
+    rb_define_singleton_method(c_native_node, "resolve!",
+                               leptris_native_resolve_rb, 1);
+}

data/lib/leptris/version.rb

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

data/lib/leptris/xml/native_layer.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+# Opt-in native read layer (TODO.restructure/21 round 2, #185):
+# TypedData node wrappers with C-bound hot reads and bulk children
+# construction — measured 6.2x on raw walks. Load explicitly:
+#
+#     require "leptris/xml/native"
+#     root = doc.native_node
+#     root.children.each { |c| c.name }
+#
+# Identity is shared with the binding through the per-document
+# wrapper cache, so native and binding views of one document
+# interoperate. The default require path never loads this file;
+# installs without the compiled bundle (ruby-platform gem) raise
+# a clear LoadError from the require.
+
+begin
+  # The compiled bundle (feature "leptris/xml/native" resolves
+  # native.bundle). A sanctioned require exception: a .bundle
+  # cannot go through autoload. Missing in installs that do not
+  # vendor it (ruby-platform gem).
+  require "leptris/xml/native"
+rescue LoadError => e
+  raise LoadError, <<~MSG
+    leptris: the compiled native read layer is not available in
+    this install (#{e.message}). It ships in platform gems; the
+    ruby-platform variant does not carry it.
+  MSG
+end
+
+module Leptris::XML::Native
+  LIB_CANDIDATES = [
+    ENV["LEPTRIS_LIB_PATH"],
+    File.expand_path("../../libleptris.dylib", __dir__),
+    File.expand_path("../../libleptris.so", __dir__),
+    File.expand_path("../../libleptris.dll", __dir__),
+    "libleptris",
+  ].compact.freeze
+end
+
+candidates = Leptris::XML::Native::LIB_CANDIDATES
+resolved = candidates.any? do |path|
+  resolved = Leptris::XML::Native::LIB_CANDIDATES.any? do |path|
+    begin
+      Leptris::XML::NativeNode.resolve!(path)
+      true
+    rescue RuntimeError
+      false
+    end
+  end
+  raise LoadError,
+    "leptris: native layer loaded but libleptris could not be " \
+    "resolved from #{candidates.inspect}" unless resolved
+end
+
+class Leptris::XML::Document
+  # The native-node view of the document root (opt-in read layer).
+  def native_node
+    root or raise Leptris::XML::Error, "document has no root element"
+    Leptris::XML::NativeNode.from(self, root.c_ptr)
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: leptris
 version: !ruby/object:Gem::Version
-  version: 1.9.162.1
+  version: 1.9.162.6
 platform: ruby
 authors:
 - Ribose Inc.
@@ -97,6 +97,8 @@ files:
 - docs/adr/0004-lifetime-guard.md
 - docs/adr/0005-autoload-manifest-ordering.md
 - docs/adr/0006-ruby-variant-policy.md
+- ext/leptris/native/extconf.rb
+- ext/leptris/native/native.c
 - leptris.gemspec
 - lib/leptris.rb
 - lib/leptris/version.rb
@@ -117,6 +119,7 @@ files:
 - lib/leptris/xml/iteration_scope.rb
 - lib/leptris/xml/iterparse.rb
 - lib/leptris/xml/namespace.rb
+- lib/leptris/xml/native_layer.rb
 - lib/leptris/xml/node.rb
 - lib/leptris/xml/node_set.rb
 - lib/leptris/xml/parse_options.rb