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

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

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

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: 4b35798ccf95eb1f8e6ec527419b949e6addabf19927112e6608d763bcda9944
-  data.tar.gz: 2bfb8f9f35832d09b66186cd0a30909d91429915a19ed2b985cd4119e2c6107e
+  metadata.gz: a611e71b2fb8ba1f62c3eb3ba1d62914e4cad152a0c404d308ead15fbcf5ed8b
+  data.tar.gz: 6a0c9b323c9e9676ddd1215e2f8299f1cee3cbd70c31e73598bd497cd8ee6e2d
 SHA512:
-  metadata.gz: 45474d5583c3d5b878d7bffe65ea22dacf93d8678134f9d92ae2358b0cf3c8611d5b6b2e8eabd57aee5c732255f0c77da15c03b17323dffb3faa697a9607670d
-  data.tar.gz: b186dbae6efb8299075cd7336c41715e7b82dce20a0f749220911ced6901ecaa0de47d3d429493023a803bfcef9cf8f1b0399a0e5540ac2584e9da3fe00b5568
+  metadata.gz: c8556803ee6aa905c1e713fd4940143cf96c220dce608c5d46f975172f0b035bac4916bcfb99d5c68c5bd77724dc5928cecd94b78ac58d1c258d445421d42ab5
+  data.tar.gz: da661918f416b7892131f4fa0f1cc16dd710d57d3c661441bd898680e4726c45c68bcb4165e656494440663af4fc8895b3cb0b3c8704c2a765f1d05437a466dd

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