rubyx-py 0.1.1 → 0.2.1

data/ext/rubyx/src/lib.rs

@@ -18,6 +18,7 @@ mod convert;
 mod eval;
 mod exception;
 mod future;
+mod gvl;
 mod import;
 mod nonblocking_stream;
 mod pipe_notify;
@@ -94,6 +95,7 @@ fn init(ruby: &magnus::Ruby) -> Result<(), magnus::Error> {
     py_object.define_method("truthy?", method!(RubyxObject::is_truthy, 0))?;
     py_object.define_method("falsy?", method!(RubyxObject::is_falsy, 0))?;
     py_object.define_method("callable?", method!(RubyxObject::is_callable, 0))?;
+    py_object.define_method("call", method!(RubyxObject::call, -1))?;
     py_object.define_method("py_type", method!(RubyxObject::py_type, 0))?;
     py_object.define_method("each", method!(RubyxObject::each, 0))?;
     py_object.include_module(ruby.module_enumerable())?;
@@ -155,7 +157,8 @@ fn init(ruby: &magnus::Ruby) -> Result<(), magnus::Error> {
 
     // Rubyx::Future class
     let future_class = rubyx_module.define_class("Future", ruby.class_object())?;
-    future_class.define_method("value", method!(crate::future::RubyxFuture::value, 0))?;
+    // value() instead of await since await is a reserved keyword
+    future_class.define_method("await", method!(crate::future::RubyxFuture::value, 0))?;
     future_class.define_method("ready?", method!(crate::future::RubyxFuture::is_ready, 0))?;
 
     Ok(())
@@ -2968,13 +2971,17 @@ mod tests {
 
     #[test]
     #[serial]
-    fn test_to_ruby_unconvertible_returns_error() {
+    fn test_to_ruby_wraps_module_via_pyobjectref() {
         with_ruby_python(|_ruby, api| {
-            // Python module objects can't be converted to Ruby primitives
+            // Modules have __dict__ and are not callable, so python_to_sendable
+            // returns PyObjectRef → wrapped as RubyxObject.
             let module = api.import_module("sys").expect("sys should import");
             let wrapper = RubyxObject::new(module, api).unwrap();
             let result = wrapper.to_ruby();
-            assert!(result.is_err(), "module should not be convertible to Ruby");
+            assert!(
+                result.is_ok(),
+                "module should wrap as RubyxObject via PyObjectRef"
+            );
 
             drop(wrapper);
             api.decref(module);
@@ -3008,6 +3015,17 @@ mod tests {
 
     // ========== Rubyx::Future / async_await tests ==========
 
+    /// Spin-wait then call value() — ensures the fast path is hit in tests,
+    /// avoiding rb_thread_call_without_gvl which deadlocks in embedded Ruby.
+    fn test_future_value(
+        future: &crate::future::RubyxFuture,
+    ) -> Result<magnus::Value, magnus::Error> {
+        while !future.is_ready() {
+            std::thread::sleep(std::time::Duration::from_millis(1));
+        }
+        future.value()
+    }
+
     /// Helper: define an async function in globals, create coroutine,
     /// release GIL, run future, restore GIL, return result.
     fn run_future_test(
@@ -3025,7 +3043,7 @@ mod tests {
 
         let tstate = api.save_thread();
         let future = crate::future::RubyxFuture::from_coroutine(coroutine, api);
-        let result = future.value();
+        let result = test_future_value(&future);
         drop(future);
         api.restore_thread(tstate);
 
@@ -3197,14 +3215,18 @@ mod tests {
                 .run_string("get_val()", PY_EVAL_INPUT, globals, globals)
                 .expect("should create coroutine");
 
-            let wrapper = RubyxObject::new(coroutine, api).expect("should wrap coroutine");
-            let coro_value: magnus::Value = magnus::IntoValue::into_value_with(wrapper, ruby);
-            let result =
-                crate::eval::rubyx_await(coro_value).expect("blocking await should succeed");
+            // Manually do what rubyx_await does, but with proper GIL management
+            // for the test environment (can't call rubyx_await directly because
+            // its ensure_gil/release_gil nests incorrectly with with_ruby_python's GIL)
+            let future = crate::future::RubyxFuture::from_coroutine(coroutine, api);
 
-            let obj = magnus::typed_data::Obj::<RubyxObject>::try_convert(result)
-                .expect("should be RubyxObject");
-            assert_eq!(api.long_to_i64(obj.as_ptr()), 99);
+            // Release GIL so the background thread can acquire it
+            let tstate = api.save_thread();
+            let result = test_future_value(&future).expect("await should succeed");
+            drop(future);
+            api.restore_thread(tstate);
+
+            assert_eq!(i64::try_convert(result).unwrap(), 99);
 
             api.decref(globals);
         });
@@ -3223,12 +3245,16 @@ mod tests {
             )
             .expect("should define async function");
 
-            let result = crate::eval::await_eval_with_globals("double(21)", globals, api)
+            let future = crate::eval::await_eval_with_globals("double(21)", globals, api)
                 .expect("await_eval should succeed");
 
-            let obj = magnus::typed_data::Obj::<RubyxObject>::try_convert(result)
-                .expect("should be RubyxObject");
-            assert_eq!(api.long_to_i64(obj.as_ptr()), 42);
+            // Release GIL so background thread can run asyncio
+            let tstate = api.save_thread();
+            let result = test_future_value(&future).expect("future should resolve");
+            drop(future);
+            api.restore_thread(tstate);
+
+            assert_eq!(i64::try_convert(result).unwrap(), 42);
 
             api.decref(globals);
         });
@@ -3247,8 +3273,17 @@ mod tests {
             )
             .expect("should define async function");
 
-            let result = crate::eval::await_eval_with_globals("fail()", globals, api);
-            assert!(result.is_err(), "should propagate error");
+            let future_result = crate::eval::await_eval_with_globals("fail()", globals, api);
+            match future_result {
+                Err(_) => {} // eval itself failed — error propagated
+                Ok(future) => {
+                    // Eval succeeded but asyncio.run should fail
+                    let tstate = api.save_thread();
+                    let result = test_future_value(&future);
+                    api.restore_thread(tstate);
+                    assert!(result.is_err(), "should propagate error");
+                }
+            }
 
             api.decref(globals);
         });
@@ -3430,10 +3465,15 @@ mod tests {
             api.decref(py_a);
             api.decref(py_b);
 
-            let result = crate::eval::await_eval_with_globals("multiply(a, b)", globals, api)
+            let future = crate::eval::await_eval_with_globals("multiply(a, b)", globals, api)
                 .expect("await should succeed");
-            let obj = Obj::<RubyxObject>::try_convert(result).expect("should be RubyxObject");
-            assert_eq!(api.long_to_i64(obj.as_ptr()), 42);
+
+            let tstate = api.save_thread();
+            let result = test_future_value(&future).expect("future should resolve");
+            drop(future);
+            api.restore_thread(tstate);
+
+            assert_eq!(i64::try_convert(result).unwrap(), 42);
 
             api.decref(globals);
         });
@@ -3460,13 +3500,16 @@ mod tests {
             api.decref(key);
             api.decref(py_who);
 
-            let result = crate::eval::await_eval_with_globals("greet(who)", globals, api)
+            let future = crate::eval::await_eval_with_globals("greet(who)", globals, api)
                 .expect("await should succeed");
-            let obj = Obj::<RubyxObject>::try_convert(result).expect("should be RubyxObject");
-            assert_eq!(
-                api.string_to_string(obj.as_ptr()),
-                Some("hi world".to_string())
-            );
+
+            let tstate = api.save_thread();
+            let result = test_future_value(&future).expect("future should resolve");
+            drop(future);
+            api.restore_thread(tstate);
+
+            let s: String = TryConvert::try_convert(result).unwrap();
+            assert_eq!(s, "hi world");
 
             api.decref(globals);
         });
@@ -3493,8 +3536,16 @@ mod tests {
             api.decref(key);
             api.decref(py_val);
 
-            let result = crate::eval::await_eval_with_globals("check(val)", globals, api);
-            assert!(result.is_err(), "should propagate ValueError");
+            let future_result = crate::eval::await_eval_with_globals("check(val)", globals, api);
+            match future_result {
+                Err(_) => {} // eval itself failed
+                Ok(future) => {
+                    let tstate = api.save_thread();
+                    let result = test_future_value(&future);
+                    api.restore_thread(tstate);
+                    assert!(result.is_err(), "should propagate ValueError");
+                }
+            }
 
             api.decref(globals);
         });
@@ -3537,7 +3588,7 @@ mod tests {
             // Release GIL so the background thread can acquire it
             let tstate = api.save_thread();
             let future = crate::future::RubyxFuture::from_coroutine(coroutine, api);
-            let result = future.value().expect("future should resolve");
+            let result = test_future_value(&future).expect("future should resolve");
             drop(future);
             api.restore_thread(tstate);
 
@@ -3582,7 +3633,7 @@ mod tests {
 
             let tstate = api.save_thread();
             let future = crate::future::RubyxFuture::from_coroutine(coroutine, api);
-            let result = future.value().expect("future should resolve");
+            let result = test_future_value(&future).expect("future should resolve");
             drop(future);
             api.restore_thread(tstate);
 
@@ -3626,7 +3677,7 @@ mod tests {
 
             let tstate = api.save_thread();
             let future = crate::future::RubyxFuture::from_coroutine(coroutine, api);
-            let result = future.value();
+            let result = test_future_value(&future);
             drop(future);
             api.restore_thread(tstate);
 

data/ext/rubyx/src/nonblocking_stream.rs

@@ -1,3 +1,4 @@
+use crate::gvl::{rb_thread_call_without_gvl, rb_thread_check_ints, recv_loop, ubf_cancel};
 use crate::pipe_notify::PipeNotify;
 use crate::ruby_helpers::runtime_error;
 use crate::stream::StreamItem;
@@ -9,37 +10,6 @@ use std::os::fd::RawFd;
 use std::sync::atomic::AtomicBool;
 use std::sync::Arc;
 
-extern "C" {
-    /// Release the GVL, call `func(data1)`, then reacquire the GVL.
-    ///
-    /// While `func` runs, other Ruby threads can execute. Inside `func`,
-    /// you must NOT call any Ruby C API or access any Ruby VALUE.
-    ///
-    /// If `ubf` is provided, Ruby may call it from another thread to
-    /// interrupt `func` (e.g., on Thread#kill or signal delivery).
-    ///
-    /// # Safety
-    ///
-    /// - `func` must not touch Ruby objects (GVL is not held).
-    /// - `data1` must remain valid for the duration of `func`.
-    /// - `data2` must remain valid for the duration of `ubf` (if provided).
-    fn rb_thread_call_without_gvl(
-        func: unsafe extern "C" fn(*mut c_void) -> *mut c_void,
-        data1: *mut c_void,
-        ubf: Option<unsafe extern "C" fn(*mut c_void)>,
-        data2: *mut c_void,
-    ) -> *mut c_void;
-
-    /// Check for pending Ruby interrupts (Thread#kill, signals, etc.).
-    ///
-    /// Must be called WITH the GVL held. If an interrupt is pending,
-    /// this raises a Ruby exception (longjmp). Call this immediately
-    /// after `rb_thread_call_without_gvl` returns to deliver any
-    /// interrupts that arrived while the GVL was released.
-    fn rb_thread_check_ints();
-
-}
-
 fn create_ruby_io(ruby: &Ruby, fd: RawFd) -> Result<Value, Error> {
     let io_class: Value = ruby.class_object().const_get("IO")?;
     io_class.funcall("for_fd", (fd, magnus::kwargs!("autoclose" => false)))
@@ -55,54 +25,11 @@ fn has_fiber_scheduler(ruby: &Ruby) -> bool {
         .unwrap_or_else(|_| ruby.qnil().as_value());
     !scheduler.is_nil()
 }
-
-unsafe extern "C" fn ubf_cancel(data: *mut c_void) {
-    let cancel = &*(data as *const AtomicBool);
-    cancel.store(true, std::sync::atomic::Ordering::Relaxed);
-}
-
-unsafe extern "C" fn recv_without_gvl_cb(args: *mut c_void) -> *mut c_void {
-    let args = &mut *(args as *mut RecvArgs);
-    loop {
-        match args.receiver.try_recv() {
-            Ok(item) => {
-                args.result = Some(Ok(item));
-                return std::ptr::null_mut();
-            }
-            Err(crossbeam_channel::TryRecvError::Empty) => {
-                // Check the cancel flag relaxed already
-                if args.cancel.load(std::sync::atomic::Ordering::Relaxed) {
-                    args.result = None;
-                    return std::ptr::null_mut();
-                }
-
-                // Wait for timeout
-                match args
-                    .receiver
-                    .recv_timeout(std::time::Duration::from_millis(50))
-                {
-                    Ok(item) => {
-                        args.result = Some(Ok(item));
-                        return std::ptr::null_mut();
-                    }
-                    Err(crossbeam_channel::RecvTimeoutError::Timeout) => {
-                        // continue to check cancel
-                        continue;
-                    }
-                    Err(crossbeam_channel::RecvTimeoutError::Disconnected) => {
-                        args.result = Some(Err(crossbeam_channel::RecvError));
-                        return std::ptr::null_mut();
-                    }
-                }
-            }
-            Err(crossbeam_channel::TryRecvError::Disconnected) => {
-                args.result = Some(Err(crossbeam_channel::RecvError));
-                return std::ptr::null_mut();
-            }
-        }
-    }
+pub(crate) unsafe extern "C" fn recv_without_gvl_cb(args: *mut c_void) -> *mut c_void {
+    let args = &mut *(args as *mut crate::nonblocking_stream::RecvArgs);
+    args.result = recv_loop(&args.receiver, &args.cancel);
+    std::ptr::null_mut()
 }
-
 struct RecvArgs {
     receiver: Receiver<StreamItem>,
     result: Option<Result<StreamItem, crossbeam_channel::RecvError>>,