quickjs 0.3.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ecc8aa4eddd6aca97baf0e773c4880b4479b4ac4597e0edf811d256eeb61aeb9
-  data.tar.gz: 37c8eeef2cad6e0d7773e89759c7d2d1659219247883cfd1817f2603ffbf1543
+  metadata.gz: c3241377c00ffedb82e1752917d2a3bd6ac1fb667eebc30eb16b153c83119103
+  data.tar.gz: adc59082d4d1eb6cfbe662b88d3cbbee6deeb933c623964ccb139f1ae5b238c8
 SHA512:
-  metadata.gz: 2728bcbae59fae1138bdb5aef4e2f22290db93ce6c1e81f031e25c43108287a4f4d93d20afcfd9cb19a0e55593e1ccdadf1d83ebfbb430ee802368b73994cc2b
-  data.tar.gz: d06939ece851f9f4fb1311846826cad5c92e594511948ac9659bb190ebe6f905fdce15b4b9d16cf5df3b08bc5483a6f27d847f3ddf752aaa18bfcf74fec087e1
+  metadata.gz: b434d7100850f01b027d437800018a14eec3d97292d3553736baf43ede5714146eb56c81b060462bc6e49a21df90aa562638ee9dfe35c73fdd8d0046f2eb65e0
+  data.tar.gz: 7b37256b42f7d5a767cb8a048ae0d287dc8d7c6590bb2155d059f8a5fc674d08fda84d1242d7bcdc198367e0aef5d4699cab6ecb984dc28e430571da25fc8122

data/ext/quickjsrb/quickjsrb.c

@@ -87,6 +87,23 @@ JSValue to_js_value(JSContext *ctx, VALUE r_value)
   }
 }
 
+VALUE find_ruby_error(JSContext *ctx, JSValue j_error)
+{
+  JSValue j_errorOriginalRubyObjectId = JS_GetPropertyStr(ctx, j_error, "rb_object_id");
+  int errorOriginalRubyObjectId = 0;
+  if (JS_VALUE_GET_NORM_TAG(j_errorOriginalRubyObjectId) == JS_TAG_INT)
+  {
+    JS_ToInt32(ctx, &errorOriginalRubyObjectId, j_errorOriginalRubyObjectId);
+    JS_FreeValue(ctx, j_errorOriginalRubyObjectId);
+    if (errorOriginalRubyObjectId > 0)
+    {
+      // may be nice if cover the case of object is missing
+      return rb_funcall(rb_const_get(rb_cClass, rb_intern("ObjectSpace")), rb_intern("_id2ref"), 1, INT2NUM(errorOriginalRubyObjectId));
+    }
+  }
+  return Qnil;
+}
+
 VALUE r_try_json_parse(VALUE r_str)
 {
   return rb_funcall(rb_const_get(rb_cClass, rb_intern("JSON")), rb_intern("parse"), 1, r_str);
@@ -135,19 +152,12 @@ VALUE to_rb_value(JSContext *ctx, JSValue j_val)
 
     if (JS_IsError(ctx, j_val))
     {
-      JSValue j_errorOriginalRubyObjectId = JS_GetPropertyStr(ctx, j_val, "rb_object_id");
-      int errorOriginalRubyObjectId = 0;
-      if (JS_VALUE_GET_NORM_TAG(j_errorOriginalRubyObjectId) == JS_TAG_INT)
+      VALUE r_maybe_ruby_error = find_ruby_error(ctx, j_val);
+      if (!NIL_P(r_maybe_ruby_error))
       {
-        JS_ToInt32(ctx, &errorOriginalRubyObjectId, j_errorOriginalRubyObjectId);
-        JS_FreeValue(ctx, j_errorOriginalRubyObjectId);
-        if (errorOriginalRubyObjectId > 0)
-        {
-          // may be nice if cover the case of object is missing
-          return rb_funcall(rb_const_get(rb_cClass, rb_intern("ObjectSpace")), rb_intern("_id2ref"), 1, INT2NUM(errorOriginalRubyObjectId));
-        }
+        return r_maybe_ruby_error;
       }
-      // will support other errors
+      // will support other errors like just returning an instance of Error
     }
 
     JSValue j_global = JS_GetGlobalObject(ctx);
@@ -189,19 +199,12 @@ VALUE to_rb_value(JSContext *ctx, JSValue j_val)
     JSValue j_exceptionVal = JS_GetException(ctx);
     if (JS_IsError(ctx, j_exceptionVal))
     {
-      JSValue j_errorOriginalRubyObjectId = JS_GetPropertyStr(ctx, j_exceptionVal, "rb_object_id");
-      int errorOriginalRubyObjectId = 0;
-      if (JS_VALUE_GET_NORM_TAG(j_errorOriginalRubyObjectId) == JS_TAG_INT)
+      VALUE r_maybe_ruby_error = find_ruby_error(ctx, j_exceptionVal);
+      if (!NIL_P(r_maybe_ruby_error))
       {
-        JS_ToInt32(ctx, &errorOriginalRubyObjectId, j_errorOriginalRubyObjectId);
-        JS_FreeValue(ctx, j_errorOriginalRubyObjectId);
-        if (errorOriginalRubyObjectId > 0)
-        {
-          JS_FreeValue(ctx, j_exceptionVal);
-          // may be nice if cover the case of object is missing
-          rb_exc_raise(rb_funcall(rb_const_get(rb_cClass, rb_intern("ObjectSpace")), rb_intern("_id2ref"), 1, INT2NUM(errorOriginalRubyObjectId)));
-          return Qnil;
-        }
+        JS_FreeValue(ctx, j_exceptionVal);
+        rb_exc_raise(r_maybe_ruby_error);
+        return Qnil;
       }
 
       JSValue j_errorClassName = JS_GetPropertyStr(ctx, j_exceptionVal, "name");
@@ -210,8 +213,22 @@ VALUE to_rb_value(JSContext *ctx, JSValue j_val)
       JSValue j_errorClassMessage = JS_GetPropertyStr(ctx, j_exceptionVal, "message");
       const char *errorClassMessage = JS_ToCString(ctx, j_errorClassMessage);
 
+      JSValue j_stackTrace = JS_GetPropertyStr(ctx, j_exceptionVal, "stack");
+      const char *stackTrace = JS_ToCString(ctx, j_stackTrace);
+      const char *headlineTemplate = "Uncaught %s: %s\n%s";
+      int length = snprintf(NULL, 0, headlineTemplate, errorClassName, errorClassMessage, stackTrace);
+      char *headline = (char *)malloc(length + 1);
+      snprintf(headline, length + 1, headlineTemplate, errorClassName, errorClassMessage, stackTrace);
+
+      VMData *data = JS_GetContextOpaque(ctx);
+      VALUE r_headline = rb_str_new2(headline);
+      rb_ary_push(data->logs, r_log_new("error", rb_ary_new3(1, r_log_body_new(r_headline, r_headline))));
+
       JS_FreeValue(ctx, j_errorClassMessage);
       JS_FreeValue(ctx, j_errorClassName);
+      JS_FreeValue(ctx, j_stackTrace);
+      JS_FreeCString(ctx, stackTrace);
+      free(headline);
 
       VALUE r_error_class, r_error_message = rb_str_new2(errorClassMessage);
       if (is_native_error_name(errorClassName))
@@ -240,8 +257,18 @@ VALUE to_rb_value(JSContext *ctx, JSValue j_val)
     else // exception without Error object
     {
       const char *errorMessage = JS_ToCString(ctx, j_exceptionVal);
-      VALUE r_error_message = rb_sprintf("%s", errorMessage);
+      const char *headlineTemplate = "Uncaught '%s'";
+      int length = snprintf(NULL, 0, headlineTemplate, errorMessage);
+      char *headline = (char *)malloc(length + 1);
+      snprintf(headline, length + 1, headlineTemplate, errorMessage);
+
+      VMData *data = JS_GetContextOpaque(ctx);
+      VALUE r_headline = rb_str_new2(headline);
+      rb_ary_push(data->logs, r_log_new("error", rb_ary_new3(1, r_log_body_new(r_headline, r_headline))));
+
+      free(headline);
 
+      VALUE r_error_message = rb_sprintf("%s", errorMessage);
       JS_FreeCString(ctx, errorMessage);
       JS_FreeValue(ctx, j_exceptionVal);
       rb_exc_raise(rb_funcall(QUICKJSRB_ERROR_FOR(QUICKJSRB_ROOT_RUNTIME_ERROR), rb_intern("new"), 2, r_error_message, Qnil));
@@ -281,84 +308,117 @@ static VALUE r_try_call_proc(VALUE r_try_args)
   );
 }
 
-static JSValue js_quickjsrb_call_global(JSContext *ctx, JSValueConst _this, int _argc, JSValueConst *argv)
+static JSValue js_quickjsrb_call_global(JSContext *ctx, JSValueConst _this, int argc, JSValueConst *argv, int _magic, JSValue *func_data)
 {
-  VMData *data = JS_GetContextOpaque(ctx);
-  JSValue j_maybeFuncName = JS_ToString(ctx, argv[0]);
-  const char *funcName = JS_ToCString(ctx, j_maybeFuncName);
-  JS_FreeValue(ctx, j_maybeFuncName);
+  const char *funcName = JS_ToCString(ctx, func_data[0]);
 
+  VMData *data = JS_GetContextOpaque(ctx);
   VALUE r_proc = rb_hash_aref(data->defined_functions, rb_str_new2(funcName));
   if (r_proc == Qnil)
-  { // Shouldn't happen
-    return JS_ThrowReferenceError(ctx, "Proc `%s` is not defined", funcName);
+  {                                                                           // Shouldn't happen
+    return JS_ThrowReferenceError(ctx, "Proc `%s` is not defined", funcName); // TODO: Free funcnName
   }
+  JS_FreeCString(ctx, funcName);
 
   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]));
+
+  VALUE r_argv = rb_ary_new();
+  for (int i = 0; i < argc; i++)
+  {
+    rb_ary_push(r_argv, to_rb_value(ctx, argv[i]));
+  }
+  rb_ary_push(r_call_args, r_argv);
   rb_ary_push(r_call_args, ULONG2NUM(data->eval_time->limit * 1000 / CLOCKS_PER_SEC));
 
   int sadnessHappened;
-  VALUE r_result = rb_protect(r_try_call_proc, r_call_args, &sadnessHappened);
-  JSValue j_result;
-  if (sadnessHappened)
+
+  if (JS_ToBool(ctx, func_data[1]))
   {
-    VALUE r_error = rb_errinfo();
-    JSValue j_error = j_error_from_ruby_error(ctx, r_error);
-    return JS_Throw(ctx, j_error);
+    JSValue promise, resolving_funcs[2];
+    JSValue ret_val;
+
+    promise = JS_NewPromiseCapability(ctx, resolving_funcs);
+    if (JS_IsException(promise))
+      return JS_EXCEPTION;
+
+    // Currently, it's blocking process but should be asynchronized
+    JSValue j_result;
+    VALUE r_result = rb_protect(r_try_call_proc, r_call_args, &sadnessHappened);
+    if (sadnessHappened)
+    {
+      VALUE r_error = rb_errinfo();
+      j_result = j_error_from_ruby_error(ctx, r_error);
+      ret_val = JS_Call(ctx, resolving_funcs[1], JS_UNDEFINED,
+                        1, (JSValueConst *)&j_result);
+    }
+    else
+    {
+      j_result = to_js_value(ctx, r_result);
+      ret_val = JS_Call(ctx, resolving_funcs[0], JS_UNDEFINED,
+                        1, (JSValueConst *)&j_result);
+    }
+    JS_FreeValue(ctx, j_result);
+    JS_FreeValue(ctx, ret_val);
+    JS_FreeValue(ctx, resolving_funcs[0]);
+    JS_FreeValue(ctx, resolving_funcs[1]);
+    return promise;
   }
   else
   {
-    j_result = to_js_value(ctx, r_result);
+    VALUE r_result = rb_protect(r_try_call_proc, r_call_args, &sadnessHappened);
+    if (sadnessHappened)
+    {
+      VALUE r_error = rb_errinfo();
+      JSValue j_error = j_error_from_ruby_error(ctx, r_error);
+      return JS_Throw(ctx, j_error);
+    }
+    else
+    {
+      return 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)
+static JSValue js_quickjsrb_log(JSContext *ctx, JSValueConst _this, int argc, JSValueConst *argv, const char *severity)
 {
   VMData *data = JS_GetContextOpaque(ctx);
-  JSValue j_severity = JS_ToString(ctx, argv[0]);
-  const char *severity = JS_ToCString(ctx, j_severity);
-  JS_FreeValue(ctx, j_severity);
-
-  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;
-  JSValue j_length = JS_GetPropertyStr(ctx, argv[1], "length");
-  int count;
-  JS_ToInt32(ctx, &count, j_length);
-  JS_FreeValue(ctx, j_length);
-
-  for (i = 0; i < count; i++)
+  for (int i = 0; i < argc; 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));
-    }
+    JSValue j_logged = argv[i];
+    VALUE r_raw = JS_VALUE_GET_NORM_TAG(j_logged) == JS_TAG_OBJECT && JS_PromiseState(ctx, j_logged) != -1 ? rb_str_new2("Promise") : to_rb_value(ctx, j_logged);
     const char *body = JS_ToCString(ctx, j_logged);
-    JS_FreeValue(ctx, j_logged);
-    rb_hash_aset(r_loghash, ID2SYM(rb_intern("c")), rb_str_new2(body));
+    VALUE r_c = rb_str_new2(body);
     JS_FreeCString(ctx, body);
-    rb_ary_push(r_row, r_loghash);
+
+    rb_ary_push(r_row, r_log_body_new(r_raw, r_c));
   }
 
-  rb_iv_set(r_log, "@row", r_row);
-  rb_ary_push(data->logs, r_log);
+  rb_ary_push(data->logs, r_log_new(severity, r_row));
   return JS_UNDEFINED;
 }
 
+static JSValue js_console_info(JSContext *ctx, JSValueConst this, int argc, JSValueConst *argv)
+{
+  return js_quickjsrb_log(ctx, this, argc, argv, "info");
+}
+
+static JSValue js_console_verbose(JSContext *ctx, JSValueConst this, int argc, JSValueConst *argv)
+{
+  return js_quickjsrb_log(ctx, this, argc, argv, "verbose");
+}
+
+static JSValue js_console_warn(JSContext *ctx, JSValueConst this, int argc, JSValueConst *argv)
+{
+  return js_quickjsrb_log(ctx, this, argc, argv, "warning");
+}
+
+static JSValue js_console_error(JSContext *ctx, JSValueConst this, int argc, JSValueConst *argv)
+{
+  return js_quickjsrb_log(ctx, this, argc, argv, "error");
+}
+
 static VALUE vm_m_initialize(int argc, VALUE *argv, VALUE r_self)
 {
   VALUE r_opts;
@@ -430,29 +490,27 @@ static VALUE vm_m_initialize(int argc, VALUE *argv, VALUE r_self)
     JS_FreeValue(data->context, j_timeoutEval);
   }
 
-  JSValue j_global = JS_GetGlobalObject(data->context);
-  JSValue j_quickjsrbGlobal = JS_NewObject(data->context);
-  JS_SetPropertyStr(
-      data->context, j_quickjsrbGlobal, "runRubyMethod",
-      JS_NewCFunction(data->context, js_quickjsrb_call_global, "runRubyMethod", 2));
-
-  JS_SetPropertyStr(data->context, j_global, "__quickjsrb", j_quickjsrbGlobal);
-
   JSValue j_console = JS_NewObject(data->context);
   JS_SetPropertyStr(
-      data->context, j_quickjsrbGlobal, "log",
-      JS_NewCFunction(data->context, js_quickjsrb_log, "log", 2));
+      data->context, j_console, "log",
+      JS_NewCFunction(data->context, js_console_info, "log", 1));
+  JS_SetPropertyStr(
+      data->context, j_console, "debug",
+      JS_NewCFunction(data->context, js_console_verbose, "debug", 1));
+  JS_SetPropertyStr(
+      data->context, j_console, "info",
+      JS_NewCFunction(data->context, js_console_info, "info", 1));
+  JS_SetPropertyStr(
+      data->context, j_console, "warn",
+      JS_NewCFunction(data->context, js_console_warn, "warn", 1));
+  JS_SetPropertyStr(
+      data->context, j_console, "error",
+      JS_NewCFunction(data->context, js_console_error, "error", 1));
+
+  JSValue j_global = JS_GetGlobalObject(data->context);
   JS_SetPropertyStr(data->context, j_global, "console", j_console);
   JS_FreeValue(data->context, j_global);
 
-  const char *defineLoggers = "console.log = (...args) => __quickjsrb.log('info', args);\n"
-                              "console.debug = (...args) => __quickjsrb.log('verbose', args);\n"
-                              "console.info = (...args) => __quickjsrb.log('info', args);\n"
-                              "console.warn = (...args) => __quickjsrb.log('warning', args);\n"
-                              "console.error = (...args) => __quickjsrb.log('error', args);\n";
-  JSValue j_defineLoggers = JS_Eval(data->context, defineLoggers, strlen(defineLoggers), "<vm>", JS_EVAL_TYPE_GLOBAL);
-  JS_FreeValue(data->context, j_defineLoggers);
-
   return r_self;
 }
 
@@ -501,27 +559,23 @@ 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);
 
-  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);
 
   rb_hash_aset(data->defined_functions, r_name, r_block);
   char *funcName = StringValueCStr(r_name);
 
-  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);
+  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")))));
 
-  JSValue j_codeResult = JS_Eval(data->context, result, strlen(result), "<vm>", JS_EVAL_TYPE_MODULE);
+  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);
 
-  free(result);
-  JS_FreeValue(data->context, j_codeResult);
   return rb_funcall(r_name, rb_intern("to_sym"), 0, NULL);
-
-  return Qnil;
 }
 
 static VALUE vm_m_import(int argc, VALUE *argv, VALUE r_self)

data/ext/quickjsrb/quickjsrb.h

@@ -178,6 +178,23 @@ static VALUE r_define_log_class(VALUE r_parent_class)
   return r_log_class;
 }
 
+static VALUE r_log_new(const char *severity, VALUE r_row)
+{
+  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)));
+  rb_iv_set(r_log, "@row", r_row);
+  return r_log;
+}
+
+static VALUE r_log_body_new(VALUE r_raw, VALUE r_c)
+{
+  VALUE r_log_body = rb_hash_new();
+  rb_hash_aset(r_log_body, ID2SYM(rb_intern("raw")), r_raw);
+  rb_hash_aset(r_log_body, ID2SYM(rb_intern("c")), r_c);
+  return r_log_body;
+}
+
 // Exceptions
 
 #define QUICKJSRB_ROOT_RUNTIME_ERROR "RuntimeError"

data/lib/quickjs/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: quickjs
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.5.0
 platform: ruby
 authors:
 - hmsk
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-11-08 00:00:00.000000000 Z
+date: 2024-11-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json