src/runtimes/ruby.rs

@@ -1,3 +1,4 @@
+// TODO: use funcall_public?
 use std::{
     collections::HashMap,
     ffi::CString,
@@ -5,7 +6,8 @@ use std::{
     thread::{self, JoinHandle},
 };
 
-use ::magnus::{typed_data::Inspect, value::Opaque};
+use ::magnus::{error::IntoError, typed_data::Inspect, value::Opaque};
+use anyhow::anyhow;
 use bevy::{
     asset::Asset,
     ecs::{component::Component, entity::Entity, resource::Resource, schedule::ScheduleLabel},
@@ -19,7 +21,7 @@ use magnus::{
     value::{Lazy, ReprValue},
 };
 use magnus::{method, prelude::*};
-use rb_sys::{VALUE, ruby_init_stack};
+use rb_sys::{VALUE, rb_backtrace, rb_make_backtrace, ruby_init_stack};
 use serde::Deserialize;
 
 use crate::{
@@ -222,15 +224,17 @@ impl TryConvert for BevyVec3 {
 
 impl From<magnus::Error> for ScriptingError {
     fn from(value: magnus::Error) -> Self {
+        // TODO: DRY
         ScriptingError::RuntimeError(
             value.inspect(),
             value
                 .value()
-                .expect("No error value")
+                .unwrap()
-                .funcall::<_, _, magnus::RArray>("backtrace", ())
+                .funcall::<_, _, magnus::RArray>("backtrace", ()) // TODO: is there an API for this
-                .expect("Failed to get backtrace")
+                // somehwere
+                .unwrap()
                 .to_vec::<String>()
-                .expect("Failed to convert backtrace to vec of strings")
+                .unwrap()
                 .join("\n"),
         )
     }
@@ -324,25 +328,6 @@ impl RubyRuntime {
             .expect("No Ruby thread")
             .execute(Box::new(move |mut ruby| f(&mut ruby)))
     }
-
-    fn with_current_entity<T>(ruby: &Ruby, entity: Entity, f: impl FnOnce() -> T) -> T {
-        let var = ruby
-            .class_object()
-            .const_get::<_, RModule>("Bevy")
-            .expect("Failed to get Bevy module")
-            .const_get::<_, RClass>("Entity")
-            .expect("Failed to get Entity class");
-
-        var.ivar_set("_current", BevyEntity(entity))
-            .expect("Failed to set current entity handle");
-
-        let result = f();
-
-        var.ivar_set("_current", ruby.qnil().as_value())
-            .expect("Failed to unset current entity handle");
-
-        result
-    }
 }
 
 impl Runtime for RubyRuntime {
@@ -391,10 +376,33 @@ impl Runtime for RubyRuntime {
     ) -> Result<Self::ScriptData, crate::ScriptingError> {
         let script = script.0.clone();
         self.execute_in_thread(Box::new(move |ruby: &Ruby| {
-            Self::with_current_entity(ruby, entity, || {
+            // TODO: refactor
-                ruby.eval::<magnus::value::Value>(&script)
+            let var = ruby
-                    .map_err(|e| <magnus::Error as Into<ScriptingError>>::into(e))
+                .class_object()
+                .const_get::<_, RModule>("Bevy")
+                .expect("Failed to get Bevy module")
+                .const_get::<_, RClass>("Entity")
+                .expect("Failed to get Entity class");
+
+            var.ivar_set("_current", BevyEntity(entity))
+                .expect("Failed to set current entity handle");
+
+            ruby.eval::<magnus::value::Value>(&script).map_err(|e| {
+                ScriptingError::RuntimeError(
+                    e.inspect(),
+                    e.value()
+                        .unwrap()
+                        .funcall::<_, _, magnus::RArray>("backtrace", ())
+                        .unwrap()
+                        .to_vec::<String>()
+                        .unwrap()
+                        .join("\n"),
+                )
             })?;
+
+            var.ivar_set("_current", ruby.qnil().as_value())
+                .expect("Failed to unset current entity handle");
+
             Ok::<Self::ScriptData, ScriptingError>(RubyScriptData)
         }))
     }
@@ -431,19 +439,11 @@ impl Runtime for RubyRuntime {
         fn callback(args: &[magnus::Value]) -> magnus::Value {
             let ruby = magnus::Ruby::get()
                 .expect("Failed to get a handle to Ruby API while processing callback");
-            let method_name: magnus::value::StaticSymbol = ruby
+            let method_name: magnus::value::StaticSymbol =
-                .class_object()
+                ruby.class_object().funcall("__method__", ()).unwrap();
-                .funcall("__method__", ())
+            let method_name = method_name.name().unwrap();
-                .expect("Failed to get currently called method name symbol from Ruby");
+            let callbacks = RUBY_CALLBACKS.lock().unwrap();
-            let method_name = method_name
+            let f = callbacks.get(method_name).unwrap();
-                .name()
-                .expect("Failed to convert method symbol to string");
-            let callbacks = RUBY_CALLBACKS
-                .lock()
-                .expect("Failed to lock callbacks when executing a script callback");
-            let f = callbacks
-                .get(method_name)
-                .expect("No callback found to execute with specified name");
             let result = f(
                 (),
                 args.iter()
@@ -471,15 +471,23 @@ impl Runtime for RubyRuntime {
     ) -> Result<Self::Value, crate::ScriptingError> {
         let name = name.to_string();
         self.execute_in_thread(Box::new(move |ruby: &Ruby| {
-            let return_value = Self::with_current_entity(ruby, entity, || {
+            // TOOD: refactor
+            let var = ruby
+                .class_object()
+                .const_get::<_, RModule>("Bevy")
+                .unwrap()
+                .const_get::<_, RClass>("Entity")
+                .unwrap();
+            var.ivar_set("_current", BevyEntity(entity)).unwrap();
+
             let args: Vec<_> = args
                 .parse(ruby)
                 .into_iter()
                 .map(|a| ruby.get_inner(a.0))
                 .collect();
+            let return_value: magnus::Value = ruby.class_object().funcall(name, args.as_slice())?;
 
-                ruby.class_object().funcall(name, args.as_slice())
+            var.ivar_set("_current", ruby.qnil().as_value()).unwrap();
-            })?;
 
             Ok(RubyValue::new(return_value))
         }))
@@ -493,8 +501,11 @@ impl Runtime for RubyRuntime {
     ) -> Result<Self::Value, crate::ScriptingError> {
         let value = value.clone();
 
-        self.execute_in_thread(move |ruby| {
+        self.ruby_thread
-            let f: Proc = TryConvert::try_convert(ruby.get_inner(value.0))?;
+            .as_ref()
+            .unwrap()
+            .execute(Box::new(move |ruby| {
+                let f: Proc = TryConvert::try_convert(ruby.get_inner(value.0)).unwrap();
 
                 let args: Vec<_> = args
                     .into_iter()
@@ -502,7 +513,7 @@ impl Runtime for RubyRuntime {
                     .collect();
                 let result: magnus::Value = f.funcall("call", args.as_slice())?;
                 Ok(RubyValue::new(result))
-        })
+            }))
     }
 
     fn needs_own_thread() -> bool {
@@ -521,7 +532,7 @@ pub mod prelude {
 impl<T: TryConvert> FromRuntimeValueWithEngine<'_, RubyRuntime> for T {
     fn from_runtime_value_with_engine(value: RubyValue, engine: &magnus::Ruby) -> Self {
         let inner = engine.get_inner(value.0);
-        T::try_convert(inner).expect("Failed to convert from Ruby value to native type")
+        T::try_convert(inner).unwrap()
     }
 }
 
@@ -550,8 +561,7 @@ pub struct RArray(pub Opaque<magnus::RArray>);
 impl FromRuntimeValueWithEngine<'_, RubyRuntime> for RArray {
     fn from_runtime_value_with_engine(value: RubyValue, engine: &magnus::Ruby) -> Self {
         let inner = engine.get_inner(value.0);
-        let array =
+        let array = magnus::RArray::try_convert(inner).unwrap();
-            magnus::RArray::try_convert(inner).expect("Failed to convert Ruby value to RArray");
         RArray(Opaque::from(array))
     }
 }