lora-ruby 0.8.5 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8f72fa76f2d63847c463cc5c593bbe9e8995cf34a64bc8eec60e701a183160fa
-  data.tar.gz: a76de1f7ca4da81c27ba3bd2053c40972a534b01b29bd31bf79bacb9f551855f
+  metadata.gz: f5e8fafa0e3463f9478a2fe5ee4508dcb8952ba61611b6ce49f8d0fc25ae2bb6
+  data.tar.gz: 653fd6d952de9430140bf6574ae86995e0750c387e308c9709bc8cf3be726408
 SHA512:
-  metadata.gz: 53d140c867e9a6d5aec77ce394a19fa28f6506ae9f212648a7ab62788926c8f4e4c2589f311ff465e21f9c259ab5513d20814a645493549610b0d20b81a5d9d8
-  data.tar.gz: ff1c852d76857f3381faf68347229687996253b921e69265793af586f64e75abb421598852ea5f8e15d759d8a7d2410c1308d0a8e894c8065c54ff27df56a336
+  metadata.gz: 626786c04ec31baef4f51e5ba58440ba9755bcff854325f65e88f35b689117634bde1f4edfb6cf55661c130f80e2a1075c853ccc9a765a5d12ce0f06a7ddfb37
+  data.tar.gz: e95004f92f2a18f0a8ade9d0a98963e2b56ebc1e038850658f007173d007652b7b3eee17d062d6163ff4f544c5a86ef1ec0b3d478d98eab793920aff9a3bf35b

data/lib/lora_ruby/version.rb

@@ -10,5 +10,5 @@ module LoraRuby
   # Guard against redefinition so re-requiring this file (or loading
   # both paths) doesn't emit a "warning: already initialized constant"
   # when the native extension loads second with the identical value.
-  VERSION = "0.8.5" unless const_defined?(:VERSION)
+  VERSION = "0.9.0" unless const_defined?(:VERSION)
 end

data/src/errors.rs

@@ -9,18 +9,15 @@
 use lora_database::{LoraError, LoraErrorCode};
 use magnus::{prelude::*, Error as MagnusError, ExceptionClass, RModule, Ruby};
 
-pub(crate) fn lora_module(ruby: &Ruby) -> RModule {
-    ruby.class_object()
-        .const_get::<_, RModule>("LoraRuby")
-        .expect("LoraRuby module is defined by `init` before any method runs")
-}
-
 pub(crate) fn lora_error_class(ruby: &Ruby, name: &str) -> ExceptionClass {
     // `const_get::<_, ExceptionClass>` converts the stored RClass into
     // an ExceptionClass — this is the sound path, because our subclasses
     // of StandardError retain the exception-class trait on the Ruby
     // side even though `define_class` typed them as RClass.
-    lora_module(ruby)
+    let Ok(module) = ruby.class_object().const_get::<_, RModule>("LoraRuby") else {
+        return ruby.exception_standard_error();
+    };
+    module
         .const_get::<_, ExceptionClass>(name)
         .unwrap_or_else(|_| ruby.exception_standard_error())
 }

data/src/gvl.rs

@@ -1,7 +1,39 @@
 //! Global VM Lock release primitive.
 
 use std::ffi::c_void;
+use std::fmt;
 use std::mem::MaybeUninit;
+use std::panic::{catch_unwind, AssertUnwindSafe};
+
+pub(crate) struct GvlPanic {
+    payload: Box<dyn std::any::Any + Send>,
+}
+
+impl GvlPanic {
+    fn new(payload: Box<dyn std::any::Any + Send>) -> Self {
+        Self { payload }
+    }
+
+    fn message(&self) -> &str {
+        if let Some(s) = self.payload.downcast_ref::<&'static str>() {
+            s
+        } else if let Some(s) = self.payload.downcast_ref::<String>() {
+            s.as_str()
+        } else {
+            "non-string panic payload"
+        }
+    }
+}
+
+impl fmt::Display for GvlPanic {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(
+            f,
+            "engine panicked while Ruby GVL was released: {}",
+            self.message()
+        )
+    }
+}
 
 /// Run `f` with Ruby's Global VM Lock released.
 ///
@@ -11,7 +43,7 @@ use std::mem::MaybeUninit;
 /// keeping all such work on the calling thread. Everything inside
 /// `database_execute`'s closure is pure Rust on pre-extracted data, so
 /// this is sound.
-pub(crate) fn without_gvl<F, R>(f: F) -> R
+pub(crate) fn without_gvl<F, R>(f: F) -> Result<R, GvlPanic>
 where
     F: FnOnce() -> R,
     F: Send,
@@ -19,7 +51,7 @@ where
 {
     struct Data<F, R> {
         func: Option<F>,
-        result: MaybeUninit<R>,
+        result: MaybeUninit<std::thread::Result<R>>,
     }
 
     unsafe extern "C" fn trampoline<F, R>(data: *mut c_void) -> *mut c_void
@@ -27,11 +59,13 @@ where
         F: FnOnce() -> R,
     {
         let data = &mut *(data as *mut Data<F, R>);
-        let f = data
-            .func
-            .take()
-            .expect("without_gvl: closure already taken");
-        data.result.write(f());
+        let result = match data.func.take() {
+            Some(f) => catch_unwind(AssertUnwindSafe(f)),
+            None => {
+                Err(Box::new("without_gvl: closure already taken") as Box<dyn std::any::Any + Send>)
+            }
+        };
+        data.result.write(result);
         std::ptr::null_mut()
     }
 
@@ -50,6 +84,6 @@ where
             None,
             std::ptr::null_mut(),
         );
-        data.result.assume_init()
+        data.result.assume_init().map_err(GvlPanic::new)
     }
 }

data/src/lib.rs

@@ -146,8 +146,7 @@ impl Database {
 // cost-equivalent.
 fn database_new(ruby: &Ruby, args: &[Value]) -> Result<Database, MagnusError> {
     let (database_name, options) = database_open_args(ruby, args)?;
-    let db = without_gvl(move || open_database(database_name, options))
-        .map_err(|e| query_error(ruby, e))?;
+    let db = without_gvl_string_result(ruby, move || open_database(database_name, options))?;
     Ok(Database::from_db(db))
 }
 
@@ -180,7 +179,7 @@ fn database_open_wal(ruby: &Ruby, args: &[Value]) -> Result<Database, MagnusErro
         ));
     }
     options.wal_dir = Some(wal_dir);
-    let db = without_gvl(move || open_wal_database(options)).map_err(|e| query_error(ruby, e))?;
+    let db = without_gvl_string_result(ruby, move || open_wal_database(options))?;
     Ok(Database::from_db(db))
 }
 
@@ -229,8 +228,9 @@ fn database_save_snapshot(
 ) -> Result<RHash, MagnusError> {
     let (path, options) = snapshot_file_args(ruby, args)?;
     let db = database_inner(ruby, rb_self)?;
-    let meta = without_gvl(move || db.save_snapshot_to_with_options(&path, &options))
-        .map_err(|e| query_error_from_anyhow(ruby, e))?;
+    let meta = without_gvl_lora_result(ruby, move || {
+        db.save_snapshot_to_with_options(&path, &options)
+    })?;
     snapshot_meta_to_rhash(ruby, meta)
 }
 
@@ -241,9 +241,9 @@ fn database_load_snapshot(
 ) -> Result<RHash, MagnusError> {
     let (path, credentials) = snapshot_load_file_args(ruby, args)?;
     let db = database_inner(ruby, rb_self)?;
-    let meta =
-        without_gvl(move || db.load_snapshot_from_with_credentials(&path, credentials.as_ref()))
-            .map_err(|e| query_error_from_anyhow(ruby, e))?;
+    let meta = without_gvl_lora_result(ruby, move || {
+        db.load_snapshot_from_with_credentials(&path, credentials.as_ref())
+    })?;
     snapshot_meta_to_rhash(ruby, meta)
 }
 
@@ -456,6 +456,31 @@ fn database_inner(
         .ok_or_else(|| query_error(ruby, "database is closed"))
 }
 
+fn without_gvl_string_result<T>(
+    ruby: &Ruby,
+    f: impl FnOnce() -> Result<T, String> + Send,
+) -> Result<T, MagnusError>
+where
+    T: Send,
+{
+    without_gvl(f)
+        .map_err(|panic| query_error(ruby, panic.to_string()))?
+        .map_err(|e| query_error(ruby, e))
+}
+
+fn without_gvl_lora_result<T, E>(
+    ruby: &Ruby,
+    f: impl FnOnce() -> Result<T, E> + Send,
+) -> Result<T, MagnusError>
+where
+    T: Send,
+    E: Into<lora_database::LoraError> + Send,
+{
+    without_gvl(f)
+        .map_err(|panic| query_error(ruby, panic.to_string()))?
+        .map_err(|e| query_error_from_anyhow(ruby, e))
+}
+
 /// `execute(query, params = nil)` — `-1` arity so `params` is optional and
 /// we can distinguish "not passed" from `nil`/`{}` (both map to empty
 /// params). Everything that touches Ruby values happens under the GVL;
@@ -494,17 +519,16 @@ fn database_execute(ruby: &Ruby, rb_self: &Database, args: &[Value]) -> Result<R
     // is pure Rust — no Ruby values cross the boundary — which keeps this
     // sound.
     let db = database_inner(ruby, rb_self)?;
-    let exec_result = without_gvl(move || {
+    let exec_result = without_gvl_lora_result(ruby, move || {
         let options = ExecuteOptions {
             format: ResultFormat::RowArrays,
         };
         db.execute_with_params(&query, Some(options), params_map)
-    });
+    })?;
 
     let row_arrays = match exec_result {
-        Ok(QueryResult::RowArrays(r)) => r,
-        Ok(_) => return Err(query_error(ruby, "expected RowArrays result")),
-        Err(e) => return Err(query_error_from_anyhow(ruby, e)),
+        QueryResult::RowArrays(r) => r,
+        _ => return Err(query_error(ruby, "expected RowArrays result")),
     };
 
     let out = ruby.hash_new();
@@ -536,8 +560,7 @@ fn database_explain(ruby: &Ruby, rb_self: &Database, args: &[Value]) -> Result<R
         None => None,
     };
     let db = database_inner(ruby, rb_self)?;
-    let plan = without_gvl(move || db.explain(&query, params_map))
-        .map_err(|e| query_error_from_anyhow(ruby, e))?;
+    let plan = without_gvl_lora_result(ruby, move || db.explain(&query, params_map))?;
     query_plan_to_ruby(ruby, &plan)
 }
 
@@ -554,8 +577,7 @@ fn database_profile(ruby: &Ruby, rb_self: &Database, args: &[Value]) -> Result<R
         None => None,
     };
     let db = database_inner(ruby, rb_self)?;
-    let prof = without_gvl(move || db.profile(&query, params_map))
-        .map_err(|e| query_error_from_anyhow(ruby, e))?;
+    let prof = without_gvl_lora_result(ruby, move || db.profile(&query, params_map))?;
     query_profile_to_ruby(ruby, &prof)
 }
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lora-ruby
 version: !ruby/object:Gem::Version
-  version: 0.8.5
+  version: 0.9.0
 platform: ruby
 authors:
 - LoraDB, Inc.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-05-06 00:00:00.000000000 Z
+date: 2026-05-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rb_sys