quickjs 0.14.0 → 0.15.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 69b86d7c5040dba161c1d6f67cb3eab3fd8a3dc51b30eb6d355c2580dbc29602
-  data.tar.gz: 5e174baed18d79e0ac18a496f97cd580fd20830a98fb240351eeea46abe57683
+  metadata.gz: 54fe50175028245be99548bdb43a1884ceb956f77a999fca6c4cdf9ea9085a13
+  data.tar.gz: ddbf8d46cfec89db687899ec083e7ef2859ebd4ff9d711c9a18801d15c8d4ad0
 SHA512:
-  metadata.gz: 9f7abcc1733fcfe9c51aacf81c9e34b05e7e44142a9db79a8bd4525ba67570f897cd7c1fb200428507876dad35a67b9a3f383711a3b0cfc9ff1b46728cd1c125
-  data.tar.gz: a15abae6b482f0df7efc89e9b0a3b9d3ca3bab8bb8d04ce7844f60b195a0314d8e12d2b3bbdf8cf01dae763e75945d4e84cf3c1efbe2a99d4cfa525e2279625e
+  metadata.gz: ce86220556d6e2bbf06f2da42227876f972a991e4beca36ecce89efcfc84f11ee6d62172813442368af11632f33f970db97535eab435f3fa6046be955c98529d
+  data.tar.gz: 255c23efa72230afbac3760e1cd8efd8ba29038263371ed4a4bc591dfbc58da9e48e2524bde82151cb8b10d14cda87255170fe0c46377efec8cb114ea8e9a855

data/README.md

@@ -40,6 +40,13 @@ Quickjs.eval_code(code,
 )
 ```
 
+#### Filename
+
+```rb
+# Label shown in JS stack traces (default: "<code>")
+Quickjs.eval_code(code, filename: 'my_script.js')
+```
+
 #### Timeout
 
 ```rb
@@ -133,6 +140,23 @@ end
 vm.eval_code("greetingTo('Rick')") #=> 'Hello! Rick'
 ```
 
+Pass an `Array` as the name to register the function on an existing JS object (the last element is the method name; preceding elements are the object path):
+
+```rb
+vm = Quickjs::VM.new
+vm.eval_code("const myLib = {}")
+vm.define_function(["myLib", "greetingTo"]) { |name| "Hello, #{name}!" }
+
+vm.eval_code("myLib.greetingTo('Rick')") #=> 'Hello! Rick'
+
+# Deeply nested
+vm.eval_code("const a = { b: { c: {} } }")
+vm.define_function(["a", "b", "c", "double"]) { |x| x * 2 }
+vm.eval_code("a.b.c.double(21)") #=> 42
+```
+
+`define_function` returns the registered name as a `Symbol` (or an `Array` of `Symbol`s for array paths).
+
 A Ruby exception raised inside the block is catchable in JS as an `Error`, and propagates back to Ruby as the original exception type if uncaught in JS.
 
 ```rb
@@ -177,14 +201,20 @@ vm.eval_code('console.log("hello", 42)')
 | `string` | ↔ | `String` | |
 | `true` / `false` | ↔ | `true` / `false` | |
 | `null` | ↔ | `nil` | |
-| `Array` | ↔ | `Array` | via JSON |
-| `Object` | ↔ | `Hash` | via JSON |
+| `Array` | ↔ | `Array` | recursively converted |
+| `Object` | ↔ | `Hash` | recursively converted; keys are always `String` |
+| `function` | → | `Quickjs::Function` — `.source`, `.call(*args, on:)` | |
 | `undefined` | → | `Quickjs::Value::UNDEFINED` | |
 | `NaN` | → | `Quickjs::Value::NAN` | |
 | `Blob` | → | `Quickjs::Blob` — `.size`, `.type`, `.content` | requires `POLYFILL_FILE` |
 | `File` | → | `Quickjs::File` — `.name`, `.last_modified` + Blob attrs | requires `POLYFILL_FILE` |
 | `File` proxy | ← | `::File` | requires `POLYFILL_FILE`; applies to `define_function` return values |
 
+## Acknowledgements
+
+- [@ursm](https://github.com/ursm) — for continuous contributions improving performance and developer experience
+- [@persona-id](https://github.com/persona-id) — for providing real-world use cases that shape the direction of this project
+
 ## License
 
 - `ext/quickjsrb/quickjs`

data/ext/quickjsrb/extconf.rb

@@ -3,6 +3,7 @@
 require 'mkmf'
 
 $VPATH << "$(srcdir)/quickjs"
+$INCFLAGS << " -I$(srcdir)/quickjs"
 
 $srcs = [
   'dtoa.c',
@@ -21,8 +22,6 @@ $srcs = [
   'quickjsrb_crypto_subtle.c',
 ]
 
-append_cflags('-I$(srcdir)/quickjs')
-
 append_cflags('-g')
 append_cflags('-O2')
 append_cflags('-Wall')

data/ext/quickjsrb/quickjsrb.c

@@ -26,6 +26,9 @@ const int num_native_errors = sizeof(native_errors) / sizeof(native_errors[0]);
 
 static int dispatch_log(VMData *data, const char *severity, VALUE r_row);
 
+JSValue to_js_value(JSContext *ctx, VALUE r_value);
+VALUE to_rb_value(JSContext *ctx, JSValue j_val);
+
 JSValue j_error_from_ruby_error(JSContext *ctx, VALUE r_error)
 {
   JSValue j_error = JS_NewError(ctx); // may wanna have custom error class to determine in JS' end
@@ -45,6 +48,33 @@ JSValue j_error_from_ruby_error(JSContext *ctx, VALUE r_error)
   return j_error;
 }
 
+typedef struct
+{
+  JSContext *ctx;
+  JSValue j_obj;
+} RbHashToJsArg;
+
+static int rb_hash_entry_to_js(VALUE r_key, VALUE r_val, VALUE extra)
+{
+  RbHashToJsArg *arg = (RbHashToJsArg *)extra;
+  const char *key_cstr;
+  if (SYMBOL_P(r_key))
+  {
+    key_cstr = rb_id2name(SYM2ID(r_key));
+  }
+  else if (RB_TYPE_P(r_key, T_STRING))
+  {
+    key_cstr = StringValueCStr(r_key);
+  }
+  else
+  {
+    VALUE r_key_str = rb_funcall(r_key, rb_intern("to_s"), 0);
+    key_cstr = StringValueCStr(r_key_str);
+  }
+  JS_SetPropertyStr(arg->ctx, arg->j_obj, key_cstr, to_js_value(arg->ctx, r_val));
+  return ST_CONTINUE;
+}
+
 JSValue to_js_value(JSContext *ctx, VALUE r_value)
 {
   switch (TYPE(r_value))
@@ -52,45 +82,57 @@ JSValue to_js_value(JSContext *ctx, VALUE r_value)
   case T_NIL:
     return JS_NULL;
   case T_FIXNUM:
+    return JS_NewInt64(ctx, NUM2LL(r_value));
   case T_FLOAT:
+    return JS_NewFloat64(ctx, NUM2DBL(r_value));
+  case T_BIGNUM:
   {
     VALUE r_str = rb_funcall(r_value, rb_intern("to_s"), 0);
-    char *str = StringValueCStr(r_str);
+    JSValue j_str = JS_NewStringLen(ctx, RSTRING_PTR(r_str), RSTRING_LEN(r_str));
     JSValue j_global = JS_GetGlobalObject(ctx);
     JSValue j_numberClass = JS_GetPropertyStr(ctx, j_global, "Number");
-    JSValue j_str = JS_NewString(ctx, str);
-    JSValue j_stringified = JS_Call(ctx, j_numberClass, JS_UNDEFINED, 1, (JSValueConst *)&j_str);
-    JS_FreeValue(ctx, j_global);
-    JS_FreeValue(ctx, j_numberClass);
+    JSValue j_num = JS_Call(ctx, j_numberClass, JS_UNDEFINED, 1, (JSValueConst *)&j_str);
     JS_FreeValue(ctx, j_str);
-
-    return j_stringified;
+    JS_FreeValue(ctx, j_numberClass);
+    JS_FreeValue(ctx, j_global);
+    return j_num;
   }
   case T_STRING:
-  {
-    char *str = StringValueCStr(r_value);
-
-    return JS_NewString(ctx, str);
-  }
+    return JS_NewStringLen(ctx, RSTRING_PTR(r_value), RSTRING_LEN(r_value));
   case T_SYMBOL:
   {
-    VALUE r_str = rb_funcall(r_value, rb_intern("to_s"), 0);
-    char *str = StringValueCStr(r_str);
-
-    return JS_NewString(ctx, str);
+    if (r_value == QUICKJSRB_SYM(undefinedId))
+      return JS_UNDEFINED;
+    if (r_value == QUICKJSRB_SYM(nanId))
+    {
+      JSValue j_global = JS_GetGlobalObject(ctx);
+      JSValue j_nan = JS_GetPropertyStr(ctx, j_global, "NaN");
+      JS_FreeValue(ctx, j_global);
+      return j_nan;
+    }
+    const char *name = rb_id2name(SYM2ID(r_value));
+    return JS_NewString(ctx, name);
   }
   case T_TRUE:
     return JS_TRUE;
   case T_FALSE:
     return JS_FALSE;
-  case T_HASH:
   case T_ARRAY:
   {
-    VALUE r_json_str = rb_funcall(r_value, rb_intern("to_json"), 0);
-    char *str = StringValueCStr(r_json_str);
-    JSValue j_parsed = JS_ParseJSON(ctx, str, strlen(str), "<quickjsrb.c>");
-
-    return j_parsed;
+    int len = RARRAY_LEN(r_value);
+    JSValue j_arr = JS_NewArray(ctx);
+    for (int i = 0; i < len; i++)
+    {
+      JS_SetPropertyUint32(ctx, j_arr, (uint32_t)i, to_js_value(ctx, RARRAY_AREF(r_value, i)));
+    }
+    return j_arr;
+  }
+  case T_HASH:
+  {
+    JSValue j_obj = JS_NewObject(ctx);
+    RbHashToJsArg arg = {ctx, j_obj};
+    rb_hash_foreach(r_value, rb_hash_entry_to_js, (VALUE)&arg);
+    return j_obj;
   }
   default:
   {
@@ -100,10 +142,7 @@ JSValue to_js_value(JSContext *ctx, VALUE r_value)
       if (!JS_IsUndefined(data->j_file_proxy_creator))
         return quickjsrb_file_to_js(ctx, r_value);
     }
-    if (TYPE(r_value) == T_OBJECT && RTEST(rb_funcall(
-                                         r_value,
-                                         rb_intern("is_a?"),
-                                         1, rb_const_get(rb_cClass, rb_intern("Exception")))))
+    if (rb_obj_is_kind_of(r_value, rb_eException))
     {
       return j_error_from_ruby_error(ctx, r_value);
     }
@@ -157,6 +196,59 @@ VALUE to_r_json(JSContext *ctx, JSValue j_val)
   return r_str;
 }
 
+static int js_is_plain_object(JSContext *ctx, JSValue j_val)
+{
+  JSValue j_proto = JS_GetPrototype(ctx, j_val);
+  if (JS_IsNull(j_proto))
+    return 1; // Object.create(null)
+  JSValue j_global = JS_GetGlobalObject(ctx);
+  JSValue j_Object = JS_GetPropertyStr(ctx, j_global, "Object");
+  JSValue j_Object_proto = JS_GetPropertyStr(ctx, j_Object, "prototype");
+  int result = JS_StrictEq(ctx, j_proto, j_Object_proto);
+  JS_FreeValue(ctx, j_proto);
+  JS_FreeValue(ctx, j_global);
+  JS_FreeValue(ctx, j_Object);
+  JS_FreeValue(ctx, j_Object_proto);
+  return result;
+}
+
+static VALUE js_array_to_rb(JSContext *ctx, JSValue j_val)
+{
+  JSValue j_length = JS_GetPropertyStr(ctx, j_val, "length");
+  uint32_t length = 0;
+  JS_ToUint32(ctx, &length, j_length);
+  JS_FreeValue(ctx, j_length);
+
+  VALUE r_array = rb_ary_new_capa(length);
+  for (uint32_t i = 0; i < length; i++)
+  {
+    JSValue j_elem = JS_GetPropertyUint32(ctx, j_val, i);
+    rb_ary_push(r_array, to_rb_value(ctx, j_elem));
+    JS_FreeValue(ctx, j_elem);
+  }
+  return r_array;
+}
+
+static VALUE js_plain_object_to_rb(JSContext *ctx, JSValue j_val)
+{
+  JSPropertyEnum *ptab;
+  uint32_t plen;
+  if (JS_GetOwnPropertyNames(ctx, &ptab, &plen, j_val, JS_GPN_STRING_MASK | JS_GPN_ENUM_ONLY) < 0)
+    return rb_hash_new();
+
+  VALUE r_hash = rb_hash_new();
+  for (uint32_t i = 0; i < plen; i++)
+  {
+    const char *key = JS_AtomToCString(ctx, ptab[i].atom);
+    JSValue j_prop = JS_GetProperty(ctx, j_val, ptab[i].atom);
+    rb_hash_aset(r_hash, rb_str_new2(key), to_rb_value(ctx, j_prop));
+    JS_FreeCString(ctx, key);
+    JS_FreeValue(ctx, j_prop);
+  }
+  JS_FreePropertyEnum(ctx, ptab, plen);
+  return r_hash;
+}
+
 VALUE to_rb_value(JSContext *ctx, JSValue j_val)
 {
   switch (JS_VALUE_GET_NORM_TAG(j_val))
@@ -179,16 +271,13 @@ VALUE to_rb_value(JSContext *ctx, JSValue j_val)
   }
   case JS_TAG_STRING:
   {
-    int couldntParse;
-    VALUE r_result = rb_protect(r_try_json_parse, to_r_json(ctx, j_val), &couldntParse);
-    if (couldntParse)
-    {
+    size_t len;
+    const char *str = JS_ToCStringLen(ctx, &len, j_val);
+    if (str == NULL)
       return Qnil;
-    }
-    else
-    {
-      return r_result;
-    }
+    VALUE r_str = rb_utf8_str_new(str, (long)len);
+    JS_FreeCString(ctx, str);
+    return r_str;
   }
   case JS_TAG_OBJECT:
   {
@@ -200,6 +289,18 @@ VALUE to_rb_value(JSContext *ctx, JSValue j_val)
       return Qnil;
     }
 
+    if (JS_IsFunction(ctx, j_val))
+    {
+      JSValue j_toStringFunc = JS_GetPropertyStr(ctx, j_val, "toString");
+      JSValue j_source = JS_Call(ctx, j_toStringFunc, j_val, 0, NULL);
+      JS_FreeValue(ctx, j_toStringFunc);
+      const char *source = JS_ToCString(ctx, j_source);
+      JS_FreeValue(ctx, j_source);
+      VALUE r_source = rb_str_new2(source);
+      JS_FreeCString(ctx, source);
+      return rb_funcall(rb_path2class("Quickjs::Function"), rb_intern("new"), 1, r_source);
+    }
+
     if (JS_IsError(ctx, j_val))
     {
       VALUE r_maybe_ruby_error = find_ruby_error(ctx, j_val);
@@ -239,6 +340,13 @@ VALUE to_rb_value(JSContext *ctx, JSValue j_val)
         return r_maybe_file;
     }
 
+    if (JS_IsArray(ctx, j_val))
+      return js_array_to_rb(ctx, j_val);
+
+    if (js_is_plain_object(ctx, j_val))
+      return js_plain_object_to_rb(ctx, j_val);
+
+    // Fallback: non-plain objects (Date, RegExp, Map, class instances, functions, etc.)
     VALUE r_str = to_r_json(ctx, j_val);
 
     if (rb_funcall(r_str, rb_intern("=="), 1, rb_str_new2("undefined")))
@@ -376,16 +484,19 @@ static VALUE r_try_call_proc(VALUE r_try_args)
 
 static JSValue js_quickjsrb_call_global(JSContext *ctx, JSValueConst _this, int argc, JSValueConst *argv, int _magic, JSValue *func_data)
 {
-  const char *funcName = JS_ToCString(ctx, func_data[0]);
+  // func_data[0] holds the Ruby Symbol ID for the defined function (stored by
+  // vm_m_defineGlobalFunction). Looking up by ID avoids a JS_ToCString +
+  // rb_intern round-trip on every call.
+  int64_t key_id;
+  JS_ToInt64(ctx, &key_id, func_data[0]);
 
   VMData *data = JS_GetContextOpaque(ctx);
-  VALUE r_proc = rb_hash_aref(data->defined_functions, ID2SYM(rb_intern(funcName)));
+  VALUE r_proc = rb_hash_aref(data->defined_functions, ID2SYM((ID)key_id));
   // Shouldn't happen
   if (r_proc == Qnil)
   {
-    return JS_ThrowReferenceError(ctx, "Proc `%s` is not defined", funcName); // TODO: Free funcnName
+    return JS_ThrowReferenceError(ctx, "Proc is not defined");
   }
-  JS_FreeCString(ctx, funcName);
 
   VALUE r_call_args = rb_ary_new();
   rb_ary_push(r_call_args, r_proc);
@@ -736,22 +847,36 @@ static VALUE to_rb_return_value(JSContext *ctx, JSValue j_val)
   return result;
 }
 
-static VALUE vm_m_evalCode(VALUE r_self, VALUE r_code)
+static VALUE vm_m_evalCode(int argc, VALUE *argv, VALUE r_self)
 {
   VMData *data;
   TypedData_Get_Struct(r_self, VMData, &vm_type, data);
 
+  VALUE r_code, r_opts;
+  rb_scan_args(argc, argv, "1:", &r_code, &r_opts);
+
   if (!RB_TYPE_P(r_code, T_STRING))
   {
     VALUE r_code_class = rb_class_name(CLASS_OF(r_code));
     rb_raise(rb_eTypeError, "JavaScript code must be a String, got %s", StringValueCStr(r_code_class));
   }
 
+  const char *filename = "<code>";
+  if (!NIL_P(r_opts))
+  {
+    VALUE r_filename = rb_hash_aref(r_opts, ID2SYM(rb_intern("filename")));
+    if (!NIL_P(r_filename))
+    {
+      Check_Type(r_filename, T_STRING);
+      filename = StringValueCStr(r_filename);
+    }
+  }
+
   clock_gettime(CLOCK_MONOTONIC, &data->eval_time->started_at);
   JS_SetInterruptHandler(JS_GetRuntime(data->context), interrupt_handler, data->eval_time);
 
-  char *code = StringValueCStr(r_code);
-  JSValue j_codeResult = JS_Eval(data->context, code, strlen(code), "<code>", JS_EVAL_TYPE_GLOBAL | JS_EVAL_FLAG_ASYNC);
+  StringValue(r_code);
+  JSValue j_codeResult = JS_Eval(data->context, RSTRING_PTR(r_code), RSTRING_LEN(r_code), filename, JS_EVAL_TYPE_GLOBAL | JS_EVAL_FLAG_ASYNC);
   JSValue j_awaitedResult = js_std_await(data->context, j_codeResult); // This frees j_codeResult
   // JS_EVAL_FLAG_ASYNC wraps the result in {value, done} — extract the actual value
   // Free j_awaitedResult before to_rb_return_value because it may raise (longjmp), which would skip cleanup
@@ -769,33 +894,117 @@ static VALUE vm_m_defineGlobalFunction(int argc, VALUE *argv, VALUE r_self)
   VALUE r_block;
   rb_scan_args(argc, argv, "10*&", &r_name, &r_flags, &r_block);
 
-  if (!(SYMBOL_P(r_name) || RB_TYPE_P(r_name, T_STRING)))
-  {
-    rb_raise(rb_eTypeError, "function's name should be a Symbol or a String");
-  }
-
   VMData *data;
   TypedData_Get_Struct(r_self, VMData, &vm_type, data);
 
-  VALUE r_name_sym = rb_funcall(r_name, rb_intern("to_sym"), 0);
+  if (RB_TYPE_P(r_name, T_ARRAY))
+  {
+    long path_len = RARRAY_LEN(r_name);
+    if (path_len < 1)
+      rb_raise(rb_eArgError, "function's path array must not be empty");
 
-  rb_hash_aset(data->defined_functions, r_name_sym, r_block);
-  VALUE r_name_str = rb_funcall(r_name, rb_intern("to_s"), 0);
-  char *funcName = StringValueCStr(r_name_str);
+    for (long i = 0; i < path_len; i++)
+    {
+      VALUE r_seg = RARRAY_AREF(r_name, i);
+      if (!(SYMBOL_P(r_seg) || RB_TYPE_P(r_seg, T_STRING)))
+        rb_raise(rb_eTypeError, "function's name should be a Symbol or a String");
+    }
 
-  JSValueConst ruby_data[2];
-  ruby_data[0] = JS_NewString(data->context, funcName);
-  ruby_data[1] = JS_NewBool(data->context, RTEST(rb_funcall(r_flags, rb_intern("include?"), 1, ID2SYM(rb_intern("async")))));
+    // Build internal lookup key by joining path segments with "."
+    // e.g. ["myLib", "hello"] -> :"myLib.hello"
+    VALUE r_segs = rb_ary_new();
+    for (long i = 0; i < path_len; i++)
+      rb_ary_push(r_segs, rb_funcall(RARRAY_AREF(r_name, i), rb_intern("to_s"), 0));
+    VALUE r_key_str = rb_funcall(r_segs, rb_intern("join"), 1, rb_str_new2("."));
+    VALUE r_key_sym = rb_funcall(r_key_str, rb_intern("to_sym"), 0);
+    rb_hash_aset(data->defined_functions, r_key_sym, r_block);
+
+    VALUE r_func_seg_str = rb_funcall(RARRAY_AREF(r_name, path_len - 1), rb_intern("to_s"), 0);
+    char *funcName = StringValueCStr(r_func_seg_str);
+
+    JSValueConst ruby_data[2];
+    ruby_data[0] = JS_NewInt64(data->context, (int64_t)SYM2ID(r_key_sym));
+    ruby_data[1] = JS_NewBool(data->context, RTEST(rb_funcall(r_flags, rb_intern("include?"), 1, ID2SYM(rb_intern("async")))));
+
+    // Resolve the parent object to attach the function to.
+    // For a single-element array, parent is the global object.
+    // For multi-element arrays, traverse path[0..n-2] using JS_Eval for the first
+    // segment (so lexical const/let bindings are resolved, not just global properties)
+    // and JS_GetPropertyStr for subsequent segments.
+    JSValue j_parent;
+    if (path_len == 1)
+    {
+      j_parent = JS_GetGlobalObject(data->context);
+    }
+    else
+    {
+      VALUE r_first_str = rb_funcall(RARRAY_AREF(r_name, 0), rb_intern("to_s"), 0);
+      const char *first_seg = StringValueCStr(r_first_str);
+      j_parent = JS_Eval(data->context, first_seg, strlen(first_seg), "<vm>", JS_EVAL_TYPE_GLOBAL);
 
-  JSValue j_global = JS_GetGlobalObject(data->context);
-  JS_SetPropertyStr(
-      data->context, j_global, funcName,
-      JS_NewCFunctionData(data->context, js_quickjsrb_call_global, 1, 0, 2, ruby_data));
-  JS_FreeValue(data->context, j_global);
-  JS_FreeValue(data->context, ruby_data[0]);
-  JS_FreeValue(data->context, ruby_data[1]);
+      if (JS_IsException(j_parent) || !JS_IsObject(j_parent))
+      {
+        JS_FreeValue(data->context, j_parent);
+        JS_FreeValue(data->context, ruby_data[0]);
+        JS_FreeValue(data->context, ruby_data[1]);
+        rb_raise(rb_eArgError, "cannot define function: '%s' is not an object", first_seg);
+      }
+
+      for (long i = 1; i < path_len - 1; i++)
+      {
+        VALUE r_seg_str = rb_funcall(RARRAY_AREF(r_name, i), rb_intern("to_s"), 0);
+        JSValue j_next = JS_GetPropertyStr(data->context, j_parent, StringValueCStr(r_seg_str));
+        JS_FreeValue(data->context, j_parent);
+
+        if (JS_IsException(j_next) || !JS_IsObject(j_next))
+        {
+          JS_FreeValue(data->context, j_next);
+          JS_FreeValue(data->context, ruby_data[0]);
+          JS_FreeValue(data->context, ruby_data[1]);
+          rb_raise(rb_eArgError, "cannot define function: '%s' is not an object", StringValueCStr(r_seg_str));
+        }
+        j_parent = j_next;
+      }
+    }
+
+    JS_SetPropertyStr(
+        data->context, j_parent, funcName,
+        JS_NewCFunctionData(data->context, js_quickjsrb_call_global, 1, 0, 2, ruby_data));
+    JS_FreeValue(data->context, j_parent);
+    JS_FreeValue(data->context, ruby_data[0]);
+    JS_FreeValue(data->context, ruby_data[1]);
+
+    VALUE r_result = rb_ary_new();
+    for (long i = 0; i < path_len; i++)
+      rb_ary_push(r_result, rb_funcall(RARRAY_AREF(r_name, i), rb_intern("to_sym"), 0));
+    return r_result;
+  }
+  else if (SYMBOL_P(r_name) || RB_TYPE_P(r_name, T_STRING))
+  {
+    VALUE r_name_sym = rb_funcall(r_name, rb_intern("to_sym"), 0);
 
-  return r_name_sym;
+    rb_hash_aset(data->defined_functions, r_name_sym, r_block);
+    VALUE r_name_str = rb_funcall(r_name, rb_intern("to_s"), 0);
+    char *funcName = StringValueCStr(r_name_str);
+
+    JSValueConst ruby_data[2];
+    ruby_data[0] = JS_NewInt64(data->context, (int64_t)SYM2ID(r_name_sym));
+    ruby_data[1] = JS_NewBool(data->context, RTEST(rb_funcall(r_flags, rb_intern("include?"), 1, ID2SYM(rb_intern("async")))));
+
+    JSValue j_global = JS_GetGlobalObject(data->context);
+    JS_SetPropertyStr(
+        data->context, j_global, funcName,
+        JS_NewCFunctionData(data->context, js_quickjsrb_call_global, 1, 0, 2, ruby_data));
+    JS_FreeValue(data->context, j_global);
+    JS_FreeValue(data->context, ruby_data[0]);
+    JS_FreeValue(data->context, ruby_data[1]);
+
+    return r_name_sym;
+  }
+  else
+  {
+    rb_raise(rb_eTypeError, "function's name should be a Symbol or a String");
+  }
 }
 
 static VALUE vm_m_callGlobalFunction(int argc, VALUE *argv, VALUE r_self)
@@ -1006,7 +1215,7 @@ RUBY_FUNC_EXPORTED void Init_quickjsrb(void)
   VALUE r_class_vm = rb_define_class_under(r_module_quickjs, "VM", rb_cObject);
   rb_define_alloc_func(r_class_vm, vm_alloc);
   rb_define_method(r_class_vm, "initialize", vm_m_initialize, -1);
-  rb_define_method(r_class_vm, "eval_code", vm_m_evalCode, 1);
+  rb_define_method(r_class_vm, "eval_code", vm_m_evalCode, -1);
   rb_define_method(r_class_vm, "call", vm_m_callGlobalFunction, -1);
   rb_define_method(r_class_vm, "define_function", vm_m_defineGlobalFunction, -1);
   rb_define_method(r_class_vm, "import", vm_m_import, -1);

data/lib/quickjs/function.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Quickjs
+  class Function
+    def initialize(source)
+      @source = source
+    end
+
+    def source
+      @source
+    end
+
+    def call(*args, on: nil)
+      case on
+      when Quickjs::VM
+        _call_on(on, args)
+      when nil, Hash
+        vm = Quickjs::VM.new(**on || {})
+        res = _call_on(vm, args)
+        vm = nil
+        res
+      else
+        raise ArgumentError, 'on: must be a Quickjs::VM, a Hash of VM options, or nil'
+      end
+    end
+
+    private
+
+    def _call_on(vm, args)
+      args_js = args.map { |a| JSON.generate(a) }.join(', ')
+      vm.eval_code("(#{@source})(#{args_js})")
+    end
+  end
+end

data/lib/quickjs/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Quickjs
-  VERSION = "0.14.0"
+  VERSION = "0.15.1"
 end

data/lib/quickjs.rb

@@ -5,6 +5,7 @@ require "timeout"
 require_relative "quickjs/version"
 require_relative "quickjs/subtle_crypto"
 require_relative "quickjs/crypto_key"
+require_relative "quickjs/function"
 require_relative "quickjs/quickjsrb"
 
 module Quickjs
@@ -17,8 +18,10 @@ module Quickjs
   end
 
   def eval_code(code, overwrite_opts = {})
+    eval_opts = {}
+    eval_opts[:filename] = overwrite_opts.delete(:filename) if overwrite_opts.key?(:filename)
     vm = Quickjs::VM.new(**overwrite_opts)
-    res = vm.eval_code(code)
+    res = vm.eval_code(code, **eval_opts)
     vm = nil
     res
   end

data/polyfills/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "quickjs-rb-polyfills",
-  "version": "0.14.0",
+  "version": "0.15.1",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "quickjs-rb-polyfills",
-      "version": "0.14.0",
+      "version": "0.15.1",
       "dependencies": {
         "@formatjs/intl-datetimeformat": "^7.3.1",
         "@formatjs/intl-getcanonicallocales": "^3.2.2",

data/polyfills/package.json

@@ -1,6 +1,6 @@
 {
   "name": "quickjs-rb-polyfills",
-  "version": "0.14.0",
+  "version": "0.15.1",
   "private": true,
   "scripts": {
     "build": "rolldown -c rolldown.config.mjs",

data/sig/quickjs.rbs

@@ -21,11 +21,12 @@ module Quickjs
   class VM
     def initialize: (?features: Array[Symbol], ?memory_limit: Integer, ?max_stack_size: Integer, ?timeout_msec: Integer) -> void
 
-    def eval_code: (String code) -> untyped
+    def eval_code: (String code, ?filename: String) -> untyped
 
     def call: (String | Symbol name, *untyped args) -> untyped
 
     def define_function: (String | Symbol name, *Symbol flags) { (*untyped) -> untyped } -> Symbol
+                       | (Array[String | Symbol] path, *Symbol flags) { (*untyped) -> untyped } -> Array[Symbol]
 
     def import: (String | Array[String] | Hash[Symbol, String] imported, from: String, ?code_to_expose: String?) -> true
 
@@ -42,6 +43,14 @@ module Quickjs
     end
   end
 
+  class Function
+    def initialize: (String source) -> void
+
+    def source: () -> String
+
+    def call: (*untyped args, ?on: VM | Hash[Symbol, untyped] | nil) -> untyped
+  end
+
   class RuntimeError < ::RuntimeError
     def initialize: (String message, String? js_name) -> void
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: quickjs
 version: !ruby/object:Gem::Version
-  version: 0.14.0
+  version: 0.15.1
 platform: ruby
 authors:
 - hmsk
@@ -90,6 +90,7 @@ files:
 - ext/quickjsrb/vendor/polyfill-url.min.js
 - lib/quickjs.rb
 - lib/quickjs/crypto_key.rb
+- lib/quickjs/function.rb
 - lib/quickjs/subtle_crypto.rb
 - lib/quickjs/version.rb
 - polyfills/check-licenses.mjs