rubyx-py 0.1.0 → 0.2.0

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;
@@ -155,7 +156,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 +2970,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 +3014,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 +3042,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 +3214,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 +3244,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 +3272,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 +3464,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 +3499,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 +3535,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 +3587,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 +3632,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 +3676,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>>,

data/ext/rubyx/src/rubyx_object.rs

@@ -91,6 +91,14 @@ pub(crate) fn python_to_sendable(
     if py_val == api.py_false {
         return Ok(SendableValue::Bool(false));
     }
+    let has_dict = {
+        let name = std::ffi::CString::new("__dict__").unwrap();
+        api.object_has_attr_string(py_val, name.as_ptr()) != 0
+    };
+    if api.callable_check(py_val) == 0 && has_dict {
+        api.incref(py_val);
+        return Ok(SendableValue::PyObjectRef(py_val as usize));
+    }
     Err("Cannot convert Python value to Ruby".to_string())
 }
 pub(crate) fn ruby_to_python(
@@ -1183,13 +1191,13 @@ mod tests {
 
     #[test]
     #[serial]
-    fn test_to_ruby_errors_for_module() {
+    fn test_to_ruby_wraps_module_as_rubyx_object() {
         with_ruby_python(|_ruby, api| {
             let module = api.import_module("os").expect("os should import");
             let wrapper = RubyxObject::new(module, api).unwrap();
             assert!(
-                wrapper.to_ruby().is_err(),
-                "module should not convert to Ruby"
+                wrapper.to_ruby().is_ok(),
+                "module should convert to RubyxObject via PyObjectRef"
             );
             drop(wrapper);
             api.decref(module);
@@ -1928,4 +1936,84 @@ mod tests {
         drop(w);
         api.decref(os);
     }
+
+    // ========== python_to_sendable: PyObjectRef fallback ==========
+
+    #[test]
+    #[serial]
+    fn test_python_to_sendable_module_returns_py_object_ref() {
+        use crate::test_helpers::skip_if_no_python;
+        let Some(guard) = skip_if_no_python() else {
+            return;
+        };
+        let api = guard.api();
+        let os = api.import_module("os").expect("os should import");
+        let sendable = python_to_sendable(os, api).unwrap();
+        match &sendable {
+            SendableValue::PyObjectRef(addr) => {
+                assert_eq!(*addr, os as usize);
+            }
+            other => panic!("expected PyObjectRef, got {other:?}"),
+        }
+        // Clean up: decref once for the sendable's incref, once for import_module
+        api.decref(os);
+        api.decref(os);
+    }
+
+    #[test]
+    #[serial]
+    fn test_python_to_sendable_set_returns_err() {
+        use crate::test_helpers::skip_if_no_python;
+        let Some(guard) = skip_if_no_python() else {
+            return;
+        };
+        let api = guard.api();
+        // Sets don't have __dict__, so they return Err (not PyObjectRef)
+        let globals = api.dict_new();
+        let builtins = api
+            .import_module("builtins")
+            .expect("builtins should import");
+        let key = api.string_from_str("__builtins__");
+        api.dict_set_item(globals, key, builtins);
+        api.decref(key);
+        let result = api.run_string("{1, 2, 3}", 258, globals, globals);
+        let py_set = result.expect("set eval should succeed");
+        assert!(!py_set.is_null());
+
+        let sendable = python_to_sendable(py_set, api);
+        assert!(sendable.is_err(), "set should return Err (no __dict__)");
+        api.decref(py_set);
+        api.decref(builtins);
+        api.decref(globals);
+    }
+
+    #[test]
+    #[serial]
+    fn test_python_to_sendable_primitives_not_py_object_ref() {
+        use crate::test_helpers::skip_if_no_python;
+        let Some(guard) = skip_if_no_python() else {
+            return;
+        };
+        let api = guard.api();
+
+        // int → Integer, not PyObjectRef
+        let py_int = api.long_from_i64(42);
+        assert!(matches!(
+            python_to_sendable(py_int, api),
+            Ok(SendableValue::Integer(42))
+        ));
+
+        // str → Str, not PyObjectRef
+        let py_str = api.string_from_str("hello");
+        assert!(matches!(
+            python_to_sendable(py_str, api),
+            Ok(SendableValue::Str(_))
+        ));
+
+        // None → Nil, not PyObjectRef
+        assert!(matches!(
+            python_to_sendable(api.py_none, api),
+            Ok(SendableValue::Nil)
+        ));
+    }
 }

data/ext/rubyx/src/stream.rs

@@ -1,7 +1,7 @@
 use crate::api;
 use crate::python_ffi::PyObject;
 use crate::ruby_helpers::runtime_error;
-use crate::rubyx_object::python_to_sendable;
+use crate::rubyx_object::{python_to_sendable, RubyxObject};
 use crossbeam_channel::{bounded, unbounded, Receiver, Sender};
 use magnus::value::ReprValue;
 use magnus::{IntoValue, Value};
@@ -23,6 +23,7 @@ pub(crate) enum SendableValue {
     Bool(bool),
     List(Vec<SendableValue>),
     Dict(Vec<(SendableValue, SendableValue)>),
+    PyObjectRef(usize),
 }
 impl TryInto<magnus::Value> for SendableValue {
     type Error = magnus::Error;
@@ -54,6 +55,19 @@ impl TryInto<magnus::Value> for SendableValue {
                 }
                 hash.as_value()
             }
+            SendableValue::PyObjectRef(addr) => {
+                let py_obj = addr as *mut PyObject;
+                let api = crate::API.get().ok_or_else(|| {
+                    magnus::Error::new(runtime_error(), "Python API not initialized")
+                })?;
+                // RubyxObject::new increfs internally and python_to_sendable also incref
+                let wrapper = RubyxObject::new(py_obj, api).ok_or_else(|| {
+                    magnus::Error::new(runtime_error(), "Failed to wrap Python object")
+                })?;
+                // Balance the extra incref from python_to_sendable
+                api.decref(py_obj);
+                wrapper.into_value_with(&ruby)
+            }
         };
         Ok(result)
     }
@@ -710,4 +724,66 @@ mod tests {
             assert_eq!(sum, (0..1000i64).sum::<i64>());
         });
     }
+
+    // ========== PyObjectRef: SendableValue → RubyxObject ==========
+
+    #[test]
+    #[serial]
+    fn test_py_object_ref_converts_to_rubyx_object() {
+        with_ruby_python(|_ruby, api| {
+            let os = api.import_module("os").expect("os should import");
+            api.incref(os); // incref for PyObjectRef (simulates what python_to_sendable does)
+            let sendable = SendableValue::PyObjectRef(os as usize);
+
+            let val: Value = sendable.try_into().expect("PyObjectRef should convert");
+            // The result should be a RubyxObject, not a primitive
+            assert!(!val.is_nil());
+            // Verify it's not a primitive type
+            assert!(i64::try_convert(val).is_err(), "should not be an Integer");
+            assert!(String::try_convert(val).is_err(), "should not be a String");
+
+            api.decref(os); // balance the import_module refcount
+        });
+    }
+
+    #[test]
+    #[serial]
+    fn test_py_object_ref_in_stream() {
+        with_ruby_python(|_ruby, api| {
+            let os = api.import_module("os").expect("os should import");
+            api.incref(os);
+
+            let (tx, rx) = unbounded();
+            let (cancel_tx, _cancel_rx) = bounded(1);
+            let addr = os as usize;
+
+            thread::spawn(move || {
+                tx.send(Some(SendableValue::Integer(1))).ok();
+                tx.send(Some(SendableValue::PyObjectRef(addr))).ok();
+                tx.send(Some(SendableValue::Str("after".to_string()))).ok();
+                tx.send(None).ok();
+            });
+
+            let mut stream = AsyncStream::from_channel(rx, cancel_tx);
+
+            // First: integer
+            let val = stream.next().unwrap().unwrap();
+            assert_eq!(i64::try_convert(val).unwrap(), 1);
+
+            // Second: PyObjectRef → RubyxObject
+            let val = stream.next().unwrap().unwrap();
+            assert!(!val.is_nil());
+            assert!(
+                i64::try_convert(val).is_err(),
+                "should be RubyxObject, not Integer"
+            );
+
+            // Third: string
+            let val = stream.next().unwrap().unwrap();
+            assert_eq!(String::try_convert(val).unwrap(), "after");
+
+            assert!(stream.next().is_none());
+            api.decref(os);
+        });
+    }
 }

data/lib/generators/rubyx/templates/example.py

@@ -0,0 +1,5 @@
+"""Example Python module. Import with: Rubyx.import('example')"""
+
+
+def hello(name="World"):
+    return f"Hello, {name}! From Python."

data/lib/generators/rubyx/templates/pyproject.toml

@@ -0,0 +1,5 @@
+[project]
+name = "my-rails-app"
+version = "0.1.0"
+requires-python = ">=3.12"
+dependencies = []

data/lib/rubyx/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module Rubyx
-  VERSION = "0.1.0".freeze
+  VERSION = "0.2.0".freeze
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubyx-py
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Naiker
@@ -62,6 +62,7 @@ extra_rdoc_files: []
 files:
 - Cargo.toml
 - README.md
+- docs/assets/logo.png
 - ext/rubyx/Cargo.toml
 - ext/rubyx/extconf.rb
 - ext/rubyx/src/async_gen.rs
@@ -70,6 +71,7 @@ files:
 - ext/rubyx/src/eval.rs
 - ext/rubyx/src/exception.rs
 - ext/rubyx/src/future.rs
+- ext/rubyx/src/gvl.rs
 - ext/rubyx/src/import.rs
 - ext/rubyx/src/lib.rs
 - ext/rubyx/src/nonblocking_stream.rs
@@ -85,6 +87,8 @@ files:
 - ext/rubyx/src/stream.rs
 - ext/rubyx/src/test_helpers.rs
 - lib/generators/rubyx/install_generator.rb
+- lib/generators/rubyx/templates/example.py
+- lib/generators/rubyx/templates/pyproject.toml
 - lib/generators/rubyx/templates/rubyx_initializer.rb
 - lib/rubyx-py.rb
 - lib/rubyx.rb