isorun 0.1.5.pre-x86_64-linux → 0.1.7-x86_64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 425cb5a36c48c15c8d7e05e336cefb0c12921a64ff52f1bec061270386d0bae8
-  data.tar.gz: 4847244f7463591220b11506e11120236ad3c81f3ab7ac2b4acab4fe82063d82
+  metadata.gz: 8a4aeda3a39740cabd5ed2a62ca53b3b9908d518990165ddbe1271c97cd09381
+  data.tar.gz: 1eb2373c0cc3b4287becc08c2b304d7ad9874856ec8ec14a8212be2f764a5dc0
 SHA512:
-  metadata.gz: 3642a8e54820ce5eca25721d5d22b4a78cf7d9df530006d5bb38c4651df26ba001375472568bb9ae49f0df543705e5c09f8f6124eb5eaf71432929ea5a3b0214
-  data.tar.gz: 476317987740b058717dcf5041e1c0aec793366403658d161e424612029257b5e50a1fb64fe07ddabfccddf3d8bb50f1bc5d93e99a3fa180b0275da466b10cb3
+  metadata.gz: b1425a976b568f920a1c90ad3b47b5007d4ef95a31a319ef9e8cc33fa4f9b27c3d2a76ae98a3d5f051943df62bfa0a3f91557e1fb5e7e0897b09b74d75369f91
+  data.tar.gz: 421de15c0adc18b0777021be608cac34895bd1ce5c46ba6a233dc45181afba134b98a3a2155002662f2d736b36f80fafb7eedf99419b49f22c5547a6259a25a6

data/app/helpers/isorun/app_helper.rb

@@ -3,7 +3,7 @@
 module Isorun
   module AppHelper
     def isorun_app(id) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
-      module_path = Isorun.configuration.module_resolver.call(id)
+      module_path = Isorun.config.module_resolver.call(id)
 
       ssr_html = Isorun::Context.create do |context|
         render_context = { environment: Rails.env.to_s }
@@ -14,11 +14,18 @@ module Isorun
                             "does not have a server entrypoint. Please " \
                             "check if an asset with filename " + "
                                `#{id}-server.js` exists.")
+          return ""
         end
 
-        Isorun.with_receiver(Isorun.configuration.receiver) do
-          render_function.call_without_gvl(render_context)
-        end
+        # set receiver to allow calling into Ruby from JavaScript
+        context.receiver = Isorun.config.receiver
+
+        html = render_function.call(render_context)
+
+        # reset receiver
+        context.receiver = nil
+
+        html
       end
 
       html = if ssr_html.present?

data/ext/isorun/Cargo.toml

@@ -1,26 +1,26 @@
 [package]
 name = "isorun"
-version = "0.1.5"
+version = "0.1.7"
 edition = "2021"
 authors = ["Hannes Moser <box@hannesmoser.at>"]
 homepage = "https://github.com/eliias/isorun"
 repository = "https://github.com/eliias/isorun"
 
 [dependencies]
-deno_console = "0.80.0"
-deno_core = "0.162.0"
-deno_fetch = "0.103.0"
-deno_runtime = "0.88.0"
-deno_url = "0.80.0"
-deno_web = "0.111.0"
-deno_webidl = "0.80.0"
+deno_console = "0.82.0"
+deno_core = "0.164.0"
+deno_fetch = "0.106.0"
+deno_runtime = "0.90.0"
+deno_url = "0.82.0"
+deno_web = "0.113.0"
+deno_webidl = "0.82.0"
 lazy_static = "1.4.0"
-magnus = { git = "https://github.com/eliias/magnus", rev = "1833ad96919b8891c1b5d62a22f0fc2b94f5961a" } # waiting for release with full rb-sys backend
+magnus = { git = "https://github.com/eliias/magnus", rev = "3289eeda7ea63831c0277b153666f1efab3866bb" }
 tokio = { version = "1.21.1", features = ["full"] }
-v8 = "0.58.0"
+v8 = "0.60.0"
 
 [dev-dependencies]
-magnus = { git = "https://github.com/eliias/magnus", rev = "1833ad96919b8891c1b5d62a22f0fc2b94f5961a", features = ["embed"] } # waiting for release with full rb-sys backend
+magnus = { git = "https://github.com/eliias/magnus", rev = "3289eeda7ea63831c0277b153666f1efab3866bb", features = ["embed"] }
 
 [lib]
 name = "isorun"

data/ext/isorun/src/isorun/context.rs

@@ -2,6 +2,7 @@ use crate::isorun;
 use crate::js::module::Module;
 use crate::js::worker::WORKER;
 use deno_core::JsRealm;
+use magnus::block::Proc;
 use magnus::Error;
 use std::cell::RefCell;
 use std::rc::Rc;
@@ -22,6 +23,10 @@ impl Context {
             })
     }
 
+    pub(crate) fn set_receiver(&self, receiver: Option<Proc>) {
+        WORKER.with(|worker| worker.ruby_receiver.replace(receiver));
+    }
+
     pub(crate) fn load(
         &self,
         path: String,

data/ext/isorun/src/isorun/function.rs

@@ -3,6 +3,7 @@ use crate::js::worker::WORKER;
 use magnus::Error;
 use std::cell::RefCell;
 use std::ops::Deref;
+use v8::{Global, Value};
 
 #[magnus::wrap(class = "Isorun::Function")]
 pub(crate) struct Function(pub(crate) RefCell<js::module_item::Function>);
@@ -15,46 +16,25 @@ impl Function {
         &self,
         args: &[magnus::Value],
     ) -> Result<magnus::Value, Error> {
-        let args = WORKER.with(|worker| {
+        WORKER.with(|worker| {
             let func = self.0.borrow();
             let realm = func.realm.borrow();
             let realm = realm.deref();
 
-            let mut v8_args = vec![];
-            for arg in args {
-                let v8_arg = worker.to_v8(realm, *arg).unwrap();
-                v8_args.push(v8_arg);
-            }
-            v8_args
-        });
+            let v8_args: Vec<Global<Value>> = args
+                .iter()
+                .map(|arg| worker.to_v8(realm, *arg).unwrap())
+                .collect();
 
-        self.0.borrow().call(args.as_slice()).map_err(|error| {
-            Error::runtime_error(format!("cannot call function: {}", error))
-        })
-    }
+            let result =
+                self.0.borrow().call(v8_args.as_slice()).map_err(|error| {
+                    Error::runtime_error(format!(
+                        "cannot call function: {}",
+                        error
+                    ))
+                });
 
-    pub(crate) fn call_without_gvl(
-        &self,
-        args: &[magnus::Value],
-    ) -> Result<magnus::Value, Error> {
-        let args = WORKER.with(|worker| {
-            let func = self.0.borrow();
-            let realm = func.realm.borrow();
-            let realm = realm.deref();
-
-            let mut v8_args = vec![];
-            for arg in args {
-                let v8_arg = worker.to_v8(realm, *arg).unwrap();
-                v8_args.push(v8_arg);
-            }
-            v8_args
-        });
-
-        self.0
-            .borrow()
-            .call_without_gvl(args.as_slice())
-            .map_err(|error| {
-                Error::runtime_error(format!("cannot call function: {}", error))
-            })
+            result
+        })
     }
 }

data/ext/isorun/src/isorun/mod.rs

@@ -1,4 +1,3 @@
-pub(crate) mod configure;
 pub(crate) mod context;
 pub(crate) mod function;
 pub(crate) mod module;

data/ext/isorun/src/isorun/utils.rs

@@ -5,12 +5,13 @@ use magnus::{
     Integer, RArray, RFloat, RHash, RString, RStruct, Symbol, Value, QFALSE,
     QNIL, QTRUE,
 };
-use v8::{Array, GetPropertyNamesArgs, HandleScope, Local, Object};
+use v8::{Array, GetPropertyNamesArgs, Global, HandleScope, Local, Object};
 
 pub fn convert_v8_to_ruby(
-    value: Local<v8::Value>,
+    value: &Global<v8::Value>,
     scope: &mut HandleScope,
 ) -> Result<Value, AnyError> {
+    let value = Local::new(scope, value);
     if value.is_null() {
         return Ok(Value::from(QNIL));
     }
@@ -36,8 +37,7 @@ pub fn convert_v8_to_ruby(
     }
 
     if value.is_string() {
-        let raw = value.to_rust_string_lossy(scope);
-        return Ok(Value::from(RString::from(raw)));
+        return Ok(Value::from(value.to_rust_string_lossy(scope)));
     }
 
     if value.is_array() {
@@ -46,7 +46,8 @@ pub fn convert_v8_to_ruby(
         let r_arr = RArray::with_capacity(length as usize);
         for i in 0..length {
             let raw = arr.get_index(scope, i).unwrap();
-            let val = convert_v8_to_ruby(raw, scope).unwrap();
+            let global_raw = Global::<v8::Value>::new(scope, raw);
+            let val = convert_v8_to_ruby(&global_raw, scope).unwrap();
             r_arr.push(val).expect("cannot add item to array");
         }
         return Ok(Value::from(r_arr));
@@ -61,9 +62,11 @@ pub fn convert_v8_to_ruby(
         let r_hash = RHash::new();
         for i in 0..length {
             let raw_key = properties.get_index(scope, i).unwrap();
+            let global_raw_key = Global::<v8::Value>::new(scope, raw_key);
             let raw_val = obj.get(scope, raw_key).unwrap();
-            let key = convert_v8_to_ruby(raw_key, scope).unwrap();
-            let val = convert_v8_to_ruby(raw_val, scope).unwrap();
+            let global_raw_val = Global::<v8::Value>::new(scope, raw_val);
+            let key = convert_v8_to_ruby(&global_raw_key, scope).unwrap();
+            let val = convert_v8_to_ruby(&global_raw_val, scope).unwrap();
             r_hash.aset(key, val).expect("cannot set item to hash");
         }
         return Ok(Value::from(r_hash));

data/ext/isorun/src/js/module_item.rs

@@ -1,6 +1,5 @@
 use crate::js::worker::WORKER;
 use deno_core::JsRealm;
-use magnus::gvl::without_gvl;
 use std::cell::RefCell;
 use std::ops::Deref;
 use std::rc::Rc;
@@ -31,30 +30,6 @@ impl Function {
                 .block_on(worker.call(realm, &self.binding, args))
         })
     }
-
-    pub(crate) fn call_without_gvl(
-        &self,
-        args: &[Global<v8::Value>],
-    ) -> Result<magnus::Value, magnus::Error> {
-        WORKER.with(|worker| {
-            let realm = self.realm.borrow();
-            let realm = realm.deref();
-            let result = without_gvl(
-                |gvl_context| {
-                    worker.ruby_context.replace(Some(gvl_context));
-                    let result = worker
-                        .runtime
-                        // we block here instead of the worker, due to a refcell issue
-                        // when borrowing within an await
-                        .block_on(worker.call(realm, &self.binding, args));
-                    worker.ruby_context.replace(None);
-                    result
-                },
-                None::<fn()>,
-            );
-            result.0.unwrap()
-        })
-    }
 }
 
 pub(crate) struct Value {

data/ext/isorun/src/js/worker.rs

@@ -8,7 +8,7 @@ use deno_runtime::worker::{MainWorker, WorkerOptions};
 use deno_runtime::BootstrapOptions;
 use deno_web::BlobStore;
 use magnus::block::Proc;
-use magnus::gvl::GVLContext;
+use magnus::gvl::{without_gvl, GVLContext};
 use magnus::{Error, Value};
 use std::borrow::BorrowMut;
 use std::cell::RefCell;
@@ -19,7 +19,7 @@ use std::rc::Rc;
 use std::string::ToString;
 use std::sync::Arc;
 use tokio::runtime::Runtime;
-use v8::{Global, Local};
+use v8::{Global, HandleScope, Local};
 
 fn get_error_class_name(e: &AnyError) -> &'static str {
     deno_runtime::errors::get_error_class_name(e).unwrap_or("Error")
@@ -84,9 +84,23 @@ impl Worker {
                 local_args.push(local_arg);
             }
             let receiver = v8::undefined(scope.borrow_mut());
-            let promise = callee
-                .call(&mut scope, receiver.into(), local_args.as_slice())
-                .unwrap();
+            let (promise, _cancel) = without_gvl(
+                |ctx| {
+                    self.ruby_context.replace(Some(ctx));
+                    let result = callee
+                        .call(
+                            &mut scope,
+                            receiver.into(),
+                            local_args.as_slice(),
+                        )
+                        .unwrap();
+                    self.ruby_context.replace(None);
+                    result
+                },
+                None::<fn()>,
+            );
+
+            let promise = promise.unwrap();
             Global::<v8::Value>::new(&mut scope, promise)
         };
 
@@ -107,7 +121,6 @@ impl Worker {
     ) -> Option<Value> {
         let mut worker = self.worker.borrow_mut();
         let mut scope = realm.handle_scope(worker.js_runtime.v8_isolate());
-        let value = Local::new(&mut scope, value);
         let result = convert_v8_to_ruby(value, &mut scope);
 
         match result {
@@ -129,20 +142,57 @@ impl Worker {
         Some(value)
     }
 
-    fn send(&self, value: Value) -> Result<Value, Error> {
-        // we need to deref the receiver as mut, as it is behind an Option
-        if let (Some(ctx), Some(rec)) = (
+    fn send<'a>(
+        &self,
+        scope: &mut HandleScope,
+        value: serde_v8::Value<'a>,
+    ) -> Result<serde_v8::Value<'a>, AnyError> {
+        if let None = self.ruby_receiver.borrow_mut().as_mut() {
+            return Err(AnyError::msg(
+                "Cannot send to ruby. The ruby receiver is missing, please \
+                initialize and set one before calling into Ruby?",
+            ));
+        }
+
+        // we can send with and without gvl, if no ruby context is present, we
+        // assume that GVL is held
+        if let (None, Some(rec)) = (
             self.ruby_context.borrow_mut().as_mut(),
             self.ruby_receiver.borrow_mut().as_mut(),
         ) {
+            let mut scope = scope; // fixme: can't figure out how to forward the borrow
+            let value = value.v8_value;
+            let value = Global::<v8::Value>::new(&mut scope, value);
+            let value = convert_v8_to_ruby(&value, &mut scope).unwrap();
+            let args: (Value,) = (value,);
+            return rec
+                .call::<(Value,), Value>(args)
+                .map_err(|err| AnyError::msg(format!("{:?}", err)))
+                .and_then(|value| convert_ruby_to_v8(value, &mut scope))
+                .map(|value| from_v8(&mut scope, value).unwrap());
+        }
+
+        // we need to deref the receiver as mut, as it is behind an Option
+        // TODO: make sure all operations on Ruby data happen when GVL is held
+        if let Some(ctx) = self.ruby_context.borrow_mut().as_mut() {
+            let mut scope = scope; // fixme: can't figure out how to forward the borrow
             ctx.with_gvl(|| {
-                let args: (Value,) = (value,);
-                rec.call::<(Value,), Value>(args)
-            })?
+                if let Some(rec) = self.ruby_receiver.borrow_mut().as_mut() {
+                    let value = value.v8_value;
+                    let value = Global::<v8::Value>::new(&mut scope, value);
+                    let value = convert_v8_to_ruby(&value, &mut scope)?;
+                    let args: (Value,) = (value,);
+                    rec.call::<(Value,), Value>(args)
+                        .map_err(|err| AnyError::msg(format!("{:?}", err)))
+                } else {
+                    Err(AnyError::msg("cannot access ruby receiver"))
+                }
+            })
+            .map_err(|err| AnyError::msg(format!("{:?}", err)))?
+            .and_then(|value| convert_ruby_to_v8(value, &mut scope))
+            .map(|value| from_v8(&mut scope, value).unwrap())
         } else {
-            Err(Error::runtime_error(
-                "Cannot send to ruby. Is the ruby receiver and context initialized and set?",
-            ))
+            Err(AnyError::msg("this should never happen"))
         }
     }
 }
@@ -200,19 +250,13 @@ impl Default for Worker {
             shared_array_buffer_store: None,
             compiled_wasm_module_store: None,
             stdio: Default::default(),
+            should_wait_for_inspector_session: false,
         };
 
         // todo: we don't use the main module at all, but it could be used as an
         //  entry point for "eval" JavaScript.
-        let default_path = Path::new(env!("CARGO_MANIFEST_DIR"))
-            .join("../..")
-            .canonicalize()
-            .unwrap()
-            .into_os_string()
-            .into_string()
-            .unwrap();
         let isorun_native_gem_path =
-            env::var("ISORUN_NATIVE_GEM_PATH").unwrap_or(default_path.clone());
+            env::var("ISORUN_NATIVE_GEM_PATH").unwrap();
         let js_path = Path::new(isorun_native_gem_path.as_str())
             .join("ext/isorun/src/call.js");
 
@@ -261,17 +305,5 @@ fn op_send_to_ruby<'a>(
     scope: &mut v8::HandleScope,
     data: serde_v8::Value<'a>,
 ) -> Result<serde_v8::Value<'a>, AnyError> {
-    let value = convert_v8_to_ruby(data.v8_value, scope)?;
-
-    WORKER.with(|worker| {
-        worker
-            .send(value)
-            .map(|v| {
-                let v = convert_ruby_to_v8(v, scope).unwrap();
-                from_v8(scope, v).unwrap()
-            })
-            .map_err(|error| {
-                AnyError::msg(format!("failed to send to ruby: {}", error))
-            })
-    })
+    WORKER.with(|worker| worker.send(scope, data))
 }

data/ext/isorun/src/lib.rs

@@ -1,5 +1,4 @@
 use crate::isorun::context::Context;
-use isorun::configure::set_receiver;
 use isorun::function::Function;
 use isorun::module::Module;
 use magnus::{define_module, function, method, Error, Module as M, Object};
@@ -11,9 +10,6 @@ mod js;
 fn init() -> Result<(), Error> {
     let root = define_module("Isorun").expect("cannot define module: Isorun");
 
-    root.define_module_function("receiver=", function!(set_receiver, 1))
-        .expect("cannot define module function: receiver=");
-
     let context = root
         .define_class("Context", Default::default())
         .expect("cannot define class: Isorun::Context");
@@ -22,7 +18,10 @@ fn init() -> Result<(), Error> {
         .expect("cannot define singelton method: new");
     context
         .define_method("load", method!(Context::load, 1))
-        .expect("cannot load module");
+        .expect("cannot define method: load");
+    context
+        .define_method("receiver=", method!(Context::set_receiver, 1))
+        .expect("cannot define method: receiver=");
 
     let module = root
         .define_class("Module", Default::default())
@@ -40,12 +39,6 @@ fn init() -> Result<(), Error> {
     function
         .define_method("call", method!(Function::call, -1))
         .expect("cannot define method: call");
-    function
-        .define_method(
-            "call_without_gvl",
-            method!(Function::call_without_gvl, -1),
-        )
-        .expect("cannot define method: call_without_gvl");
 
     Ok(())
 }

data/lib/isorun/context.rb

@@ -76,9 +76,9 @@ module Isorun
       export_names = [:default.to_s] if export_names.empty?
       Import.new(self, export_names)
     end
-  end
 
-  # @!method receiver=(receiver)
-  # @param receiver [Proc]
-  # @return [Isorun::Context] the newly created context
+    # @!method receiver=(receiver)
+    # @param receiver [Proc, nil]
+    # @return [Isorun::Context] the newly created context
+  end
 end

data/lib/isorun/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Isorun
-  VERSION = "0.1.5.pre"
+  VERSION = "0.1.7"
 end

data/lib/isorun.rb

@@ -6,7 +6,7 @@ ENV["ISORUN_NATIVE_GEM_PATH"] = File.expand_path("..", __dir__)
 
 # load native extension
 begin
-  ruby_version = /(\d+\.\d+)/.match(::RUBY_VERSION)
+  ruby_version = /(\d+\.\d+)/.match(RUBY_VERSION)
   require "isorun/#{ruby_version}/isorun"
 rescue LoadError
   require "isorun/isorun"
@@ -23,11 +23,4 @@ module Isorun
   extend ActiveSupport::Autoload
 
   class Error < StandardError; end
-
-  def self.with_receiver(receiver)
-    self.receiver = receiver
-    result = yield
-    self.receiver = nil
-    result
-  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: isorun
 version: !ruby/object:Gem::Version
-  version: 0.1.5.pre
+  version: 0.1.7
 platform: x86_64-linux
 authors:
 - Hannes Moser
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-12-10 00:00:00.000000000 Z
+date: 2022-12-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: railties
@@ -112,7 +112,6 @@ files:
 - ext/isorun/Cargo.toml
 - ext/isorun/extconf.rb
 - ext/isorun/src/call.js
-- ext/isorun/src/isorun/configure.rs
 - ext/isorun/src/isorun/context.rs
 - ext/isorun/src/isorun/function.rs
 - ext/isorun/src/isorun/mod.rs
@@ -161,9 +160,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 3.2.dev
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubygems_version: 3.3.22
 signing_key:

data/ext/isorun/src/isorun/configure.rs

@@ -1,9 +0,0 @@
-use crate::js::worker::WORKER;
-use magnus::block::Proc;
-
-pub(crate) fn set_receiver(receiver: Option<Proc>) {
-    WORKER.with(|worker| match receiver {
-        None => worker.ruby_receiver.replace(None),
-        Some(r) => worker.ruby_receiver.replace(Some(r)),
-    });
-}