quickjs 0.2.0 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 30027c93cb2dd5dbb85d43ab40700f7ee06679a824b503bee42786a42bc5dc26
-  data.tar.gz: 51c60a962c82bbbbaa3a3fc4202255809751848d1474f9a4e9f6b7ebe4df0277
+  metadata.gz: 0c2a481a2ea280bc0d4a9c7778b62035991bd08293ddef98b4824a40a6a6ccd9
+  data.tar.gz: a40b2f11813f2f82db4c5b9e0931199013671e0983e80566f0b6645709deece7
 SHA512:
-  metadata.gz: e1f248cbafcc56ceba481f658aae542660ac8de6036b7fc1e9425e5f214f4f51a918a3051b82e796a075ed83726f59ba6b8dcc85e8b1c38ee1369b089ebd410a
-  data.tar.gz: 7c7346da3a318d3ed07bfd490561ced7deda800678bda0cb23c4f2b19b84b9720191a7999a7d9a5225d91d4c2140b7fffae03f16d75b791cd4d3b746bbab50a9
+  metadata.gz: f509a918c4e5ff7d19bdaa8873ee62ede64cfd98e405a7ea6f4eb00a724fc79fc2cd928e2388d0f8e07dcd455834ba1f60ec2a9990b4781bd0012ec5f72a9c16
+  data.tar.gz: b7604b888bc62fe12f6a5b30387891108a24cf1de55e77934cabeeab20fe9ae27f494098448a32a975e9fde99cee9a9af5bdd58c258a0bafb60adc125cedf206

data/README.md

@@ -36,7 +36,10 @@ Quickjs.eval_code('const obj = {}; obj.missingKey;') # => :undefined (Quickjs::V
 Quickjs.eval_code("Number('whatever')") #=> :NaN (Quickjs::Value::NAN)
 ```
 
-#### Limit resources
+<details>
+<summary>Options</summary>
+
+#### Resources
 
 ```rb
 # 1GB memory limit
@@ -46,20 +49,21 @@ Quickjs.eval_code(code, { memory_limit: 1024 ** 3 })
 Quickjs.eval_code(code, { max_stack_size: 1024 ** 2 })
 ```
 
-#### Enable built-in modules
+#### Built-in modules
+
+To enable [std module](https://bellard.org/quickjs/quickjs.html#std-module) and [os module](https://bellard.org/quickjs/quickjs.html#os-module) selectively.
 
 ```rb
 # enable std module
-# https://bellard.org/quickjs/quickjs.html#std-module
 Quickjs.eval_code(code, { features: [Quickjs::MODULE_STD] })
 
 # enable os module
-# https://bellard.org/quickjs/quickjs.html#os-module
 Quickjs.eval_code(code, { features: [Quickjs::MODULE_OS] })
 
-# enable timeout features `setTimeout`, `clearTimeout`
+# enable timeout features `setTimeout`, `clearTimeout` from os module specifically
 Quickjs.eval_code(code, { features: [Quickjs::FEATURES_TIMEOUT] })
 ```
+</details>
 
 ### `Quickjs::VM`: Maintain a consistent VM/runtime
 
@@ -71,7 +75,10 @@ vm.eval_code('a.b = "d";')
 vm.eval_code('a.b;') #=> "d"
 ```
 
-#### Config VM
+<details>
+<summary>Config VM/runtime</summary>
+
+#### Resources
 
 ```rb
 vm = Quickjs::VM.new(
@@ -80,41 +87,51 @@ vm = Quickjs::VM.new(
 )
 ```
 
+#### Built-in modules
+
+To enable [std module](https://bellard.org/quickjs/quickjs.html#std-module) and [os module](https://bellard.org/quickjs/quickjs.html#os-module) selectively.
+
 ```rb
 # enable std module
-# https://bellard.org/quickjs/quickjs.html#std-module
-vm = Quickjs::VM.new(
-  features: [::Quickjs::MODULE_STD],
-)
+vm = Quickjs::VM.new(features: [::Quickjs::MODULE_STD])
 
 # enable os module
-# https://bellard.org/quickjs/quickjs.html#os-module
-vm = Quickjs::VM.new(
-  features: [::Quickjs::MODULE_OS],
-)
-
-# `eval_code` will be interrupted after 1 sec (default: 100 msec)
-vm = Quickjs::VM.new(
-  timeout_msec: 1_000,
-)
+vm = Quickjs::VM.new(features: [::Quickjs::MODULE_OS])
 
 # enable timeout features `setTimeout`, `clearTimeout`
-vm = Quickjs::VM.new(
-  features: [::Quickjs::FEATURES_TIMEOUT],
-)
+vm = Quickjs::VM.new(features: [::Quickjs::FEATURES_TIMEOUT])
 ```
 
-#### ⚡️ Import ESM from source
+#### VM timeout
+
+```rb
+# `eval_code` will be interrupted after 1 sec (default: 100 msec)
+vm = Quickjs::VM.new(timeout_msec: 1_000)
+```
+</details>
+
+#### `Quickjs::VM#import`: 🔌 Import ESM from a source code
 
 ```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'))
 ```
 
-#### ⚡️ Define a global function for JS by Ruby
+#### `Quickjs::VM#define_function`: 💎 Define a global function for JS by Ruby
 
 ```rb
 vm = Quickjs::VM.new
@@ -125,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,22 @@ 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)
+      if (is_native_error_name(errorClassName))
       {
-        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)
-      {
-        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, "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 +186,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;
   }
@@ -342,8 +243,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 +254,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 +317,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 +326,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 +334,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 +392,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 +400,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
@@ -531,19 +446,20 @@ static VALUE vm_m_import(int argc, VALUE *argv, VALUE r_self)
   rb_scan_args(argc, argv, "10:", &r_import_string, &r_opts);
   if (NIL_P(r_opts))
     r_opts = rb_hash_new();
-  VALUE r_from = rb_hash_aref(r_opts, ID2SYM(rb_intern("from")));
+  VALUE r_from = rb_hash_aref(r_opts, ID2SYM(rb_intern("from"))); // TODO: Use kwargs instead
   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 +473,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 +486,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 +494,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,205 @@
 #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_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);
+}
+
 #endif /* QUICKJSRB_H */

data/lib/quickjs/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Quickjs
-  VERSION = "0.2.0"
+  VERSION = "0.2.2"
 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"
 
@@ -23,15 +22,30 @@ module Quickjs
   end
   module_function :_with_timeout
 
-  def _build_import(mappings)
-    imports, aliases = mappings.to_a.map do |imp|
-      ["#{imp[0]} as #{imp[1]}", imp[1].to_s]
-    end.transpose
+  def _build_import(imported)
+    code_define_global = ->(name) { "globalThis['#{name}'] = #{name};" }
+    case imported
+    in String if matched = imported.match(/\* as (.+)/)
+      [imported, code_define_global.call(matched[1])]
+    in String
+      [imported, code_define_global.call(imported)]
+    in [*all] if all.all? {|e| e.is_a? String }
+      [
+        imported.join(', ').yield_self{|s| '{ %s }' % s },
+        imported.map(&code_define_global).join("\n")
+      ]
+    in { ** }
+      imports, aliases = imported.to_a.map do |imp|
+        ["#{imp[0]} as #{imp[1]}", imp[1].to_s]
+      end.transpose
 
-    [
-      imports.join(", ").yield_self{|s| '{ %s }' % s },
-      aliases.map {|name| "globalThis['#{name}'] = #{name};"}.join("\n")
-    ]
+      [
+        imports.join(', ').yield_self{|s| '{ %s }' % s },
+        aliases.map(&code_define_global).join("\n")
+      ]
+    else
+      raise 'Unsupported importing style'
+    end
   end
   module_function :_build_import
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: quickjs
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.2
 platform: ruby
 authors:
 - hmsk
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-10-14 00:00:00.000000000 Z
+date: 2024-10-29 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