quickjs 0.2.1 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7afae8229fda495f4a4c40c5c3ec1527bbb5491f23cd46ac1cf7d94badaa6a8b
-  data.tar.gz: 62abbf8909cabf1e5d22b7228eda4fe3bd2193122573ad38b6491a7e60c142e2
+  metadata.gz: 5f57f31bd8921f897f9d1c81d1c50d24774bbfba5d31a99528b138e82d3fad58
+  data.tar.gz: 28216a7b1711fe08ad3e2a5b021abebaadd2b5d3808584ff259d0129abf0adf6
 SHA512:
-  metadata.gz: 6fad5187a6672299187de72faf8ccb3cc5402858c65a12edb808ae5759c1665ec90c75cbc34194b9d81e28c4ca5b8616de9174cbac060ba74da4509a28b21d85
-  data.tar.gz: dd8505b9ac5459fa2a2859cb1108b27861efcd59f234290ec43c4e2dc80e8ee61ea1ae34dba2f013036b495bcf6e9013f0fad0822a5249a43f7eba7cd3864251
+  metadata.gz: 355b53297b3c27269b71dca93e057ecfe02eac70755b5bd336b212092fb6da3c14ff3b2dd2f77214a62891b28d860e33f961329374ddef485e168dea41b50097
+  data.tar.gz: 7ff16986a8ef0efeff790389805fa6d36f6b03b5983e8f8131ff33f8369514344cc9f9b9f103f036ad305441e06dfdfdacd125bdb8b061967337235d4913c525

data/README.md

@@ -114,10 +114,21 @@ vm = Quickjs::VM.new(timeout_msec: 1_000)
 
 ```rb
 vm = Quickjs::VM.new
+
+# Equivalent to `import { default: aliasedDefault, member: member } from './exports.esm.js';`
 vm.import({ default: 'aliasedDefault', member: 'member' }, from: File.read('exports.esm.js'))
 
 vm.eval_code("aliasedDefault()") #=> Exported `default` of the ESM is called
 vm.eval_code("member()") #=> Exported `member` of the ESM is called
+
+# import { member, defaultMember } from './exports.esm.js';
+vm.import(['member', 'defaultMember'], from: File.read('exports.esm.js'))
+
+# import DefaultExport from './exports.esm.js';
+vm.import('DefaultExport', from: File.read('exports.esm.js'))
+
+# import * as all from './exports.esm.js';
+vm.import('* as all', from: File.read('exports.esm.js'))
 ```
 
 #### `Quickjs::VM#define_function`: 💎 Define a global function for JS by Ruby
@@ -131,6 +142,20 @@ end
 vm.eval_code("greetingTo('Rick')") #=> 'Hello! Rick'
 ```
 
+#### `Quickjs::VM#logs`: 💾 Capture console logs
+
+All logs by `console.(log|info|debug|warn|error)` on VM are recorded and inspectable.
+
+```rb
+vm = Quickjs::VM.new
+vm.eval_code('console.log("log me", null)')
+
+vm.logs #=> Array of Quickjs::VM::Log
+vm.logs.last.severity #=> :info
+vm.logs.last.to_s #=> 'log me null'
+vm,logs.last.raw #=> ['log me', nil]
+```
+
 ## License
 
 Every file in `ext/quickjsrb/quickjs` is licensed under [the MIT License Copyright 2017-2021 by Fabrice Bellard and Charlie Goron](/ext/quickjsrb/quickjs/LICENSE).

data/ext/quickjsrb/quickjs/qjs.c

@@ -34,7 +34,7 @@
 #include <time.h>
 #if defined(__APPLE__)
 #include <malloc/malloc.h>
-#elif defined(__linux__)
+#elif defined(__linux__) || defined(__GLIBC__)
 #include <malloc.h>
 #elif defined(__FreeBSD__)
 #include <malloc_np.h>
@@ -151,7 +151,7 @@ static size_t js_trace_malloc_usable_size(const void *ptr)
     return _msize((void *)ptr);
 #elif defined(EMSCRIPTEN)
     return 0;
-#elif defined(__linux__)
+#elif defined(__linux__) || defined(__GLIBC__)
     return malloc_usable_size((void *)ptr);
 #else
     /* change this to `return 0;` if compilation fails */

data/ext/quickjsrb/quickjs/quickjs-libc.c

@@ -78,6 +78,10 @@ typedef sig_t sighandler_t;
 #include "list.h"
 #include "quickjs-libc.h"
 
+#if !defined(PATH_MAX)
+#define PATH_MAX 4096
+#endif
+
 /* TODO:
    - add socket calls
 */
@@ -1090,7 +1094,7 @@ static JSValue js_std_file_tell(JSContext *ctx, JSValueConst this_val,
     int64_t pos;
     if (!f)
         return JS_EXCEPTION;
-#if defined(__linux__)
+#if defined(__linux__) || defined(__GLIBC__)
     pos = ftello(f);
 #else
     pos = ftell(f);
@@ -1113,7 +1117,7 @@ static JSValue js_std_file_seek(JSContext *ctx, JSValueConst this_val,
         return JS_EXCEPTION;
     if (JS_ToInt32(ctx, &whence, argv[1]))
         return JS_EXCEPTION;
-#if defined(__linux__)
+#if defined(__linux__) || defined(__GLIBC__)
     ret = fseeko(f, pos, whence);
 #else
     ret = fseek(f, pos, whence);

data/ext/quickjsrb/quickjs/quickjs.c

@@ -34,7 +34,7 @@
 #include <math.h>
 #if defined(__APPLE__)
 #include <malloc/malloc.h>
-#elif defined(__linux__)
+#elif defined(__linux__) || defined(__GLIBC__)
 #include <malloc.h>
 #elif defined(__FreeBSD__)
 #include <malloc_np.h>
@@ -1681,7 +1681,7 @@ JSRuntime *JS_NewRuntime2(const JSMallocFunctions *mf, void *opaque)
     rt->stack_size = JS_DEFAULT_STACK_SIZE;
     JS_UpdateStackTop(rt);
 
-    rt->current_exception = JS_NULL;
+    rt->current_exception = JS_UNINITIALIZED;
 
     return rt;
  fail:
@@ -1708,7 +1708,7 @@ static size_t js_def_malloc_usable_size(const void *ptr)
     return _msize((void *)ptr);
 #elif defined(EMSCRIPTEN)
     return 0;
-#elif defined(__linux__)
+#elif defined(__linux__) || defined(__GLIBC__)
     return malloc_usable_size((void *)ptr);
 #else
     /* change this to `return 0;` if compilation fails */
@@ -6398,13 +6398,13 @@ JSValue JS_GetException(JSContext *ctx)
     JSValue val;
     JSRuntime *rt = ctx->rt;
     val = rt->current_exception;
-    rt->current_exception = JS_NULL;
+    rt->current_exception = JS_UNINITIALIZED;
     return val;
 }
 
 JS_BOOL JS_HasException(JSContext *ctx)
 {
-    return !JS_IsNull(ctx->rt->current_exception);
+    return !JS_IsUninitialized(ctx->rt->current_exception);
 }
 
 static void dbuf_put_leb128(DynBuf *s, uint32_t v)
@@ -15321,7 +15321,7 @@ static int JS_IteratorClose(JSContext *ctx, JSValueConst enum_obj,
 
     if (is_exception_pending) {
         ex_obj = ctx->rt->current_exception;
-        ctx->rt->current_exception = JS_NULL;
+        ctx->rt->current_exception = JS_UNINITIALIZED;
         res = -1;
     } else {
         ex_obj = JS_UNDEFINED;
@@ -18674,7 +18674,7 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
                     JS_IteratorClose(ctx, sp[-1], TRUE);
                 } else {
                     *sp++ = rt->current_exception;
-                    rt->current_exception = JS_NULL;
+                    rt->current_exception = JS_UNINITIALIZED;
                     pc = b->byte_code_buf + pos;
                     goto restart;
                 }
@@ -46151,8 +46151,10 @@ static JSValue js_proxy_get(JSContext *ctx, JSValueConst obj, JSAtom atom,
     if (JS_IsException(ret))
         return JS_EXCEPTION;
     res = JS_GetOwnPropertyInternal(ctx, &desc, JS_VALUE_GET_OBJ(s->target), atom);
-    if (res < 0)
+    if (res < 0) {
+        JS_FreeValue(ctx, ret);
         return JS_EXCEPTION;
+    }
     if (res) {
         if ((desc.flags & (JS_PROP_GETSET | JS_PROP_CONFIGURABLE | JS_PROP_WRITABLE)) == 0) {
             if (!js_same_value(ctx, desc.value, ret)) {

data/ext/quickjsrb/quickjsrb.c

@@ -1,79 +1,5 @@
 #include "quickjsrb.h"
 
-typedef struct EvalTime
-{
-  clock_t limit;
-  clock_t started_at;
-} EvalTime;
-
-typedef struct VMData
-{
-  struct JSContext *context;
-  VALUE defined_functions;
-  struct EvalTime *eval_time;
-  VALUE logs;
-} VMData;
-
-static void vm_free(void *ptr)
-{
-  VMData *data = (VMData *)ptr;
-  free(data->eval_time);
-
-  JSRuntime *runtime = JS_GetRuntime(data->context);
-  JS_SetInterruptHandler(runtime, NULL, NULL);
-  js_std_free_handlers(runtime);
-  JS_FreeContext(data->context);
-  JS_FreeRuntime(runtime);
-
-  xfree(ptr);
-}
-
-size_t vm_size(const void *data)
-{
-  return sizeof(VMData);
-}
-
-static void vm_mark(void *ptr)
-{
-  VMData *data = (VMData *)ptr;
-  rb_gc_mark_movable(data->defined_functions);
-  rb_gc_mark_movable(data->logs);
-}
-
-static const rb_data_type_t vm_type = {
-    .wrap_struct_name = "quickjsvm",
-    .function = {
-        .dmark = vm_mark,
-        .dfree = vm_free,
-        .dsize = vm_size,
-    },
-    .flags = RUBY_TYPED_FREE_IMMEDIATELY,
-};
-
-static VALUE vm_alloc(VALUE r_self)
-{
-  VMData *data;
-  VALUE obj = TypedData_Make_Struct(r_self, VMData, &vm_type, data);
-  data->defined_functions = rb_hash_new();
-  data->logs = rb_ary_new();
-
-  EvalTime *eval_time = malloc(sizeof(EvalTime));
-  data->eval_time = eval_time;
-
-  JSRuntime *runtime = JS_NewRuntime();
-  data->context = JS_NewContext(runtime);
-
-  return obj;
-}
-
-VALUE rb_cQuickjsVMLog, rb_cQuickjsSyntaxError, rb_cQuickjsRuntimeError, rb_cQuickjsInterruptedError, rb_cQuickjsNoAwaitError, rb_cQuickjsTypeError, rb_cQuickjsReferenceError, rb_cQuickjsRangeError, rb_cQuickjsEvalError, rb_cQuickjsURIError, rb_cQuickjsAggregateError;
-const char *undefinedId = "undefined";
-const char *nanId = "NaN";
-
-const char *featureStdId = "feature_std";
-const char *featureOsId = "feature_os";
-const char *featureOsTimeoutId = "feature_os_timeout";
-
 JSValue to_js_value(JSContext *ctx, VALUE r_value)
 {
   if (RTEST(rb_funcall(
@@ -168,7 +94,7 @@ VALUE to_rb_value(JSContext *ctx, JSValue j_val)
   {
     if (JS_VALUE_IS_NAN(j_val))
     {
-      return ID2SYM(rb_intern(nanId));
+      return QUICKJSRB_SYM(nanId);
     }
     double double_res;
     JS_ToFloat64(ctx, &double_res, j_val);
@@ -191,7 +117,7 @@ VALUE to_rb_value(JSContext *ctx, JSValue j_val)
     if (promiseState != -1)
     {
       VALUE r_error_message = rb_str_new2("cannot translate a Promise to Ruby. await within JavaScript's end");
-      rb_exc_raise(rb_funcall(rb_cQuickjsRuntimeError, rb_intern("new"), 2, r_error_message, Qnil));
+      rb_exc_raise(rb_funcall(QUICKJSRB_ERROR_FOR(QUICKJSRB_ROOT_RUNTIME_ERROR), rb_intern("new"), 2, r_error_message, Qnil));
       return Qnil;
     }
 
@@ -204,17 +130,17 @@ VALUE to_rb_value(JSContext *ctx, JSValue j_val)
     VALUE r_str = rb_str_new2(msg);
     JS_FreeCString(ctx, msg);
 
-    JS_FreeValue(ctx, j_global);
     JS_FreeValue(ctx, j_strigified);
     JS_FreeValue(ctx, j_stringifyFunc);
     JS_FreeValue(ctx, j_jsonClass);
+    JS_FreeValue(ctx, j_global);
 
     return rb_funcall(rb_const_get(rb_cClass, rb_intern("JSON")), rb_intern("parse"), 1, r_str);
   }
   case JS_TAG_NULL:
     return Qnil;
   case JS_TAG_UNDEFINED:
-    return ID2SYM(rb_intern(undefinedId));
+    return QUICKJSRB_SYM(undefinedId);
   case JS_TAG_EXCEPTION:
   {
     JSValue j_exceptionVal = JS_GetException(ctx);
@@ -230,47 +156,27 @@ VALUE to_rb_value(JSContext *ctx, JSValue j_val)
       JS_FreeValue(ctx, j_errorClassName);
 
       VALUE r_error_class, r_error_message = rb_str_new2(errorClassMessage);
-
-      if (strcmp(errorClassName, "SyntaxError") == 0)
-      {
-        r_error_class = rb_cQuickjsSyntaxError;
-      }
-      else if (strcmp(errorClassName, "TypeError") == 0)
-      {
-        r_error_class = rb_cQuickjsTypeError;
-      }
-      else if (strcmp(errorClassName, "ReferenceError") == 0)
-      {
-        r_error_class = rb_cQuickjsReferenceError;
-      }
-      else if (strcmp(errorClassName, "RangeError") == 0)
-      {
-        r_error_class = rb_cQuickjsRangeError;
-      }
-      else if (strcmp(errorClassName, "EvalError") == 0)
-      {
-        r_error_class = rb_cQuickjsEvalError;
-      }
-      else if (strcmp(errorClassName, "URIError") == 0)
+      if (is_native_error_name(errorClassName))
       {
-        r_error_class = rb_cQuickjsURIError;
-      }
-      else if (strcmp(errorClassName, "AggregateError") == 0)
-      {
-        r_error_class = rb_cQuickjsAggregateError;
+        r_error_class = QUICKJSRB_ERROR_FOR(errorClassName);
       }
       else if (strcmp(errorClassName, "InternalError") == 0 && strstr(errorClassMessage, "interrupted") != NULL)
       {
-        r_error_class = rb_cQuickjsInterruptedError;
+        r_error_class = QUICKJSRB_ERROR_FOR(QUICKJSRB_INTERRUPTED_ERROR);
         r_error_message = rb_str_new2("Code evaluation is interrupted by the timeout or something");
       }
+      else if (strcmp(errorClassName, "InternalError") == 0 && strstr(errorClassMessage, "Ruby") != NULL)
+      {
+        r_error_class = QUICKJSRB_ERROR_FOR(QUICKJSRB_RUBY_FUNCTION_ERROR);
+      }
+
       else if (strcmp(errorClassName, "Quickjs::InterruptedError") == 0)
       {
-        r_error_class = rb_cQuickjsInterruptedError;
+        r_error_class = QUICKJSRB_ERROR_FOR(QUICKJSRB_INTERRUPTED_ERROR);
       }
       else
       {
-        r_error_class = rb_cQuickjsRuntimeError;
+        r_error_class = QUICKJSRB_ERROR_FOR(QUICKJSRB_ROOT_RUNTIME_ERROR);
       }
       JS_FreeCString(ctx, errorClassName);
       JS_FreeCString(ctx, errorClassMessage);
@@ -285,7 +191,7 @@ VALUE to_rb_value(JSContext *ctx, JSValue j_val)
 
       JS_FreeCString(ctx, errorMessage);
       JS_FreeValue(ctx, j_exceptionVal);
-      rb_exc_raise(rb_funcall(rb_cQuickjsRuntimeError, rb_intern("new"), 2, r_error_message, Qnil));
+      rb_exc_raise(rb_funcall(QUICKJSRB_ERROR_FOR(QUICKJSRB_ROOT_RUNTIME_ERROR), rb_intern("new"), 2, r_error_message, Qnil));
     }
     return Qnil;
   }
@@ -310,6 +216,18 @@ VALUE to_rb_value(JSContext *ctx, JSValue j_val)
   }
 }
 
+static VALUE r_try_call_proc(VALUE r_try_args)
+{
+  return rb_funcall(
+      rb_const_get(rb_cClass, rb_intern("Quickjs")),
+      rb_intern("_with_timeout"),
+      3,
+      RARRAY_AREF(r_try_args, 2), // timeout
+      RARRAY_AREF(r_try_args, 0), // proc
+      RARRAY_AREF(r_try_args, 1)  // args for proc
+  );
+}
+
 static JSValue js_quickjsrb_call_global(JSContext *ctx, JSValueConst _this, int _argc, JSValueConst *argv)
 {
   VMData *data = JS_GetContextOpaque(ctx);
@@ -322,17 +240,25 @@ static JSValue js_quickjsrb_call_global(JSContext *ctx, JSValueConst _this, int
   { // Shouldn't happen
     return JS_ThrowReferenceError(ctx, "Proc `%s` is not defined", funcName);
   }
-  JS_FreeCString(ctx, funcName);
 
-  VALUE r_result = rb_funcall(
-      rb_const_get(rb_cClass, rb_intern("Quickjs")),
-      rb_intern("_with_timeout"),
-      3,
-      ULONG2NUM(data->eval_time->limit * 1000 / CLOCKS_PER_SEC),
-      r_proc,
-      to_rb_value(ctx, argv[1]));
+  VALUE r_call_args = rb_ary_new();
+  rb_ary_push(r_call_args, r_proc);
+  rb_ary_push(r_call_args, to_rb_value(ctx, argv[1]));
+  rb_ary_push(r_call_args, ULONG2NUM(data->eval_time->limit * 1000 / CLOCKS_PER_SEC));
 
-  return to_js_value(ctx, r_result);
+  int sadnessHappened;
+  VALUE r_result = rb_protect(r_try_call_proc, r_call_args, &sadnessHappened);
+  JSValue j_result;
+  if (sadnessHappened)
+  {
+    j_result = JS_ThrowInternalError(ctx, "unintentional error is raised while executing the function by Ruby: `%s`", funcName);
+  }
+  else
+  {
+    j_result = to_js_value(ctx, r_result);
+  }
+  JS_FreeCString(ctx, funcName);
+  return j_result;
 }
 
 static JSValue js_quickjsrb_log(JSContext *ctx, JSValueConst _this, int _argc, JSValueConst *argv)
@@ -342,8 +268,10 @@ static JSValue js_quickjsrb_log(JSContext *ctx, JSValueConst _this, int _argc, J
   const char *severity = JS_ToCString(ctx, j_severity);
   JS_FreeValue(ctx, j_severity);
 
-  VALUE r_log = rb_funcall(rb_cQuickjsVMLog, rb_intern("new"), 0);
+  VALUE r_log_class = rb_const_get(rb_const_get(rb_const_get(rb_cClass, rb_intern("Quickjs")), rb_intern("VM")), rb_intern("Log"));
+  VALUE r_log = rb_funcall(r_log_class, rb_intern("new"), 0);
   rb_iv_set(r_log, "@severity", ID2SYM(rb_intern(severity)));
+  JS_FreeCString(ctx, severity);
 
   VALUE r_row = rb_ary_new();
   int i;
@@ -351,22 +279,28 @@ static JSValue js_quickjsrb_log(JSContext *ctx, JSValueConst _this, int _argc, J
   int count;
   JS_ToInt32(ctx, &count, j_length);
   JS_FreeValue(ctx, j_length);
+
   for (i = 0; i < count; i++)
   {
+    VALUE r_loghash = rb_hash_new();
     JSValue j_logged = JS_GetPropertyUint32(ctx, argv[1], i);
+    if (JS_VALUE_GET_NORM_TAG(j_logged) == JS_TAG_OBJECT && JS_PromiseState(ctx, j_logged) != -1)
+    {
+      rb_hash_aset(r_loghash, ID2SYM(rb_intern("raw")), rb_str_new2("Promise"));
+    }
+    else
+    {
+      rb_hash_aset(r_loghash, ID2SYM(rb_intern("raw")), to_rb_value(ctx, j_logged));
+    }
     const char *body = JS_ToCString(ctx, j_logged);
-    VALUE r_loghash = rb_hash_new();
-    rb_hash_aset(r_loghash, ID2SYM(rb_intern("c")), rb_str_new2(body));
-    rb_hash_aset(r_loghash, ID2SYM(rb_intern("raw")), to_rb_value(ctx, j_logged));
-    rb_ary_push(r_row, r_loghash);
     JS_FreeValue(ctx, j_logged);
+    rb_hash_aset(r_loghash, ID2SYM(rb_intern("c")), rb_str_new2(body));
     JS_FreeCString(ctx, body);
+    rb_ary_push(r_row, r_loghash);
   }
 
   rb_iv_set(r_log, "@row", r_row);
   rb_ary_push(data->logs, r_log);
-  JS_FreeCString(ctx, severity);
-
   return JS_UNDEFINED;
 }
 
@@ -408,7 +342,7 @@ static VALUE vm_m_initialize(int argc, VALUE *argv, VALUE r_self)
   JS_SetModuleLoaderFunc(runtime, NULL, js_module_loader, NULL);
   js_std_init_handlers(runtime);
 
-  if (RTEST(rb_funcall(r_features, rb_intern("include?"), 1, ID2SYM(rb_intern(featureStdId)))))
+  if (RTEST(rb_funcall(r_features, rb_intern("include?"), 1, QUICKJSRB_SYM(featureStdId))))
   {
     js_init_module_std(data->context, "std");
     const char *enableStd = "import * as std from 'std';\n"
@@ -417,7 +351,7 @@ static VALUE vm_m_initialize(int argc, VALUE *argv, VALUE r_self)
     JS_FreeValue(data->context, j_stdEval);
   }
 
-  if (RTEST(rb_funcall(r_features, rb_intern("include?"), 1, ID2SYM(rb_intern(featureOsId)))))
+  if (RTEST(rb_funcall(r_features, rb_intern("include?"), 1, QUICKJSRB_SYM(featureOsId))))
   {
     js_init_module_os(data->context, "os");
     const char *enableOs = "import * as os from 'os';\n"
@@ -425,13 +359,19 @@ static VALUE vm_m_initialize(int argc, VALUE *argv, VALUE r_self)
     JSValue j_osEval = JS_Eval(data->context, enableOs, strlen(enableOs), "<vm>", JS_EVAL_TYPE_MODULE);
     JS_FreeValue(data->context, j_osEval);
   }
-  else if (RTEST(rb_funcall(r_features, rb_intern("include?"), 1, ID2SYM(rb_intern(featureOsTimeoutId)))))
+  else if (RTEST(rb_funcall(r_features, rb_intern("include?"), 1, QUICKJSRB_SYM(featureOsTimeoutId))))
   {
-    js_init_module_os(data->context, "_os"); // Better if this is limited just only for setTimeout and clearTimeout
-    const char *enableTimeout = "import * as _os from '_os';\n"
-                                "globalThis.setTimeout = _os.setTimeout;\n"
-                                "globalThis.clearTimeout = _os.clearTimeout;\n";
+    char *filename = random_string();
+    js_init_module_os(data->context, filename); // Better if this is limited just only for setTimeout and clearTimeout
+    const char *enableTimeoutTemplate = "import * as _os from '%s';\n"
+                                        "globalThis.setTimeout = _os.setTimeout;\n"
+                                        "globalThis.clearTimeout = _os.clearTimeout;\n";
+    int length = snprintf(NULL, 0, enableTimeoutTemplate, filename);
+    char *enableTimeout = (char *)malloc(length + 1);
+    snprintf(enableTimeout, length + 1, enableTimeoutTemplate, filename);
+
     JSValue j_timeoutEval = JS_Eval(data->context, enableTimeout, strlen(enableTimeout), "<vm>", JS_EVAL_TYPE_MODULE);
+    free(enableTimeout);
     JS_FreeValue(data->context, j_timeoutEval);
   }
 
@@ -477,7 +417,7 @@ static VALUE vm_m_evalCode(VALUE r_self, VALUE r_code)
 
   char *code = StringValueCStr(r_code);
   JSValue j_codeResult = JS_Eval(data->context, code, strlen(code), "<code>", JS_EVAL_TYPE_GLOBAL | JS_EVAL_FLAG_ASYNC);
-  JSValue j_awaitedResult = js_std_await(data->context, j_codeResult);
+  JSValue j_awaitedResult = js_std_await(data->context, j_codeResult); // This frees j_codeResult
   JSValue j_returnedValue = JS_GetPropertyStr(data->context, j_awaitedResult, "value");
   // Do this by rescuing to_rb_value
   if (JS_VALUE_GET_NORM_TAG(j_returnedValue) == JS_TAG_OBJECT && JS_PromiseState(data->context, j_returnedValue) != -1)
@@ -485,7 +425,7 @@ static VALUE vm_m_evalCode(VALUE r_self, VALUE r_code)
     JS_FreeValue(data->context, j_returnedValue);
     JS_FreeValue(data->context, j_awaitedResult);
     VALUE r_error_message = rb_str_new2("An unawaited Promise was returned to the top-level");
-    rb_exc_raise(rb_funcall(rb_cQuickjsNoAwaitError, rb_intern("new"), 2, r_error_message, Qnil));
+    rb_exc_raise(rb_funcall(QUICKJSRB_ERROR_FOR(QUICKJSRB_NO_AWAIT_ERROR), rb_intern("new"), 2, r_error_message, Qnil));
     return Qnil;
   }
   else
@@ -497,30 +437,34 @@ static VALUE vm_m_evalCode(VALUE r_self, VALUE r_code)
   }
 }
 
-static VALUE vm_m_defineGlobalFunction(VALUE r_self, VALUE r_name)
+static VALUE vm_m_defineGlobalFunction(int argc, VALUE *argv, VALUE r_self)
 {
   rb_need_block();
 
+  VALUE r_name;
+  VALUE r_flags;
+  VALUE r_block;
+  rb_scan_args(argc, argv, "10*&", &r_name, &r_flags, &r_block);
+
+  const char *asyncKeyword =
+      RTEST(rb_funcall(r_flags, rb_intern("include?"), 1, ID2SYM(rb_intern("async")))) ? "async " : "";
+
   VMData *data;
   TypedData_Get_Struct(r_self, VMData, &vm_type, data);
 
-  if (rb_block_given_p())
-  {
-    VALUE r_proc = rb_block_proc();
-    rb_hash_aset(data->defined_functions, r_name, r_proc);
-    char *funcName = StringValueCStr(r_name);
+  rb_hash_aset(data->defined_functions, r_name, r_block);
+  char *funcName = StringValueCStr(r_name);
 
-    const char *template = "globalThis['%s'] = (...args) => __quickjsrb.runRubyMethod('%s', args);\n";
-    int length = snprintf(NULL, 0, template, funcName, funcName);
-    char *result = (char *)malloc(length + 1);
-    snprintf(result, length + 1, template, funcName, funcName);
+  const char *template = "globalThis['%s'] = %s(...args) => __quickjsrb.runRubyMethod('%s', args);\n";
+  int length = snprintf(NULL, 0, template, funcName, asyncKeyword, funcName);
+  char *result = (char *)malloc(length + 1);
+  snprintf(result, length + 1, template, funcName, asyncKeyword, funcName);
 
-    JSValue j_codeResult = JS_Eval(data->context, result, strlen(result), "<vm>", JS_EVAL_TYPE_MODULE);
+  JSValue j_codeResult = JS_Eval(data->context, result, strlen(result), "<vm>", JS_EVAL_TYPE_MODULE);
 
-    free(result);
-    JS_FreeValue(data->context, j_codeResult);
-    return rb_funcall(r_name, rb_intern("to_sym"), 0, NULL);
-  }
+  free(result);
+  JS_FreeValue(data->context, j_codeResult);
+  return rb_funcall(r_name, rb_intern("to_sym"), 0, NULL);
 
   return Qnil;
 }
@@ -535,15 +479,16 @@ static VALUE vm_m_import(int argc, VALUE *argv, VALUE r_self)
   if (NIL_P(r_from))
   {
     VALUE r_error_message = rb_str_new2("missing import source");
-    rb_exc_raise(rb_funcall(rb_cQuickjsRuntimeError, rb_intern("new"), 2, r_error_message, Qnil));
+    rb_exc_raise(rb_funcall(QUICKJSRB_ERROR_FOR(QUICKJSRB_ROOT_RUNTIME_ERROR), rb_intern("new"), 2, r_error_message, Qnil));
     return Qnil;
   }
 
   VMData *data;
   TypedData_Get_Struct(r_self, VMData, &vm_type, data);
 
+  char *filename = random_string();
   char *source = StringValueCStr(r_from);
-  JSValue func = JS_Eval(data->context, source, strlen(source), "mmmodule", JS_EVAL_TYPE_MODULE | JS_EVAL_FLAG_COMPILE_ONLY);
+  JSValue func = JS_Eval(data->context, source, strlen(source), filename, JS_EVAL_TYPE_MODULE | JS_EVAL_FLAG_COMPILE_ONLY);
   js_module_set_import_meta(data->context, func, TRUE, FALSE);
   JS_FreeValue(data->context, func);
 
@@ -557,11 +502,11 @@ static VALUE vm_m_import(int argc, VALUE *argv, VALUE r_self)
   VALUE r_globalize = rb_ary_entry(r_import_settings, 1);
   char *globalize = StringValueCStr(r_globalize);
 
-  const char *importAndGlobalizeModule = "import %s from 'mmmodule';\n"
+  const char *importAndGlobalizeModule = "import %s from '%s';\n"
                                          "%s\n";
-  int length = snprintf(NULL, 0, importAndGlobalizeModule, import_name, globalize);
+  int length = snprintf(NULL, 0, importAndGlobalizeModule, import_name, filename, globalize);
   char *result = (char *)malloc(length + 1);
-  snprintf(result, length + 1, importAndGlobalizeModule, import_name, globalize);
+  snprintf(result, length + 1, importAndGlobalizeModule, import_name, filename, globalize);
 
   JSValue j_codeResult = JS_Eval(data->context, result, strlen(result), "<vm>", JS_EVAL_TYPE_MODULE);
   free(result);
@@ -570,7 +515,7 @@ static VALUE vm_m_import(int argc, VALUE *argv, VALUE r_self)
   return Qtrue;
 }
 
-static VALUE vm_m_getLogs(VALUE r_self)
+static VALUE vm_m_logs(VALUE r_self)
 {
   VMData *data;
   TypedData_Get_Struct(r_self, VMData, &vm_type, data);
@@ -578,77 +523,21 @@ static VALUE vm_m_getLogs(VALUE r_self)
   return data->logs;
 }
 
-static VALUE pick_raw(VALUE block_arg, VALUE data, int argc, const VALUE *argv, VALUE blockarg)
-{
-  return rb_hash_aref(block_arg, ID2SYM(rb_intern("raw")));
-}
-
-static VALUE vm_m_raw(VALUE r_self)
-{
-  VALUE row = rb_iv_get(r_self, "@row");
-  VALUE r_ary = rb_block_call(row, rb_intern("map"), 0, NULL, pick_raw, Qnil);
-
-  return r_ary;
-}
-
-static VALUE pick_c(VALUE block_arg, VALUE data, int argc, const VALUE *argv, VALUE blockarg)
-{
-  return rb_hash_aref(block_arg, ID2SYM(rb_intern("c")));
-}
-
-static VALUE vm_m_to_s(VALUE r_self)
-{
-  VALUE row = rb_iv_get(r_self, "@row");
-  VALUE r_ary = rb_block_call(row, rb_intern("map"), 0, NULL, pick_c, Qnil);
-
-  return rb_funcall(r_ary, rb_intern("join"), 1, rb_str_new2(" "));
-}
-
-VALUE vm_m_initialize_quickjs_error(VALUE self, VALUE r_message, VALUE r_js_name)
-{
-  rb_call_super(1, &r_message);
-  rb_iv_set(self, "@js_name", r_js_name);
-
-  return self;
-}
-
 RUBY_FUNC_EXPORTED void Init_quickjsrb(void)
 {
-  VALUE rb_mQuickjs = rb_define_module("Quickjs");
-  rb_define_const(rb_mQuickjs, "MODULE_STD", ID2SYM(rb_intern(featureStdId)));
-  rb_define_const(rb_mQuickjs, "MODULE_OS", ID2SYM(rb_intern(featureOsId)));
-  rb_define_const(rb_mQuickjs, "FEATURES_TIMEOUT", ID2SYM(rb_intern(featureOsTimeoutId)));
-
-  VALUE rb_cQuickjsValue = rb_define_class_under(rb_mQuickjs, "Value", rb_cObject);
-  rb_define_const(rb_cQuickjsValue, "UNDEFINED", ID2SYM(rb_intern(undefinedId)));
-  rb_define_const(rb_cQuickjsValue, "NAN", ID2SYM(rb_intern(nanId)));
-
-  VALUE rb_cQuickjsVM = rb_define_class_under(rb_mQuickjs, "VM", rb_cObject);
-  rb_define_alloc_func(rb_cQuickjsVM, vm_alloc);
-  rb_define_method(rb_cQuickjsVM, "initialize", vm_m_initialize, -1);
-  rb_define_method(rb_cQuickjsVM, "eval_code", vm_m_evalCode, 1);
-  rb_define_method(rb_cQuickjsVM, "define_function", vm_m_defineGlobalFunction, 1);
-  rb_define_method(rb_cQuickjsVM, "import", vm_m_import, -1);
-  rb_define_method(rb_cQuickjsVM, "logs", vm_m_getLogs, 0);
-
-  rb_cQuickjsVMLog = rb_define_class_under(rb_cQuickjsVM, "Log", rb_cObject);
-  rb_define_attr(rb_cQuickjsVMLog, "severity", 1, 0);
-  rb_define_method(rb_cQuickjsVMLog, "raw", vm_m_raw, 0);
-  rb_define_method(rb_cQuickjsVMLog, "to_s", vm_m_to_s, 0);
-  rb_define_method(rb_cQuickjsVMLog, "inspect", vm_m_to_s, 0);
-
-  rb_cQuickjsRuntimeError = rb_define_class_under(rb_mQuickjs, "RuntimeError", rb_eRuntimeError);
-  rb_define_method(rb_cQuickjsRuntimeError, "initialize", vm_m_initialize_quickjs_error, 2);
-  rb_define_attr(rb_cQuickjsRuntimeError, "js_name", 1, 0);
-
-  rb_cQuickjsSyntaxError = rb_define_class_under(rb_mQuickjs, "SyntaxError", rb_cQuickjsRuntimeError);
-  rb_cQuickjsTypeError = rb_define_class_under(rb_mQuickjs, "TypeError", rb_cQuickjsRuntimeError);
-  rb_cQuickjsRangeError = rb_define_class_under(rb_mQuickjs, "RangeError", rb_cQuickjsRuntimeError);
-  rb_cQuickjsReferenceError = rb_define_class_under(rb_mQuickjs, "ReferenceError", rb_cQuickjsRuntimeError);
-  rb_cQuickjsURIError = rb_define_class_under(rb_mQuickjs, "URIError", rb_cQuickjsRuntimeError);
-  rb_cQuickjsEvalError = rb_define_class_under(rb_mQuickjs, "EvalError", rb_cQuickjsRuntimeError);
-  rb_cQuickjsAggregateError = rb_define_class_under(rb_mQuickjs, "AggregateError", rb_cQuickjsRuntimeError);
-
-  rb_cQuickjsInterruptedError = rb_define_class_under(rb_mQuickjs, "InterruptedError", rb_cQuickjsRuntimeError);
-  rb_cQuickjsNoAwaitError = rb_define_class_under(rb_mQuickjs, "NoAwaitError", rb_cQuickjsRuntimeError);
+  rb_require("json");
+  rb_require("securerandom");
+
+  VALUE r_module_quickjs = rb_define_module("Quickjs");
+  r_define_constants(r_module_quickjs);
+  r_define_exception_classes(r_module_quickjs);
+
+  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, "define_function", vm_m_defineGlobalFunction, -1);
+  rb_define_method(r_class_vm, "import", vm_m_import, -1);
+  rb_define_method(r_class_vm, "logs", vm_m_logs, 0);
+  r_define_log_class(r_class_vm);
 }

data/ext/quickjsrb/quickjsrb.h

@@ -12,4 +12,207 @@
 #include <string.h>
 #include <time.h>
 
+const char *featureStdId = "feature_std";
+const char *featureOsId = "feature_os";
+const char *featureOsTimeoutId = "feature_os_timeout";
+
+const char *undefinedId = "undefined";
+const char *nanId = "NaN";
+
+const char *native_errors[] = {
+    "SyntaxError",
+    "TypeError",
+    "ReferenceError",
+    "RangeError",
+    "EvalError",
+    "URIError",
+    "AggregateError"};
+
+#define QUICKJSRB_SYM(id) \
+  (VALUE) { ID2SYM(rb_intern(id)) }
+
+// VM data structure
+
+typedef struct EvalTime
+{
+  clock_t limit;
+  clock_t started_at;
+} EvalTime;
+
+typedef struct VMData
+{
+  struct JSContext *context;
+  VALUE defined_functions;
+  struct EvalTime *eval_time;
+  VALUE logs;
+} VMData;
+
+static void vm_free(void *ptr)
+{
+  VMData *data = (VMData *)ptr;
+  free(data->eval_time);
+
+  JSRuntime *runtime = JS_GetRuntime(data->context);
+  JS_SetInterruptHandler(runtime, NULL, NULL);
+  js_std_free_handlers(runtime);
+  JS_FreeContext(data->context);
+  JS_FreeRuntime(runtime);
+
+  xfree(ptr);
+}
+
+size_t vm_size(const void *data)
+{
+  return sizeof(VMData);
+}
+
+static void vm_mark(void *ptr)
+{
+  VMData *data = (VMData *)ptr;
+  rb_gc_mark_movable(data->defined_functions);
+  rb_gc_mark_movable(data->logs);
+}
+
+static const rb_data_type_t vm_type = {
+    .wrap_struct_name = "quickjsvm",
+    .function = {
+        .dmark = vm_mark,
+        .dfree = vm_free,
+        .dsize = vm_size,
+    },
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+static VALUE vm_alloc(VALUE r_self)
+{
+  VMData *data;
+  VALUE obj = TypedData_Make_Struct(r_self, VMData, &vm_type, data);
+  data->defined_functions = rb_hash_new();
+  data->logs = rb_ary_new();
+
+  EvalTime *eval_time = malloc(sizeof(EvalTime));
+  data->eval_time = eval_time;
+
+  JSRuntime *runtime = JS_NewRuntime();
+  data->context = JS_NewContext(runtime);
+
+  return obj;
+}
+
+// Utils
+
+static char *random_string()
+{
+  VALUE r_rand = rb_funcall(
+      rb_const_get(rb_cClass, rb_intern("SecureRandom")),
+      rb_intern("alphanumeric"),
+      1,
+      INT2NUM(12));
+  return StringValueCStr(r_rand);
+}
+
+static bool is_native_error_name(const char *error_name)
+{
+  bool is_native_error = false;
+  int numStrings = sizeof(native_errors) / sizeof(native_errors[0]);
+  for (int i = 0; i < numStrings; i++)
+  {
+    if (strcmp(native_errors[i], error_name) == 0)
+    {
+      is_native_error = true;
+      break;
+    }
+  }
+  return is_native_error;
+}
+
+// Constants
+
+static void r_define_constants(VALUE r_parent_class)
+{
+  rb_define_const(r_parent_class, "MODULE_STD", QUICKJSRB_SYM(featureStdId));
+  rb_define_const(r_parent_class, "MODULE_OS", QUICKJSRB_SYM(featureOsId));
+  rb_define_const(r_parent_class, "FEATURES_TIMEOUT", QUICKJSRB_SYM(featureOsTimeoutId));
+
+  VALUE rb_cQuickjsValue = rb_define_class_under(r_parent_class, "Value", rb_cObject);
+  rb_define_const(rb_cQuickjsValue, "UNDEFINED", QUICKJSRB_SYM(undefinedId));
+  rb_define_const(rb_cQuickjsValue, "NAN", QUICKJSRB_SYM(nanId));
+}
+
+// Log class
+
+static VALUE r_proc_pick_raw(VALUE block_arg, VALUE data, int argc, const VALUE *argv, VALUE blockarg)
+{
+  return rb_hash_aref(block_arg, ID2SYM(rb_intern("raw")));
+}
+
+static VALUE r_log_m_raw(VALUE r_self)
+{
+  VALUE row = rb_iv_get(r_self, "@row");
+  VALUE r_ary = rb_block_call(row, rb_intern("map"), 0, NULL, r_proc_pick_raw, Qnil);
+
+  return r_ary;
+}
+
+static VALUE r_proc_pick_c(VALUE block_arg, VALUE data, int argc, const VALUE *argv, VALUE blockarg)
+{
+  return rb_hash_aref(block_arg, ID2SYM(rb_intern("c")));
+}
+
+static VALUE r_log_m_to_s(VALUE r_self)
+{
+  VALUE row = rb_iv_get(r_self, "@row");
+  VALUE r_ary = rb_block_call(row, rb_intern("map"), 0, NULL, r_proc_pick_c, Qnil);
+
+  return rb_funcall(r_ary, rb_intern("join"), 1, rb_str_new2(" "));
+}
+
+static VALUE r_define_log_class(VALUE r_parent_class)
+{
+  VALUE r_log_class = rb_define_class_under(r_parent_class, "Log", rb_cObject);
+  rb_define_attr(r_log_class, "severity", 1, 0);
+  rb_define_method(r_log_class, "raw", r_log_m_raw, 0);
+  rb_define_method(r_log_class, "to_s", r_log_m_to_s, 0);
+  rb_define_method(r_log_class, "inspect", r_log_m_to_s, 0);
+
+  return r_log_class;
+}
+
+// Exceptions
+
+#define QUICKJSRB_ROOT_RUNTIME_ERROR "RuntimeError"
+#define QUICKJSRB_INTERRUPTED_ERROR "InterruptedError"
+#define QUICKJSRB_NO_AWAIT_ERROR "NoAwaitError"
+#define QUICKJSRB_RUBY_FUNCTION_ERROR "RubyFunctionError"
+
+#define QUICKJSRB_ERROR_FOR(name) \
+  (VALUE) { rb_const_get(rb_const_get(rb_cClass, rb_intern("Quickjs")), rb_intern(name)) }
+
+VALUE vm_m_initialize_quickjs_error(VALUE self, VALUE r_message, VALUE r_js_name)
+{
+  rb_call_super(1, &r_message);
+  rb_iv_set(self, "@js_name", r_js_name);
+
+  return self;
+}
+
+static void r_define_exception_classes(VALUE r_parent_class)
+{
+  VALUE r_runtime_error = rb_define_class_under(r_parent_class, QUICKJSRB_ROOT_RUNTIME_ERROR, rb_eRuntimeError);
+  rb_define_method(r_runtime_error, "initialize", vm_m_initialize_quickjs_error, 2);
+  rb_define_attr(r_runtime_error, "js_name", 1, 0);
+
+  // JS native errors
+  int numStrings = sizeof(native_errors) / sizeof(native_errors[0]);
+  for (int i = 0; i < numStrings; i++)
+  {
+    rb_define_class_under(r_parent_class, native_errors[i], r_runtime_error);
+  }
+
+  // quickjsrb specific errors
+  rb_define_class_under(r_parent_class, QUICKJSRB_INTERRUPTED_ERROR, r_runtime_error);
+  rb_define_class_under(r_parent_class, QUICKJSRB_NO_AWAIT_ERROR, r_runtime_error);
+  rb_define_class_under(r_parent_class, QUICKJSRB_RUBY_FUNCTION_ERROR, r_runtime_error);
+}
+
 #endif /* QUICKJSRB_H */

data/lib/quickjs/version.rb

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

data/lib/quickjs.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "timeout"
-require "json"
 require_relative "quickjs/version"
 require_relative "quickjs/quickjsrb"
 
@@ -18,8 +17,8 @@ module Quickjs
     Timeout.timeout(msec / 1_000.0) { proc.call(*args) }
   rescue Timeout::Error
     Quickjs::InterruptedError.new('Ruby runtime got timeout', nil)
-  rescue => e
-    e
+  rescue
+    raise
   end
   module_function :_with_timeout
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: quickjs
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.2.3
 platform: ruby
 authors:
 - hmsk
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-10-15 00:00:00.000000000 Z
+date: 2024-10-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -24,6 +24,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: securerandom
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: A native wrapper to run QuickJS in Ruby
 email:
 - k.hamasaki@gmail.com