RubyGems - isorun - Versions diffs - 0.1.6.pre-arm64-darwin → 0.1.8-arm64-darwin - Mend

isorun 0.1.6.pre-arm64-darwin → 0.1.8-arm64-darwin

Files changed (21) hide show

checksums.yaml +4 -4
data/Rakefile +2 -2
data/app/helpers/isorun/app_helper.rb +26 -5
data/ext/isorun/Cargo.toml +11 -11
data/ext/isorun/src/isorun/context.rs +18 -7
data/ext/isorun/src/isorun/function.rs +16 -36
data/ext/isorun/src/isorun/mod.rs +0 -1
data/ext/isorun/src/isorun/module.rs +5 -4
data/ext/isorun/src/isorun/utils.rs +76 -7
data/ext/isorun/src/js/module_item.rs +0 -25
data/ext/isorun/src/js/worker.rs +68 -28
data/ext/isorun/src/lib.rs +14 -10
data/lib/isorun/2.7/isorun.bundle +0 -0
data/lib/isorun/3.0/isorun.bundle +0 -0
data/lib/isorun/3.1/isorun.bundle +0 -0
data/lib/isorun/context.rb +53 -9
data/lib/isorun/engine.rb +0 -1
data/lib/isorun/version.rb +1 -1
data/lib/isorun.rb +1 -8
metadata +53 -9
data/ext/isorun/src/isorun/configure.rs +0 -9

checksums.yaml CHANGED Viewed

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 728e85ec14783a4e1df04bdfde425e5edd0dcda0ed888b5c9cb63846dcf54db5
-  data.tar.gz: 236a0956a5654d4e8a2dd5f6d5b3ff34db693b5c23ec024c69663750150e31b7
+  metadata.gz: 5e4f40ff0a6d24261a8215275f3a8c28ef2b766ee8abe799229425b0b71ad818
+  data.tar.gz: 0550710d7f5d27aa8023167915ee6b8411d0c4f211ba56c98ef796ad0146255c
 SHA512:
-  metadata.gz: 7e0f4e9f0e58480210c3972d7bd46ae5199ca9c7b90caf5e9c7624540c3dff738cc0cb017b3aa05b33e17891784bfb1b93b4e84a78353480baf9389b7e180c26
-  data.tar.gz: dfb127e45f6bc304397bfc41f354ad403885e65b895fb157b236db0d16f5955d1e773008c4b5af9e434ee86110c495c13b514aa733fee10b5c81f925d90a4ece
+  metadata.gz: d0ff8d20ef234c6fdc4cccf3b402003388963003352668d5c4bd3cd651311d4b27758775cb9b0dab626a70dc0612dac7a9aff4139d54a03e42b253e90f0328bc
+  data.tar.gz: 28c1c8ec314f1cd8beeffbbd3f1e2dc5fbbacdcfcb64c792e0194d502e762b3ef04bd0fec0aa08270d1ab11269b37d26eceb4974fe95c90554a547062f909977

data/Rakefile CHANGED Viewed

@@ -6,7 +6,7 @@ require "rake/testtask"
 require "rake/extensiontask"
 require "rb_sys"
-cross_rubies = %w[3.1.0 3.0.0 2.7.0]
+cross_rubies = %w[3.2.0 3.1.0 3.0.0 2.7.0]
 cross_platforms = %w[
   arm64-darwin
   x86_64-darwin
@@ -72,7 +72,7 @@ begin
   YARD::Rake::YardocTask.new
-  task docs: :environment do
+  task :docs do
     `yard server --reload`
   end
 rescue LoadError

data/app/helpers/isorun/app_helper.rb CHANGED Viewed

@@ -2,10 +2,27 @@
 module Isorun
   module AppHelper
+    # The isorun_app helper is the most convenient way to server-side render
+    # a JavaScript application, including state extraction and automatic
+    # rehydration. The helper tries to render the application and will also
+    # inject the client-side code immediately after the rendered result.
+    #
+    # @example Renders a JavaScript application
+    #   <html>
+    #   <body>
+    #     <%= isorun_app("my_app") %>
+    #   </body>
+    #   </html>
+    #
+    # @param id [String] An ID representing both, the asset bundle, and by
+    #   convention, the target node (e.g. `<div id="my_app">`)
+    # @return [String]
     def isorun_app(id) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
-      module_path = Isorun.configuration.module_resolver.call(id)
+      ActiveSupport::Notifications.instrument "start.render.isorun", { ts: Time.current }
-      ssr_html = Isorun::Context.create do |context|
+      module_path = Isorun.config.module_resolver.call(id)
+      ssr_html = Isorun::Context.create(receiver: Isorun.config.receiver) do |context|
         render_context = { environment: Rails.env.to_s }
         render_function = context.import.from(module_path)
@@ -14,11 +31,15 @@ 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
+        html = render_function.call(render_context)
+        ActiveSupport::Notifications.instrument "finish.render.isorun", { ts: Time.current }
+        ActiveSupport::Notifications.instrument "stats.isorun", Isorun.stats
+        html
       end
       html = if ssr_html.present?

data/ext/isorun/Cargo.toml CHANGED Viewed

@@ -1,26 +1,26 @@
 [package]
 name = "isorun"
-version = "0.1.6"
+version = "0.1.8"
 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.83.0"
+deno_core = "0.165.0"
+deno_fetch = "0.107.0"
+deno_runtime = "0.91.0"
+deno_url = "0.83.0"
+deno_web = "0.114.0"
+deno_webidl = "0.83.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 = "5220756ca0ab4f2bc32d38310c26f7dda2be9bd6" }
 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 = "5220756ca0ab4f2bc32d38310c26f7dda2be9bd6", features = ["embed"] }
 [lib]
 name = "isorun"

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

@@ -2,7 +2,8 @@ use crate::isorun;
 use crate::js::module::Module;
 use crate::js::worker::WORKER;
 use deno_core::JsRealm;
-use magnus::Error;
+use magnus::block::Proc;
+use magnus::{exception, Error};
 use std::cell::RefCell;
 use std::rc::Rc;
@@ -18,10 +19,17 @@ impl Context {
             .with(|worker| worker.create_realm())
             .map(|realm| Context(Rc::new(RefCell::from(realm))))
             .map_err(|_error| {
-                Error::runtime_error("cannot create JavaScript context")
+                Error::new(
+                    exception::runtime_error(),
+                    "cannot create JavaScript 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,
@@ -36,11 +44,14 @@ impl Context {
             })
             .map(|module| isorun::Module(RefCell::from(module)))
             .map_err(|error| {
-                Error::runtime_error(format!(
-                    "cannot load module: `{}`: {}",
-                    path.as_str(),
-                    error
-                ))
+                Error::new(
+                    exception::runtime_error(),
+                    format!(
+                        "cannot load module: `{}`: {}",
+                        path.as_str(),
+                        error
+                    ),
+                )
             })
     }
 }

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

@@ -1,8 +1,9 @@
 use crate::js;
 use crate::js::worker::WORKER;
-use magnus::Error;
+use magnus::{exception, 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::new(
+                        exception::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 CHANGED Viewed

@@ -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/module.rs CHANGED Viewed

@@ -1,6 +1,6 @@
 use crate::isorun::function::Function;
 use crate::js;
-use magnus::Error;
+use magnus::{exception, Error};
 use std::cell::RefCell;
 #[magnus::wrap(class = "Isorun::Module")]
@@ -19,9 +19,10 @@ impl Module {
         export_name: String,
     ) -> Result<magnus::Value, Error> {
         let module = self.0.borrow();
-        let module_item = module
-            .import(export_name.as_str())
-            .map_err(|error| Error::runtime_error(format!("{}", error)))?;
+        let module_item =
+            module.import(export_name.as_str()).map_err(|error| {
+                Error::new(exception::runtime_error(), format!("{}", error))
+            })?;
         match module_item {
             js::module_item::ModuleItem::Value(v) => Ok(v.to_ruby().unwrap()),

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

@@ -1,3 +1,4 @@
+use crate::js::worker::WORKER;
 use deno_core::error::AnyError;
 use magnus::r_hash::ForEach;
 use magnus::value::{Qfalse, Qtrue};
@@ -5,12 +6,14 @@ use magnus::{
     Integer, RArray, RFloat, RHash, RString, RStruct, Symbol, Value, QFALSE,
     QNIL, QTRUE,
 };
-use v8::{Array, GetPropertyNamesArgs, HandleScope, Local, Object};
+use std::collections::HashMap;
+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 +39,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 +48,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 +64,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));
@@ -154,3 +159,67 @@ pub fn convert_ruby_to_v8<'s>(
     Ok(v8::null(scope).into())
 }
+pub(crate) fn low_memory_notification() {
+    WORKER.with(|worker| {
+        let mut worker = worker.worker.borrow_mut();
+        worker.js_runtime.v8_isolate().low_memory_notification();
+    });
+}
+pub(crate) fn stats() -> RHash {
+    WORKER.with(|worker| {
+        let mut worker = worker.worker.borrow_mut();
+        let heap_stats = &mut Default::default();
+        worker
+            .js_runtime
+            .v8_isolate()
+            .get_heap_statistics(heap_stats);
+        let current_thread = std::thread::current();
+        let thread = HashMap::from([(
+            "thread_id",
+            format!("{:?}", current_thread.id()),
+        )]);
+        let heap = HashMap::from([
+            ("external_memory", heap_stats.external_memory()),
+            ("heap_size_limit", heap_stats.heap_size_limit()),
+            ("malloced_memory", heap_stats.malloced_memory()),
+            (
+                "number_of_detached_contexts",
+                heap_stats.number_of_detached_contexts(),
+            ),
+            (
+                "number_of_native_contexts",
+                heap_stats.number_of_native_contexts(),
+            ),
+            ("peak_malloced_memory", heap_stats.peak_malloced_memory()),
+            ("total_available_size", heap_stats.total_available_size()),
+            (
+                "total_global_handles_size",
+                heap_stats.total_global_handles_size(),
+            ),
+            ("total_heap_size", heap_stats.total_heap_size()),
+            (
+                "total_heap_size_executable",
+                heap_stats.total_heap_size_executable(),
+            ),
+            ("total_physical_size", heap_stats.total_physical_size()),
+            (
+                "used_global_handles_size",
+                heap_stats.used_global_handles_size(),
+            ),
+            ("used_heap_size", heap_stats.used_heap_size()),
+        ]);
+        let h = RHash::new();
+        h.aset("current_thread", RHash::from_iter(thread))
+            .expect("cannot set stats for current_thread");
+        h.aset("heap", RHash::from_iter(heap))
+            .expect("cannot set stats for heap");
+        h
+    })
+}

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

@@ -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 CHANGED Viewed

@@ -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"))
         }
     }
 }
@@ -179,6 +229,7 @@ impl Default for Worker {
                 inspect: false,
             },
             extensions: std::mem::take(&mut extensions),
+            extensions_with_js: Default::default(),
             startup_snapshot: None,
             unsafely_ignore_certificate_errors: None,
             root_cert_store: None,
@@ -200,6 +251,7 @@ 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
@@ -254,17 +306,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 CHANGED Viewed

@@ -1,5 +1,6 @@
+use self::isorun::utils::stats;
 use crate::isorun::context::Context;
-use isorun::configure::set_receiver;
+use crate::isorun::utils::low_memory_notification;
 use isorun::function::Function;
 use isorun::module::Module;
 use magnus::{define_module, function, method, Error, Module as M, Object};
@@ -11,8 +12,14 @@ 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=");
+    root.define_module_function("stats", function!(stats, 0))
+        .expect("cannot define module function: stats");
+    root.define_module_function(
+        "low_memory_notification",
+        function!(low_memory_notification, 0),
+    )
+    .expect("cannot define module function: low_memory_notification");
     let context = root
         .define_class("Context", Default::default())
@@ -22,7 +29,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 +50,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/2.7/isorun.bundle CHANGED Viewed

Binary file

data/lib/isorun/3.0/isorun.bundle CHANGED Viewed

Binary file

data/lib/isorun/3.1/isorun.bundle CHANGED Viewed

Binary file

data/lib/isorun/context.rb CHANGED Viewed

@@ -10,7 +10,10 @@ module Isorun
         @export_names = export_names
       end
+      # Specify the module to import from
       def from(module_path)
+        module_path = module_path.to_s if module_path.is_a? Pathname
         mod = load(module_path)
         imports = export_names.map { |export_name| mod.import(export_name) }
         return imports.first if imports.size == 1
@@ -23,7 +26,7 @@ module Isorun
       CACHE_KEY = "isorun_module_path_mtime"
       private_constant :CACHE_KEY
-      def load(module_path)
+      def load(module_path) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
         return context.load(module_path) if Rails.env.production?
         key = module_path.parameterize
@@ -41,10 +44,14 @@ module Isorun
         # map to URI scheme to allow adding a timestamp to bust module cache
         module_path = "file://#{module_path}?t=#{mtime}"
-        return context.load(module_path) if cache_miss
+        if cache_miss
+          ActiveSupport::Notifications.instrument "load.module.isorun", { path: module_path }
+          return context.load(module_path)
+        end
         Rails.cache.write("#{CACHE_KEY}:#{key}", mtime) if prev_mtime < mtime
+        ActiveSupport::Notifications.instrument "load.module.isorun", { path: module_path }
         context.load(module_path)
       end
     end
@@ -52,11 +59,30 @@ module Isorun
     private_constant :Import
     class << self
-      def create(&block)
+      # Creates a new context and yields the context as the first argument to
+      # the block.
+      #
+      # @example Creates a new context, imports the default as function
+      #   result = Isorun::Context.create do |context|
+      #     func = context.import.from(module_path)
+      #     func.call("Hello, World!")
+      #   end
+      #
+      # @yield [context] The newly created JavaScript context
+      # @yieldparam [Isorun::Context] context
+      # @yieldreturn [Object, nil] An optional return value from the execution context
+      def create(options = default_options, &block)
         raise "[Isorun::Context] block missing when creating context" unless block
         context = Isorun::Context.new
-        yield(context)
+        context.receiver = options[:receiver] if options[:receiver].present?
+        result = yield(context)
+        context.receiver = nil if options[:receiver].present?
+        result
       end
       # @!method new()
@@ -66,19 +92,37 @@ module Isorun
       def default_options
         {
-          receiver: Isorun.configuration.receiver
+          receiver: nil
         }
       end
     end
+    # Specify items you want to import from the module. If none is specified,
+    # the default export is taken.
+    #
+    # @example Import default export
+    #   result = Isorun::Context.create do |context|
+    #     item = context.import.from(module_path)
+    #   end
+    #
+    # @example Import default export explicitly
+    #   result = Isorun::Context.create do |context|
+    #     item = context.import(:default).from(module_path)
+    #   end
+    #
+    # @example Import various exports
+    #   result = Isorun::Context.create do |context|
+    #     hello, world = context.import(:hello, :world).from(module_path)
+    #   end
     def import(*export_names)
       export_names = [*export_names].map(&:to_s)
       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/engine.rb CHANGED Viewed

@@ -12,7 +12,6 @@ module Isorun
     initializer "isorun.helpers", before: :load_config_initializers do
       ActiveSupport.on_load(:action_controller_base) do
-        Rails.logger.debug Isorun::Engine.helpers
         helper Isorun::Engine.helpers
       end
     end

data/lib/isorun/version.rb CHANGED Viewed

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

data/lib/isorun.rb CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: isorun
 version: !ruby/object:Gem::Version
-  version: 0.1.6.pre
+  version: 0.1.8
 platform: arm64-darwin
 authors:
 - Hannes Moser
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-12-10 00:00:00.000000000 Z
+date: 2023-01-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: railties
@@ -52,6 +52,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.9.46
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake-compiler
   requirement: !ruby/object:Gem::Requirement
@@ -80,6 +94,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec-rails
   requirement: !ruby/object:Gem::Requirement
@@ -94,10 +122,27 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: "Import ECMAScript modules into Ruby and use values and functions like
-  \nJavaScript is part of Ruby. Enables easy to set up server-side rendering for\nmodern
-  frontend stacks.\n\nIsorun embeds v8 into Ruby via a native extension built with
-  Rust and\ndeno_core.\n"
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.22.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.22.0
+description: |
+  Import ECMAScript modules into Ruby and use values and functions like
+  JavaScript is part of Ruby. Enables easy to set up server-side rendering for
+  modern frontend stacks.
+  Isorun embeds v8 into Ruby via a native extension built with Rust and
+  deno_core.
 email:
 - box@hannesmoser.at
 executables: []
@@ -112,7 +157,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 +205,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 DELETED Viewed

@@ -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)),
-    });
-}