quickjs 0.1.13 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 12a5b713531ad393cb5d16486516f3288eb2b9c88931b8db5fa440a4701393df
-  data.tar.gz: c780fe075e29223e90a4f0183b02506ed2209ed2f17dd33e9e734e753a9b0b3d
+  metadata.gz: 7afae8229fda495f4a4c40c5c3ec1527bbb5491f23cd46ac1cf7d94badaa6a8b
+  data.tar.gz: 62abbf8909cabf1e5d22b7228eda4fe3bd2193122573ad38b6491a7e60c142e2
 SHA512:
-  metadata.gz: 524a227ede71099f8da470ae3178df0c63fab2613cb3e9a37ec0215d462dab2fbbb52f69449273cf58ffc58758dbab8743be624c75ce0818335e86b312e49bda
-  data.tar.gz: 9602f54b31a71163ce054aaad3b6da4b5e00d1866b63e98617971d3279ba3a5cef9c8aa2ade1e130dd4499c121c62cc94a8a48dc3eba92a8eaf7bd1a2093ef56
+  metadata.gz: 6fad5187a6672299187de72faf8ccb3cc5402858c65a12edb808ae5759c1665ec90c75cbc34194b9d81e28c4ca5b8616de9174cbac060ba74da4509a28b21d85
+  data.tar.gz: dd8505b9ac5459fa2a2859cb1108b27861efcd59f234290ec43c4e2dc80e8ee61ea1ae34dba2f013036b495bcf6e9013f0fad0822a5249a43f7eba7cd3864251

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,31 +87,40 @@ 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],
-)
+vm = Quickjs::VM.new(features: [::Quickjs::MODULE_OS])
+
+# enable timeout features `setTimeout`, `clearTimeout`
+vm = Quickjs::VM.new(features: [::Quickjs::FEATURES_TIMEOUT])
+```
 
+#### VM timeout
+
+```rb
 # `eval_code` will be interrupted after 1 sec (default: 100 msec)
-vm = Quickjs::VM.new(
-  timeout_msec: 1_000,
-)
+vm = Quickjs::VM.new(timeout_msec: 1_000)
+```
+</details>
 
-# enable timeout features `setTimeout`, `clearTimeout`
-vm = Quickjs::VM.new(
-  features: [::Quickjs::FEATURES_TIMEOUT],
-)
+#### `Quickjs::VM#import`: 🔌 Import ESM from a source code
+
+```rb
+vm = Quickjs::VM.new
+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
 ```
 
-#### ⚡️ 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

data/ext/quickjsrb/quickjsrb.c

@@ -191,7 +191,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_exc_new_str(rb_eRuntimeError, r_error_message));
+      rb_exc_raise(rb_funcall(rb_cQuickjsRuntimeError, rb_intern("new"), 2, r_error_message, Qnil));
       return Qnil;
     }
 
@@ -229,43 +229,35 @@ VALUE to_rb_value(JSContext *ctx, JSValue j_val)
       JS_FreeValue(ctx, j_errorClassMessage);
       JS_FreeValue(ctx, j_errorClassName);
 
-      VALUE r_error_message = rb_sprintf("%s: %s", errorClassName, errorClassMessage);
-      VALUE r_error_class = rb_eRuntimeError;
+      VALUE r_error_class, r_error_message = rb_str_new2(errorClassMessage);
 
       if (strcmp(errorClassName, "SyntaxError") == 0)
       {
         r_error_class = rb_cQuickjsSyntaxError;
-        r_error_message = rb_str_new2(errorClassMessage);
       }
       else if (strcmp(errorClassName, "TypeError") == 0)
       {
         r_error_class = rb_cQuickjsTypeError;
-        r_error_message = rb_str_new2(errorClassMessage);
       }
       else if (strcmp(errorClassName, "ReferenceError") == 0)
       {
         r_error_class = rb_cQuickjsReferenceError;
-        r_error_message = rb_str_new2(errorClassMessage);
       }
       else if (strcmp(errorClassName, "RangeError") == 0)
       {
         r_error_class = rb_cQuickjsRangeError;
-        r_error_message = rb_str_new2(errorClassMessage);
       }
       else if (strcmp(errorClassName, "EvalError") == 0)
       {
         r_error_class = rb_cQuickjsEvalError;
-        r_error_message = rb_str_new2(errorClassMessage);
       }
       else if (strcmp(errorClassName, "URIError") == 0)
       {
         r_error_class = rb_cQuickjsURIError;
-        r_error_message = rb_str_new2(errorClassMessage);
       }
       else if (strcmp(errorClassName, "AggregateError") == 0)
       {
         r_error_class = rb_cQuickjsAggregateError;
-        r_error_message = rb_str_new2(errorClassMessage);
       }
       else if (strcmp(errorClassName, "InternalError") == 0 && strstr(errorClassMessage, "interrupted") != NULL)
       {
@@ -275,13 +267,16 @@ VALUE to_rb_value(JSContext *ctx, JSValue j_val)
       else if (strcmp(errorClassName, "Quickjs::InterruptedError") == 0)
       {
         r_error_class = rb_cQuickjsInterruptedError;
-        r_error_message = rb_str_new2(errorClassMessage);
+      }
+      else
+      {
+        r_error_class = rb_cQuickjsRuntimeError;
       }
       JS_FreeCString(ctx, errorClassName);
       JS_FreeCString(ctx, errorClassMessage);
       JS_FreeValue(ctx, j_exceptionVal);
 
-      rb_exc_raise(rb_exc_new_str(r_error_class, r_error_message));
+      rb_exc_raise(rb_funcall(r_error_class, rb_intern("new"), 2, r_error_message, rb_str_new2(errorClassName)));
     }
     else // exception without Error object
     {
@@ -290,7 +285,7 @@ VALUE to_rb_value(JSContext *ctx, JSValue j_val)
 
       JS_FreeCString(ctx, errorMessage);
       JS_FreeValue(ctx, j_exceptionVal);
-      rb_exc_raise(rb_exc_new_str(rb_cQuickjsRuntimeError, r_error_message));
+      rb_exc_raise(rb_funcall(rb_cQuickjsRuntimeError, rb_intern("new"), 2, r_error_message, Qnil));
     }
     return Qnil;
   }
@@ -490,7 +485,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_exc_new_str(rb_cQuickjsNoAwaitError, r_error_message));
+    rb_exc_raise(rb_funcall(rb_cQuickjsNoAwaitError, rb_intern("new"), 2, r_error_message, Qnil));
     return Qnil;
   }
   else
@@ -530,22 +525,17 @@ static VALUE vm_m_defineGlobalFunction(VALUE r_self, VALUE r_name)
   return Qnil;
 }
 
-// WISH: vm.import('hey', from: '...source...') imports just default
-// WISH: vm.import('{ member, member2 }', from: '...source...')
-// WISH: vm.import('{ member as aliasedName }', from: '...source...')
-// WISH: vm.import('defaultMember, { member }', from: '...source...')
-// WISH: vm.import('* as all', from: '...source...')
 static VALUE vm_m_import(int argc, VALUE *argv, VALUE r_self)
 {
   VALUE r_import_string, r_opts;
   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_exc_new_str(rb_eRuntimeError, r_error_message));
+    rb_exc_raise(rb_funcall(rb_cQuickjsRuntimeError, rb_intern("new"), 2, r_error_message, Qnil));
     return Qnil;
   }
 
@@ -553,16 +543,25 @@ static VALUE vm_m_import(int argc, VALUE *argv, VALUE r_self)
   TypedData_Get_Struct(r_self, VMData, &vm_type, data);
 
   char *source = StringValueCStr(r_from);
-  char *import_name = StringValueCStr(r_import_string);
   JSValue func = JS_Eval(data->context, source, strlen(source), "mmmodule", JS_EVAL_TYPE_MODULE | JS_EVAL_FLAG_COMPILE_ONLY);
   js_module_set_import_meta(data->context, func, TRUE, FALSE);
   JS_FreeValue(data->context, func);
 
-  const char *importAndGlobalizeModule = "import * as %s from 'mmmodule';\n"
-                                         "globalThis['%s'] = %s;\n";
-  int length = snprintf(NULL, 0, importAndGlobalizeModule, import_name, import_name, import_name);
+  VALUE r_import_settings = rb_funcall(
+      rb_const_get(rb_cClass, rb_intern("Quickjs")),
+      rb_intern("_build_import"),
+      1,
+      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);
+
+  const char *importAndGlobalizeModule = "import %s from 'mmmodule';\n"
+                                         "%s\n";
+  int length = snprintf(NULL, 0, importAndGlobalizeModule, import_name, globalize);
   char *result = (char *)malloc(length + 1);
-  snprintf(result, length + 1, importAndGlobalizeModule, import_name, import_name, import_name);
+  snprintf(result, length + 1, importAndGlobalizeModule, import_name, globalize);
 
   JSValue j_codeResult = JS_Eval(data->context, result, strlen(result), "<vm>", JS_EVAL_TYPE_MODULE);
   free(result);
@@ -605,8 +604,15 @@ static VALUE vm_m_to_s(VALUE r_self)
   return rb_funcall(r_ary, rb_intern("join"), 1, rb_str_new2(" "));
 }
 
-RUBY_FUNC_EXPORTED void
-Init_quickjsrb(void)
+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)));
@@ -632,6 +638,8 @@ Init_quickjsrb(void)
   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);

data/lib/quickjs/version.rb

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

data/lib/quickjs.rb

@@ -17,9 +17,36 @@ 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')
+    Quickjs::InterruptedError.new('Ruby runtime got timeout', nil)
   rescue => e
     e
   end
   module_function :_with_timeout
+
+  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(&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.1.13
+  version: 0.2.1
 platform: ruby
 authors:
 - hmsk
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-10-02 00:00:00.000000000 Z
+date: 2024-10-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json