Allow to wrap arbitrary JS Object by Ruby's JS::Object

Author: kateinoigakukun

ext/js/bindgen/rb-js-abi-host.wit

@@ -11,7 +11,8 @@ rb-object-to-js-rb-value: function(raw-rb-abi-value: u32) -> js-abi-value
 
 js-value-to-string: function(value: js-abi-value) -> string
 
-take-js-value: function(value: js-abi-value)
+export-js-value-to-host: function(value: js-abi-value)
+import-js-value-from-host: function() -> js-abi-value
 
 reflect-apply: function(target: js-abi-value, this-argument: js-abi-value, arguments: list<js-abi-value>) -> js-abi-value
 reflect-construct: function(target: js-abi-value, arguments: list<js-abi-value>) -> js-abi-value

ext/js/js-core.c

@@ -239,10 +239,13 @@ static VALUE _rb_js_obj_inspect(VALUE obj) {
  */
 static VALUE _rb_js_export_to_js(VALUE obj) {
   struct jsvalue *p = check_jsvalue(obj);
-  rb_js_abi_host_take_js_value(p->abi);
+  rb_js_abi_host_export_js_value_to_host(p->abi);
   return Qnil;
 }
 
+static VALUE _rb_js_import_from_js(VALUE obj) {
+  return jsvalue_s_new(rb_js_abi_host_import_js_value_from_host());
+}
 
 /*
  * call-seq:
@@ -317,6 +320,7 @@ void Init_js() {
   rb_define_method(rb_cJS_Object, "[]=", _rb_js_obj_aset, 2);
   rb_define_method(rb_cJS_Object, "call", _rb_js_obj_call, -1);
   rb_define_method(rb_cJS_Object, "__export_to_js", _rb_js_export_to_js, 0);
+  rb_define_singleton_method(rb_cJS_Object, "__import_from_js", _rb_js_import_from_js, 0);
   rb_define_method(rb_cJS_Object, "inspect", _rb_js_obj_inspect, 0);
   rb_define_singleton_method(rb_cJS_Object, "wrap", _rb_js_obj_wrap, 1);
 

packages/npm-packages/ruby-wasm-wasi/src/index.ts

@@ -23,12 +23,12 @@ import { addRbJsAbiHostToImports, JsAbiValue } from "./bindgen/rb-js-abi-host";
 export class RubyVM {
   guest: RbAbi.RbAbiGuest;
   private instance: WebAssembly.Instance | null = null;
-  private exporter: JsValueExporter;
+  private transport: JsValueTransport;
   private exceptionFormatter: RbExceptionFormatter;
 
   constructor() {
     this.guest = new RbAbi.RbAbiGuest();
-    this.exporter = new JsValueExporter();
+    this.transport = new JsValueTransport();
     this.exceptionFormatter = new RbExceptionFormatter();
   }
 
@@ -101,9 +101,12 @@ export class RubyVM {
         jsValueToString: (value) => {
           return value.toString();
         },
-        takeJsValue: (value) => {
+        exportJsValueToHost: (value) => {
           // See `JsValueExporter` for the reason why we need to do this
-          this.exporter.takeJsValue(value);
+          this.transport.takeJsValue(value);
+        },
+        importJsValueFromHost: () => {
+          return this.transport.consumeJsValue();
         },
         instanceOf: (value, klass) => {
           if (typeof klass === "function") {
@@ -180,8 +183,21 @@ export class RubyVM {
     return evalRbCode(this, this.privateObject(), code);
   }
 
+  /**
+   * Wrap a JavaScript value into a Ruby JS::Object
+   * @param value The value to convert to RbValue
+   * @returns the RbValue object representing the given JS value
+   *
+   * @example
+   * const hash = vm.eval(`Hash.new`)
+   * hash.call("store", vm.eval(`"key1"`), vm.wrap(new Object()));
+   */
+  wrap(value: any): RbValue {
+    return this.transport.importJsValue(value, this);
+  }
+
   private privateObject(): RubyVMPrivate {
-    return { exporter: this.exporter, exceptionFormatter: this.exceptionFormatter }
+    return { transport: this.transport, exceptionFormatter: this.exceptionFormatter }
   }
 }
 
@@ -204,14 +220,26 @@ export class RubyVM {
  *
  * Note that `exportJsValue` is not reentrant.
  */
-class JsValueExporter {
-  private _takenJsValues: JsAbiValue = null;
+class JsValueTransport {
+  private _takenJsValue: JsAbiValue = null;
   takeJsValue(value: JsAbiValue) {
-    this._takenJsValues = value;
+    this._takenJsValue = value;
+  }
+  consumeJsValue(): JsAbiValue {
+    return this._takenJsValue;
   }
+
   exportJsValue(value: RbValue): JsAbiValue {
     value.call("__export_to_js");
-    return this._takenJsValues;
+    return this._takenJsValue;
+  }
+
+  importJsValue(value: JsAbiValue, vm: RubyVM): RbValue {
+    this._takenJsValue = value;
+    return vm.eval(`
+      require "js"
+      JS::Object.__import_from_js
+    `);
   }
 }
 
@@ -284,7 +312,7 @@ export class RbValue {
     if (jsValue.call("nil?").toString() === "true") {
       return null;
     }
-    return this.privateObject.exporter.exportJsValue(jsValue);
+    return this.privateObject.transport.exportJsValue(jsValue);
   }
 }
 
@@ -302,7 +330,7 @@ enum ruby_tag_type {
 }
 
 type RubyVMPrivate = {
-  exporter: JsValueExporter,
+  transport: JsValueTransport,
   exceptionFormatter: RbExceptionFormatter,
 };
 

packages/npm-packages/ruby-wasm-wasi/test/vm.test.ts

@@ -170,4 +170,21 @@ eval:11:in \`<main>'`);
     expect(o1.call("hash").toString()).toBe(o2.call("hash").toString());
     expect(o2.call("hash").toString()).toBe(o3.call("hash").toString());
   });
+
+  test("Wrap arbitrary JS object to RbValue", async () => {
+    const vm = await initRubyVM();
+    const o1 = { v() { return 42 } }
+    const X = vm.eval(`
+    module X
+      def self.identity(x) = x
+    end
+    X
+    `);
+    const o1Clone = X.call("identity", vm.wrap(o1));
+    expect(o1Clone.call("call", vm.eval(`"v"`)).toJS().toString()).toBe("42");
+
+    // Check that JS object can be stored in Ruby Hash
+    const hash = vm.eval(`Hash.new`)
+    hash.call("store", vm.eval(`"key1"`), vm.wrap(new Object()));
+  });
 });