quickjs 0.2.3 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5f57f31bd8921f897f9d1c81d1c50d24774bbfba5d31a99528b138e82d3fad58
-  data.tar.gz: 28216a7b1711fe08ad3e2a5b021abebaadd2b5d3808584ff259d0129abf0adf6
+  metadata.gz: 49e231625e712ca98ffcab031b747d11392608eb840b2cafa6881173a5be9ac8
+  data.tar.gz: '099960b9c78f6f7a75990386186a0b149102d73ccbbbb7a1db7e52e120c57833'
 SHA512:
-  metadata.gz: 355b53297b3c27269b71dca93e057ecfe02eac70755b5bd336b212092fb6da3c14ff3b2dd2f77214a62891b28d860e33f961329374ddef485e168dea41b50097
-  data.tar.gz: 7ff16986a8ef0efeff790389805fa6d36f6b03b5983e8f8131ff33f8369514344cc9f9b9f103f036ad305441e06dfdfdacd125bdb8b061967337235d4913c525
+  metadata.gz: 3cad539bfe3b3a7e254ef4c1a2919c7a12afd29e67e5729acc2f8356896898eef71f1f46c35a62e351b1ac03ba0b8e9fe357c4f69781d5b8a203525068e22261
+  data.tar.gz: d4fcdfe872d91b0fd86bcccd9e58262b233ee99d31a529ba288583e2953ea191f4b9269dacbac9a47256f5d2111f737741fce4d5d26cba5e4fcc97bc450be96b

data/ext/quickjsrb/quickjsrb.c

@@ -1,22 +1,22 @@
 #include "quickjsrb.h"
 
-JSValue to_js_value(JSContext *ctx, VALUE r_value)
+JSValue j_error_from_ruby_error(JSContext *ctx, VALUE r_error)
 {
-  if (RTEST(rb_funcall(
-          r_value,
-          rb_intern("is_a?"),
-          1, rb_const_get(rb_cClass, rb_intern("Exception")))))
-  {
-    JSValue j_error = JS_NewError(ctx);
-    VALUE r_str = rb_funcall(r_value, rb_intern("message"), 0, NULL);
-    char *exceptionMessage = StringValueCStr(r_str);
-    VALUE r_exception_name = rb_funcall(rb_funcall(r_value, rb_intern("class"), 0, NULL), rb_intern("name"), 0, NULL);
-    char *exceptionName = StringValueCStr(r_exception_name);
-    JS_SetPropertyStr(ctx, j_error, "name", JS_NewString(ctx, exceptionName));
-    JS_SetPropertyStr(ctx, j_error, "message", JS_NewString(ctx, exceptionMessage));
-    return JS_Throw(ctx, j_error);
-  }
+  JSValue j_error = JS_NewError(ctx); // may wanna have custom error class to determine in JS' end
 
+  VALUE r_object_id = rb_funcall(r_error, rb_intern("object_id"), 0, NULL);
+  int objectId = NUM2INT(r_object_id);
+  JS_SetPropertyStr(ctx, j_error, "rb_object_id", JS_NewInt32(ctx, objectId));
+
+  VALUE r_exception_message = rb_funcall(r_error, rb_intern("message"), 0, NULL);
+  const char *errorMessage = StringValueCStr(r_exception_message);
+  JS_SetPropertyStr(ctx, j_error, "message", JS_NewString(ctx, errorMessage));
+
+  return j_error;
+}
+
+JSValue to_js_value(JSContext *ctx, VALUE r_value)
+{
   switch (TYPE(r_value))
   {
   case T_NIL:
@@ -72,6 +72,13 @@ JSValue to_js_value(JSContext *ctx, VALUE r_value)
   }
   default:
   {
+    if (TYPE(r_value) == T_OBJECT && RTEST(rb_funcall(
+                                         r_value,
+                                         rb_intern("is_a?"),
+                                         1, rb_const_get(rb_cClass, rb_intern("Exception")))))
+    {
+      return j_error_from_ruby_error(ctx, r_value);
+    }
     VALUE r_inspect_str = rb_funcall(r_value, rb_intern("inspect"), 0, NULL);
     char *str = StringValueCStr(r_inspect_str);
 
@@ -80,6 +87,28 @@ 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);
+}
+
 VALUE to_rb_value(JSContext *ctx, JSValue j_val)
 {
   switch (JS_VALUE_GET_NORM_TAG(j_val))
@@ -121,6 +150,16 @@ VALUE to_rb_value(JSContext *ctx, JSValue j_val)
       return Qnil;
     }
 
+    if (JS_IsError(ctx, j_val))
+    {
+      VALUE r_maybe_ruby_error = find_ruby_error(ctx, j_val);
+      if (!NIL_P(r_maybe_ruby_error))
+      {
+        return r_maybe_ruby_error;
+      }
+      // will support other errors like just returning an instance of Error
+    }
+
     JSValue j_global = JS_GetGlobalObject(ctx);
     JSValue j_jsonClass = JS_GetPropertyStr(ctx, j_global, "JSON");
     JSValue j_stringifyFunc = JS_GetPropertyStr(ctx, j_jsonClass, "stringify");
@@ -135,7 +174,21 @@ VALUE to_rb_value(JSContext *ctx, JSValue j_val)
     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);
+    if (rb_funcall(r_str, rb_intern("=="), 1, rb_str_new2("undefined")))
+    {
+      return QUICKJSRB_SYM(undefinedId);
+    }
+
+    int couldntParse;
+    VALUE r_result = rb_protect(r_try_json_parse, r_str, &couldntParse);
+    if (couldntParse)
+    {
+      return Qnil;
+    }
+    else
+    {
+      return r_result;
+    }
   }
   case JS_TAG_NULL:
     return Qnil;
@@ -146,14 +199,44 @@ VALUE to_rb_value(JSContext *ctx, JSValue j_val)
     JSValue j_exceptionVal = JS_GetException(ctx);
     if (JS_IsError(ctx, j_exceptionVal))
     {
+      VALUE r_maybe_ruby_error = find_ruby_error(ctx, j_exceptionVal);
+      if (!NIL_P(r_maybe_ruby_error))
+      {
+        JS_FreeValue(ctx, j_exceptionVal);
+        rb_exc_raise(r_maybe_ruby_error);
+        return Qnil;
+      }
+
       JSValue j_errorClassName = JS_GetPropertyStr(ctx, j_exceptionVal, "name");
       const char *errorClassName = JS_ToCString(ctx, j_errorClassName);
 
       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_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("error")));
+      VALUE r_row = rb_ary_new();
+      VALUE r_loghash = rb_hash_new();
+      rb_hash_aset(r_loghash, ID2SYM(rb_intern("raw")), rb_str_new2(headline));
+      rb_hash_aset(r_loghash, ID2SYM(rb_intern("c")), rb_str_new2(headline));
+      rb_ary_push(r_row, r_loghash);
+      rb_iv_set(r_log, "@row", r_row);
+      rb_ary_push(data->logs, r_log);
+
       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))
@@ -165,11 +248,6 @@ VALUE to_rb_value(JSContext *ctx, JSValue j_val)
         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 = QUICKJSRB_ERROR_FOR(QUICKJSRB_INTERRUPTED_ERROR);
@@ -187,8 +265,26 @@ 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_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("error")));
+      VALUE r_row = rb_ary_new();
+      VALUE r_loghash = rb_hash_new();
+      rb_hash_aset(r_loghash, ID2SYM(rb_intern("raw")), rb_str_new2(headline));
+      rb_hash_aset(r_loghash, ID2SYM(rb_intern("c")), rb_str_new2(headline));
+      rb_ary_push(r_row, r_loghash);
+      rb_iv_set(r_log, "@row", r_row);
+      rb_ary_push(data->logs, r_log);
+
+      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));
@@ -251,7 +347,9 @@ static JSValue js_quickjsrb_call_global(JSContext *ctx, JSValueConst _this, int
   JSValue j_result;
   if (sadnessHappened)
   {
-    j_result = JS_ThrowInternalError(ctx, "unintentional error is raised while executing the function by Ruby: `%s`", funcName);
+    VALUE r_error = rb_errinfo();
+    JSValue j_error = j_error_from_ruby_error(ctx, r_error);
+    return JS_Throw(ctx, j_error);
   }
   else
   {
@@ -475,13 +573,14 @@ 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"))); // TODO: Use kwargs instead
+  VALUE r_from = rb_hash_aref(r_opts, ID2SYM(rb_intern("from")));
   if (NIL_P(r_from))
   {
     VALUE r_error_message = rb_str_new2("missing import source");
     rb_exc_raise(rb_funcall(QUICKJSRB_ERROR_FOR(QUICKJSRB_ROOT_RUNTIME_ERROR), rb_intern("new"), 2, r_error_message, Qnil));
     return Qnil;
   }
+  VALUE r_custom_exposure = rb_hash_aref(r_opts, ID2SYM(rb_intern("code_to_expose")));
 
   VMData *data;
   TypedData_Get_Struct(r_self, VMData, &vm_type, data);
@@ -499,8 +598,16 @@ static VALUE vm_m_import(int argc, VALUE *argv, VALUE r_self)
       r_import_string);
   VALUE r_import_name = rb_ary_entry(r_import_settings, 0);
   char *import_name = StringValueCStr(r_import_name);
-  VALUE r_globalize = rb_ary_entry(r_import_settings, 1);
-  char *globalize = StringValueCStr(r_globalize);
+  VALUE r_default_exposure = rb_ary_entry(r_import_settings, 1);
+  char *globalize;
+  if (RTEST(r_custom_exposure))
+  {
+    globalize = StringValueCStr(r_custom_exposure);
+  }
+  else
+  {
+    globalize = StringValueCStr(r_default_exposure);
+  }
 
   const char *importAndGlobalizeModule = "import %s from '%s';\n"
                                          "%s\n";

data/ext/quickjsrb/quickjsrb.h

@@ -183,7 +183,6 @@ static VALUE r_define_log_class(VALUE r_parent_class)
 #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)) }
@@ -212,7 +211,6 @@ static void r_define_exception_classes(VALUE r_parent_class)
   // 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.3"
+  VERSION = "0.4.0"
 end

data/lib/quickjs.rb

@@ -16,7 +16,7 @@ module Quickjs
   def _with_timeout(msec, proc, args)
     Timeout.timeout(msec / 1_000.0) { proc.call(*args) }
   rescue Timeout::Error
-    Quickjs::InterruptedError.new('Ruby runtime got timeout', nil)
+    raise Quickjs::InterruptedError.new('Ruby runtime got timeout', nil)
   rescue
     raise
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: quickjs
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.4.0
 platform: ruby
 authors:
 - hmsk
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-10-31 00:00:00.000000000 Z
+date: 2024-11-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json