isorun 0.1.0.pre-x86_64-darwin

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

@@ -0,0 +1,156 @@
+use deno_core::error::AnyError;
+use magnus::r_hash::ForEach;
+use magnus::value::{Qfalse, Qtrue};
+use magnus::{
+    Integer, RArray, RFloat, RHash, RString, RStruct, Symbol, Value, QFALSE,
+    QNIL, QTRUE,
+};
+use v8::{Array, GetPropertyNamesArgs, HandleScope, Local, Object};
+
+pub fn convert_v8_to_ruby(
+    value: Local<v8::Value>,
+    scope: &mut HandleScope,
+) -> Result<Value, AnyError> {
+    if value.is_null() {
+        return Ok(Value::from(QNIL));
+    }
+
+    if value.is_int32() {
+        return Ok(Value::from(Integer::from_i64(
+            value.int32_value(scope).unwrap() as i64,
+        )));
+    }
+
+    if value.is_number() {
+        return Ok(Value::from(
+            RFloat::from_f64(value.number_value(scope).unwrap()).unwrap(),
+        ));
+    }
+
+    if value.is_true() {
+        return Ok(Value::from(QTRUE));
+    }
+
+    if value.is_false() {
+        return Ok(Value::from(QFALSE));
+    }
+
+    if value.is_string() {
+        let raw = value.to_rust_string_lossy(scope);
+        return Ok(Value::from(RString::from(raw)));
+    }
+
+    if value.is_array() {
+        let arr = Local::<Array>::try_from(value).unwrap();
+        let length = arr.length();
+        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();
+            r_arr.push(val).expect("cannot add item to array");
+        }
+        return Ok(Value::from(r_arr));
+    }
+
+    if value.is_object() {
+        let obj = Local::<Object>::try_from(value).unwrap();
+        let properties = obj
+            .get_own_property_names(scope, GetPropertyNamesArgs::default())
+            .unwrap();
+        let length = properties.length();
+        let r_hash = RHash::new();
+        for i in 0..length {
+            let raw_key = properties.get_index(scope, i).unwrap();
+            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();
+            r_hash.aset(key, val).expect("cannot set item to hash");
+        }
+        return Ok(Value::from(r_hash));
+    }
+
+    Ok(Value::from(QNIL))
+}
+
+pub fn convert_ruby_to_v8<'s>(
+    value: Value,
+    scope: &mut HandleScope<'s>,
+) -> Result<Local<'s, v8::Value>, AnyError> {
+    if value.is_nil() {
+        return Ok(v8::null(scope).into());
+    }
+
+    if let Some(v) = Qtrue::from_value(value) {
+        return Ok(v8::Boolean::new(scope, v.to_bool()).into());
+    }
+
+    if let Some(v) = Qfalse::from_value(value) {
+        return Ok(v8::Boolean::new(scope, v.to_bool()).into());
+    }
+
+    if let Some(v) = Symbol::from_value(value) {
+        return Ok(v8::String::new(scope, v.to_string().as_str())
+            .unwrap()
+            .into());
+    }
+
+    if let Some(v) = Integer::from_value(value) {
+        return Ok(v8::Integer::new(scope, v.to_i32().unwrap()).into());
+    }
+
+    if let Some(v) = RFloat::from_value(value) {
+        return Ok(v8::Number::new(scope, v.to_f64()).into());
+    }
+
+    if let Some(v) = RString::from_value(value) {
+        return Ok(v8::String::new(scope, v.to_string().unwrap().as_str())
+            .unwrap()
+            .into());
+    }
+
+    if let Some(v) = RArray::from_value(value) {
+        let arr;
+        {
+            arr = Array::new(scope, v.len() as i32);
+        }
+
+        for (i, val) in v.each().enumerate() {
+            let v8_value;
+            {
+                v8_value = convert_ruby_to_v8(val.unwrap(), scope).unwrap();
+            }
+            arr.set_index(scope, i as u32, v8_value);
+        }
+        return Ok(arr.into());
+    }
+
+    if let Some(v) = RHash::from_value(value) {
+        let obj = Object::new(scope);
+        v.foreach(|key: Value, val: Value| {
+            let key = convert_ruby_to_v8(key, scope).unwrap();
+            let val = convert_ruby_to_v8(val, scope).unwrap();
+            obj.set(scope, key, val);
+
+            Ok(ForEach::Continue)
+        })
+        .expect("cannot convert hash into JavaScript object");
+
+        return Ok(obj.into());
+    }
+
+    if let Some(v) = RStruct::from_value(value) {
+        let obj = Object::new(scope);
+        for member in v.members().unwrap() {
+            let key = member.to_string();
+            let val = v.getmember::<&str, Value>(key.as_str()).unwrap();
+            let v8_key = v8::String::new(scope, key.as_str()).unwrap();
+            let v8_val = convert_ruby_to_v8(val, scope).unwrap();
+
+            obj.set(scope, v8_key.into(), v8_val);
+        }
+
+        return Ok(obj.into());
+    }
+
+    Ok(v8::null(scope).into())
+}

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

@@ -0,0 +1,3 @@
+pub(crate) mod module;
+pub(crate) mod module_item;
+pub(crate) mod worker;

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

@@ -0,0 +1,51 @@
+use crate::js::module_item::{Function, ModuleItem, Value as JsValue};
+use crate::js::worker::WORKER;
+use deno_core::error::AnyError;
+use deno_core::{JsRealm, ModuleId};
+use std::cell::RefCell;
+use std::rc::Rc;
+use v8::{Global, Local, Value};
+
+pub(crate) struct Module {
+    pub(crate) id: ModuleId,
+    pub(crate) realm: Rc<RefCell<JsRealm>>,
+}
+
+impl Module {
+    pub(crate) fn import(
+        &self,
+        export_name: &str,
+    ) -> Result<ModuleItem, AnyError> {
+        WORKER.with(|worker| {
+            let namespace = {
+                let mut worker = worker.worker.borrow_mut();
+                worker.js_runtime.get_module_namespace(self.id).unwrap()
+            };
+
+            let realm = self.realm.borrow();
+
+            let mut worker = worker.worker.borrow_mut();
+            let mut scope = realm.handle_scope(worker.js_runtime.v8_isolate());
+
+            let namespace = Local::new(&mut scope, namespace);
+
+            let export_name = v8::String::new(&mut scope, export_name).unwrap();
+
+            let binding =
+                namespace.get(&mut scope, export_name.into()).unwrap();
+            let global_binding = Global::<Value>::new(&mut scope, binding);
+
+            if binding.is_function() {
+                Ok(ModuleItem::Function(Function {
+                    binding: global_binding,
+                    realm: self.realm.clone(),
+                }))
+            } else {
+                Ok(ModuleItem::Value(JsValue {
+                    binding: global_binding,
+                    realm: self.realm.clone(),
+                }))
+            }
+        })
+    }
+}

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

@@ -0,0 +1,71 @@
+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;
+use v8::Global;
+
+pub(crate) enum ModuleItem {
+    Value(Value),
+    Function(Function),
+}
+
+pub(crate) struct Function {
+    pub(crate) binding: Global<v8::Value>,
+    pub(crate) realm: Rc<RefCell<JsRealm>>,
+}
+
+impl Function {
+    pub(crate) fn call(
+        &self,
+        args: &[Global<v8::Value>],
+    ) -> Result<magnus::Value, magnus::Error> {
+        WORKER.with(|worker| {
+            let realm = self.realm.borrow();
+            let realm = realm.deref();
+            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))
+        })
+    }
+
+    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 {
+    pub(crate) binding: Global<v8::Value>,
+    pub(crate) realm: Rc<RefCell<JsRealm>>,
+}
+
+impl Value {
+    pub(crate) fn to_ruby(&self) -> Option<magnus::Value> {
+        let realm = self.realm.borrow();
+        let realm = realm.deref();
+        WORKER.with(|worker| worker.to_ruby(realm, &self.binding))
+    }
+}

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

@@ -0,0 +1,265 @@
+use crate::isorun::utils::{convert_ruby_to_v8, convert_v8_to_ruby};
+use deno_core::error::AnyError;
+use deno_core::serde_v8::from_v8;
+use deno_core::{op, serde_v8, Extension, FsModuleLoader, JsRealm, ModuleId};
+use deno_runtime::deno_broadcast_channel::InMemoryBroadcastChannel;
+use deno_runtime::permissions::Permissions;
+use deno_runtime::worker::{MainWorker, WorkerOptions};
+use deno_runtime::BootstrapOptions;
+use deno_web::BlobStore;
+use magnus::block::Proc;
+use magnus::gvl::GVLContext;
+use magnus::{Error, Value};
+use std::borrow::BorrowMut;
+use std::cell::RefCell;
+use std::collections::{HashMap, HashSet};
+use std::path::Path;
+use std::rc::Rc;
+use std::string::ToString;
+use std::sync::Arc;
+use tokio::runtime::Runtime;
+use v8::{Global, Local};
+
+fn get_error_class_name(e: &AnyError) -> &'static str {
+    deno_runtime::errors::get_error_class_name(e).unwrap_or("Error")
+}
+
+const USER_AGENT: &str = "isorun";
+
+pub(crate) struct Worker {
+    pub(crate) runtime: Runtime,
+    pub(crate) worker: RefCell<MainWorker>,
+    module_map: RefCell<HashMap<String, ModuleId>>,
+    pub(crate) ruby_context: RefCell<Option<GVLContext>>,
+    pub(crate) ruby_receiver: RefCell<Option<Proc>>,
+}
+
+impl Worker {
+    pub(crate) fn create_realm(&self) -> Result<JsRealm, AnyError> {
+        let mut worker = self.worker.borrow_mut();
+        worker.js_runtime.create_realm()
+    }
+
+    pub(crate) fn load_module(&self, path: &str) -> Result<ModuleId, AnyError> {
+        let mut module_map = self.module_map.borrow_mut();
+        if module_map.contains_key(path) {
+            return Ok(*module_map.get(path).unwrap());
+        }
+
+        let module_id = {
+            let mut worker = self.worker.borrow_mut();
+
+            let module_specifier =
+                deno_core::resolve_url_or_path(path).unwrap();
+            let module_id = self
+                .runtime
+                .block_on(worker.preload_side_module(&module_specifier))?;
+            self.runtime.block_on(worker.evaluate_module(module_id))?;
+
+            module_id
+        };
+
+        module_map.insert(path.to_string(), module_id);
+
+        Ok(module_id)
+    }
+
+    pub(crate) async fn call(
+        &self,
+        realm: &JsRealm,
+        callee: &Global<v8::Value>,
+        args: &[Global<v8::Value>],
+    ) -> Result<Value, Error> {
+        let promise = {
+            let mut worker = self.worker.borrow_mut();
+            let mut scope = realm.handle_scope(worker.js_runtime.v8_isolate());
+
+            let callee = Local::<v8::Value>::new(&mut scope, callee);
+            let callee = Local::<v8::Function>::try_from(callee).unwrap();
+
+            let mut local_args: Vec<Local<v8::Value>> = vec![];
+            for arg in args {
+                let local_arg = Local::<v8::Value>::new(&mut scope, arg);
+                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();
+            Global::<v8::Value>::new(&mut scope, promise)
+        };
+
+        let value = {
+            let mut worker = self.worker.borrow_mut();
+            worker.js_runtime.resolve_value(promise).await.unwrap()
+        };
+
+        let value = self.to_ruby(realm, &value).unwrap();
+
+        Ok(value)
+    }
+
+    pub(crate) fn to_ruby(
+        &self,
+        realm: &JsRealm,
+        value: &Global<v8::Value>,
+    ) -> 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 {
+            Ok(v) => Some(v),
+            Err(_) => None,
+        }
+    }
+
+    pub(crate) fn to_v8(
+        &self,
+        realm: &JsRealm,
+        value: Value,
+    ) -> Option<Global<v8::Value>> {
+        let mut worker = self.worker.borrow_mut();
+        let mut scope = realm.handle_scope(worker.js_runtime.v8_isolate());
+        let value = convert_ruby_to_v8(value, &mut scope).unwrap();
+        let value = Global::<v8::Value>::new(&mut scope, value);
+
+        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)) = (
+            self.ruby_context.borrow_mut().as_mut(),
+            self.ruby_receiver.borrow_mut().as_mut(),
+        ) {
+            ctx.with_gvl(|| {
+                let args: (Value,) = (value,);
+                rec.call::<(Value,), Value>(args)
+            })?
+        } else {
+            Err(Error::runtime_error(
+                "Cannot send to ruby. Is the ruby receiver and context initialized and set?",
+            ))
+        }
+    }
+}
+
+impl Default for Worker {
+    fn default() -> Self {
+        let module_loader = Rc::new(FsModuleLoader);
+        let create_web_worker_cb = Arc::new(|_| {
+            todo!("Web workers are not supported in the example");
+        });
+        let web_worker_event_cb = Arc::new(|_| {
+            todo!("Web workers are not supported in the example");
+        });
+
+        let extension_send = Extension::builder()
+            .ops(vec![op_send_to_ruby::decl()])
+            .build();
+        let mut extensions = vec![extension_send];
+
+        let options = WorkerOptions {
+            bootstrap: BootstrapOptions {
+                args: vec![],
+                cpu_count: 1,
+                debug_flag: false,
+                enable_testing_features: false,
+                locale: v8::icu::get_language_tag(),
+                location: None,
+                no_color: false,
+                is_tty: false,
+                runtime_version: "x".to_string(),
+                ts_version: "x".to_string(),
+                unstable: false,
+                user_agent: USER_AGENT.to_string(),
+                inspect: false,
+            },
+            extensions: std::mem::take(&mut extensions),
+            startup_snapshot: None,
+            unsafely_ignore_certificate_errors: None,
+            root_cert_store: None,
+            seed: None,
+            source_map_getter: None,
+            format_js_error_fn: None,
+            web_worker_preload_module_cb: web_worker_event_cb.clone(),
+            web_worker_pre_execute_module_cb: web_worker_event_cb,
+            create_web_worker_cb,
+            maybe_inspector_server: None,
+            should_break_on_first_statement: false,
+            module_loader,
+            npm_resolver: None,
+            get_error_class_fn: Some(&get_error_class_name),
+            cache_storage_dir: None,
+            origin_storage_dir: None,
+            blob_store: BlobStore::default(),
+            broadcast_channel: InMemoryBroadcastChannel::default(),
+            shared_array_buffer_store: None,
+            compiled_wasm_module_store: None,
+            stdio: Default::default(),
+        };
+
+        // todo: we don't use the main module at all, but it could be used as an
+        //  entry point for "eval" JavaScript.
+        let js_path = Path::new(env!("CARGO_MANIFEST_DIR")).join("src/call.js");
+        let main_module =
+            deno_core::resolve_path(&js_path.to_string_lossy()).unwrap();
+        let permissions = Permissions::allow_all();
+        let mut worker = MainWorker::bootstrap_from_options(
+            main_module.clone(),
+            permissions,
+            options,
+        );
+
+        let runtime = tokio::runtime::Builder::new_current_thread()
+            .enable_all()
+            .build()
+            .unwrap();
+
+        runtime.block_on(async {
+            let module_id =
+                worker.preload_main_module(&main_module).await.unwrap();
+            worker
+                .evaluate_module(module_id)
+                .await
+                .expect("cannot evaluate core module");
+        });
+
+        Worker {
+            runtime,
+            module_map: RefCell::from(HashMap::default()),
+            worker: RefCell::from(worker),
+            ruby_context: RefCell::from(None),
+            ruby_receiver: RefCell::from(None),
+        }
+    }
+}
+
+thread_local! {
+    pub(crate) static WORKER: Worker = Worker::default();
+    pub(crate) static MODULE_MAP: HashSet<ModuleId> = HashSet::default();
+}
+
+#[allow(clippy::extra_unused_lifetimes)]
+#[op(v8)]
+fn op_send_to_ruby<'a>(
+    // do not remove the v8:: prefix, otherwise the macro complains
+    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))
+            })
+    })
+}

data/ext/isorun/src/lib.rs

@@ -0,0 +1,51 @@
+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};
+
+mod isorun;
+mod js;
+
+#[magnus::init]
+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");
+    context
+        .define_singleton_method("new", function!(Context::new, 0))
+        .expect("cannot define singelton method: new");
+    context
+        .define_method("load", method!(Context::load, 1))
+        .expect("cannot load module");
+
+    let module = root
+        .define_class("Module", Default::default())
+        .expect("cannot define class: Isorun::Module");
+    module
+        .define_private_method("id", method!(Module::id, 0))
+        .expect("cannot define method: module_id");
+    module
+        .define_method("import", method!(Module::import, 1))
+        .expect("cannot define method: import");
+
+    let function = root
+        .define_class("Function", Default::default())
+        .expect("cannot define class: Isorun::Function");
+    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/config/abstract_builder.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Isorun
+  class Config
+    # Abstract base class for isorun and it's extensions configuration
+    # builder. Instantiates and validates gem configuration.
+    #
+    class AbstractBuilder
+      attr_reader :config
+
+      # @param [Class] config class
+      #
+      def initialize(config = Config.new, &block)
+        @config = config
+        instance_eval(&block)
+      end
+
+      # Builds and validates configuration.
+      #
+      # @return [Isorun::Config] config instance
+      #
+      def build
+        @config.validate! if @config.respond_to?(:validate!)
+        @config
+      end
+    end
+  end
+end