provide setTimeout to use sleep by Ruby

Author: hmsk

ext/quickjsrb/quickjsrb.c

@@ -381,6 +381,37 @@ static JSValue js_quickjsrb_call_global(JSContext *ctx, JSValueConst _this, int
   }
 }
 
+static JSValue js_delay_and_eval_job(JSContext *ctx, int argc, JSValueConst *argv)
+{
+  VALUE rb_delay_msec = to_rb_value(ctx, argv[1]);
+  VALUE rb_delay_sec = rb_funcall(rb_delay_msec, rb_intern("/"), 1, rb_float_new(1000));
+  rb_thread_wait_for(rb_time_interval(rb_delay_sec));
+  JS_Call(ctx, argv[0], JS_UNDEFINED, 0, NULL);
+
+  return JS_UNDEFINED;
+}
+
+static JSValue js_quickjsrb_set_timeout(JSContext *ctx, JSValueConst _this, int argc, JSValueConst *argv)
+{
+  JSValueConst func;
+  int64_t delay;
+
+  func = argv[0];
+  if (!JS_IsFunction(ctx, func))
+    return JS_ThrowTypeError(ctx, "not a function");
+  if (JS_ToInt64(ctx, &delay, argv[1])) // TODO: should be lower than global timeout
+    return JS_EXCEPTION;
+
+  JSValueConst args[2];
+  args[0] = func;
+  args[1] = argv[1]; // delay
+  // TODO: implement timer manager and poll with quickjs' queue
+  // Currently, queueing multiple js_delay_and_eval_job is not parallelized
+  JS_EnqueueJob(ctx, js_delay_and_eval_job, 2, args);
+
+  return JS_UNDEFINED;
+}
+
 static JSValue js_quickjsrb_log(JSContext *ctx, JSValueConst _this, int argc, JSValueConst *argv, const char *severity)
 {
   VMData *data = JS_GetContextOpaque(ctx);
@@ -492,6 +523,8 @@ 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);
 
+  JSValue j_global = JS_GetGlobalObject(data->context);
+
   if (RTEST(rb_funcall(r_features, rb_intern("include?"), 1, QUICKJSRB_SYM(featureStdId))))
   {
     js_init_module_std(data->context, "std");
@@ -524,6 +557,12 @@ static VALUE vm_m_initialize(int argc, VALUE *argv, VALUE r_self)
     free(enableTimeout);
     JS_FreeValue(data->context, j_timeoutEval);
   }
+  else if (RTEST(rb_funcall(r_features, rb_intern("include?"), 1, QUICKJSRB_SYM(featureOsTimeoutBetaId))))
+  {
+    JS_SetPropertyStr(
+        data->context, j_global, "setTimeout",
+        JS_NewCFunction(data->context, js_quickjsrb_set_timeout, "setTimeout", 2));
+  }
 
   if (RTEST(rb_funcall(r_features, rb_intern("include?"), 1, QUICKJSRB_SYM(featurePolyfillIntlId))))
   {
@@ -553,7 +592,6 @@ static VALUE vm_m_initialize(int argc, VALUE *argv, VALUE r_self)
       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);
 

ext/quickjsrb/quickjsrb.h

@@ -18,6 +18,7 @@ extern const uint8_t qjsc_polyfill_intl_en_min;
 const char *featureStdId = "feature_std";
 const char *featureOsId = "feature_os";
 const char *featureOsTimeoutId = "feature_os_timeout";
+const char *featureOsTimeoutBetaId = "feature_os_timeout_beta";
 const char *featurePolyfillIntlId = "feature_polyfill_intl";
 
 const char *undefinedId = "undefined";
@@ -137,6 +138,7 @@ 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));
+  rb_define_const(r_parent_class, "FEATURES_TIMEOUT_BETA", QUICKJSRB_SYM(featureOsTimeoutBetaId));
   rb_define_const(r_parent_class, "POLYFILL_INTL", QUICKJSRB_SYM(featurePolyfillIntlId));
 
   VALUE rb_cQuickjsValue = rb_define_class_under(r_parent_class, "Value", rb_cObject);

test/blocking_test.rb

@@ -21,7 +21,7 @@ def refute_sleep_a_sec_within_thread(&block)
 
   class ProcessBlocking < QuickjsBlockingTest
     setup do
-      @vm = Quickjs::VM.new(timeout_msec: 1200, features: [::Quickjs::MODULE_OS])
+      @vm = Quickjs::VM.new(timeout_msec: 500, features: [::Quickjs::MODULE_OS])
     end
     teardown { @vm = nil }
 
@@ -69,4 +69,17 @@ class ProcessBlocking < QuickjsBlockingTest
       end
     end
   end
+
+  class RubyBasedTimeout < QuickjsBlockingTest
+    setup do
+      @vm = Quickjs::VM.new(timeout_msec: 500, features: [::Quickjs::FEATURES_TIMEOUT_BETA])
+    end
+    teardown { @vm = nil }
+
+    test 'awaiting setTimeout does not block other threads' do
+      assert_sleep_a_sec_within_thread do
+        @vm.eval_code('await new Promise(resolve => setTimeout(resolve, 100));')
+      end
+    end
+  end
 end