quickjs 0.1.5 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 16b9d276d5d05c5f7cf5ff981573283fa990064d55e60b02dc86f773c892c9a0
-  data.tar.gz: bf3e2ebee03197fdead070a974d40485c77bab90a7ab5153274a3cfb48a7ea4b
+  metadata.gz: 9a639b7afafb5c155725cba8d7927b7f4e146e21369a65a3902e8fe23ef1e3dd
+  data.tar.gz: b0e098ae6c193e761f456642cdcaf5396251785d5bc56b5e807fd540a0615f87
 SHA512:
-  metadata.gz: 4f9431993a243c908c905c25a13c8679f17d3404699a87868c6a195f2eeb0b0e2f1c76716bf4564e076a189f20302ef1d6ade01a763e7827fdc5a4229f23be2c
-  data.tar.gz: 85505319f063a8f1e5c8c42dc4de7d483f9a3e3deb4599203d2d55d2c79d206d26385f8a139a67a87f753cab67fa74f2a74b0ed6f2a864fd5bd37c2588762881
+  metadata.gz: 9ad93ee1c056d68409daeba63515b8afa8555150044e0543a97bb2f3cb64abf5b8f5a5b1fce75e952721b0277a7807ce521289b70b63157cc489032da7da8f7c
+  data.tar.gz: b36a5f2e7402156e94403c5110ec1acc6141d657b236562b18b57c63c68fd966d4ef25096e3b515f9633093bee2e2a89f65578b4426e0c4184197078c9c2c578

data/README.md

@@ -40,10 +40,10 @@ Quickjs.eval_code("Number('whatever')") #=> :NaN (Quickjs::Value::NAN)
 
 ```rb
 # 1GB memory limit
-Quickjs.eval_code(code, { memoryLimit: 1024 ** 3 })
+Quickjs.eval_code(code, { memory_limit: 1024 ** 3 })
 
 # 1MB max stack size
-Quickjs.eval_code(code, { memoryLimit: 1024 ** 2 })
+Quickjs.eval_code(code, { max_stack_size: 1024 ** 2 })
 ```
 
 #### Enable built-in modules
@@ -58,7 +58,7 @@ Quickjs.eval_code(code, { features: [Quickjs::MODULE_STD] })
 Quickjs.eval_code(code, { features: [Quickjs::MODULE_OS] })
 ```
 
-### Maintain a consistent VM/runtime
+### `Quickjs::VM`: Maintain a consistent VM/runtime
 
 ```rb
 vm = Quickjs::VM.new
@@ -72,15 +72,20 @@ vm.eval_code('a.b;') #=> "d"
 
 ```rb
 vm = Quickjs::VM.new(
-  memory_limit: 1024 * 1024,
-  max_stack_size: 1024 * 1024,
+  memory_limit: 1024 ** 3,
+  max_stack_size: 1024 ** 2,
 )
 ```
 
 ```rb
+# enable std module
+# https://bellard.org/quickjs/quickjs.html#std-module
 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],
 )
@@ -92,6 +97,17 @@ vm = Quickjs::VM.new(
 vm.dispose!
 ```
 
+#### Define a global function for JS
+
+```rb
+vm = Quickjs::VM.new
+vm.define_function("greetingTo") do |arg1|
+  ['Hello!', arg1].join(' ')
+end
+
+vm.eval_code("greetingTo('Rick')") #=> 'Hello! Rick'
+```
+
 ## 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/extconf.rb

@@ -11,6 +11,7 @@ $srcs = [
   'cutils.c',
   'quickjs.c',
   'quickjs-libc.c',
+  'procs.c',
   'quickjsrb.c',
 ]
 

data/ext/quickjsrb/procs.c

@@ -0,0 +1,80 @@
+#include "procs.h"
+
+unsigned int hash(const char *key) {
+  unsigned long int value = 0;
+  unsigned int i = 0;
+  unsigned int key_len = strlen(key);
+
+  for (; i < key_len; ++i) {
+    value = value * 37 + key[i];
+  }
+  return value % MAX_NUM_OF_PROCS;
+}
+
+ProcEntry *create_proc_entry(const char *key, VALUE proc) {
+  ProcEntry *entry = malloc(sizeof(ProcEntry));
+  entry->key = strdup(key);
+  entry->proc = proc;
+  entry->next = NULL;
+  return entry;
+}
+
+ProcEntryMap *create_proc_entries() {
+  ProcEntryMap *entryMap = malloc(sizeof(ProcEntryMap));
+  entryMap->entries = malloc(sizeof(ProcEntry *) * MAX_NUM_OF_PROCS);
+  for (int i = 0; i < MAX_NUM_OF_PROCS; ++i) {
+    entryMap->entries[i] = NULL;
+  }
+  return entryMap;
+}
+
+void set_proc(ProcEntryMap *entryMap, const char *key, VALUE proc) {
+  unsigned int slot = hash(key);
+  ProcEntry *entry = entryMap->entries[slot];
+
+  if (entry == NULL) {
+    entryMap->entries[slot] = create_proc_entry(key, proc);
+    return;
+  }
+
+  ProcEntry *prev;
+  while (entry != NULL) {
+    if (strcmp(entry->key, key) == 0) {
+      entry->proc = proc;
+      return;
+    }
+    prev = entry;
+    entry = prev->next;
+  }
+
+  prev->next = create_proc_entry(key, proc);
+}
+
+VALUE get_proc(ProcEntryMap *entryMap, const char *key) {
+  unsigned int slot = hash(key);
+
+  ProcEntry *entry = entryMap->entries[slot];
+
+  while (entry != NULL) {
+    if (strcmp(entry->key, key) == 0) {
+      return entry->proc;
+    }
+    entry = entry->next;
+  }
+
+  return Qnil;
+}
+
+void free_proc_entry_map(ProcEntryMap *entryMap) {
+  for (int i = 0; i < MAX_NUM_OF_PROCS; ++i) {
+    ProcEntry *entry = entryMap->entries[i];
+    while (entry != NULL) {
+      ProcEntry *temp = entry;
+      entry = entry->next;
+      free(temp->key);
+      free(temp);
+    }
+  }
+  free(entryMap->entries);
+  free(entryMap);
+}

data/ext/quickjsrb/procs.h

@@ -0,0 +1,18 @@
+#include "ruby.h"
+
+#define MAX_NUM_OF_PROCS 100
+
+typedef struct ProcEntry {
+  char *key;
+  VALUE proc;
+  struct ProcEntry *next;
+} ProcEntry;
+
+typedef struct ProcEntryMap {
+  ProcEntry **entries;
+} ProcEntryMap;
+
+ProcEntryMap *create_proc_entries();
+void set_proc(ProcEntryMap *entryMap, const char *key, VALUE proc);
+VALUE get_proc(ProcEntryMap *entryMap, const char *key);
+void free_proc_entry_map(ProcEntryMap *entryMap);

data/ext/quickjsrb/quickjsrb.c

@@ -1,5 +1,39 @@
 #include "quickjsrb.h"
 
+typedef struct VMData {
+  char alive;
+  struct JSContext *context;
+  struct QuickjsrbRuntimeState *state;
+  struct ProcEntryMap *procs;
+} VMData;
+
+void vm_free(void* data)
+{
+  free(data);
+}
+
+size_t vm_size(const void* data)
+{
+  return sizeof(data);
+}
+
+static const rb_data_type_t vm_type = {
+  .wrap_struct_name = "vm",
+  .function = {
+    .dmark = NULL,
+    .dfree = vm_free,
+    .dsize = vm_size,
+  },
+  .data = NULL,
+  .flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+VALUE vm_alloc(VALUE self)
+{
+  VMData *data;
+  return TypedData_Make_Struct(self, VMData, &vm_type, data);
+}
+
 VALUE rb_mQuickjs;
 const char *undefinedId = "undefined";
 const char *nanId = "NaN";
@@ -7,7 +41,63 @@ const char *nanId = "NaN";
 const char *featureStdId = "feature_std";
 const char *featureOsId = "feature_os";
 
-VALUE to_rb_value (JSValue jsv, JSContext *ctx) {
+JSValue to_js_value(JSContext *ctx, VALUE r_value) {
+  switch (TYPE(r_value)) {
+    case T_NIL:
+      return JS_NULL;
+    case T_FIXNUM:
+    case T_FLOAT: {
+      VALUE r_str = rb_funcall(r_value, rb_intern("to_s"), 0, NULL);
+      char *str = StringValueCStr(r_str);
+      JSValue global = JS_GetGlobalObject(ctx);
+      JSValue numberClass = JS_GetPropertyStr(ctx, global, "Number");
+      JSValue j_str = JS_NewString(ctx, str);
+      JSValue stringified = JS_Call(ctx, numberClass, JS_UNDEFINED, 1, &j_str);
+      JS_FreeValue(ctx, global);
+      JS_FreeValue(ctx, numberClass);
+
+      return stringified;
+    }
+    case T_STRING: {
+      char *str = StringValueCStr(r_value);
+
+      return JS_NewString(ctx, str);
+    }
+    case T_SYMBOL: {
+      VALUE r_str = rb_funcall(r_value, rb_intern("to_s"), 0, NULL);
+      char *str = StringValueCStr(r_str);
+
+      return JS_NewString(ctx, str);
+    }
+    case T_TRUE:
+      return JS_TRUE;
+    case T_FALSE:
+      return JS_FALSE;
+    case T_HASH:
+    case T_ARRAY: {
+      VALUE r_json_str = rb_funcall(r_value, rb_intern("to_json"), 0, NULL);
+      char *str = StringValueCStr(r_json_str);
+      JSValue global = JS_GetGlobalObject(ctx);
+      JSValue jsonClass = JS_GetPropertyStr(ctx, global, "JSON");
+      JSValue parseFunc = JS_GetPropertyStr(ctx, jsonClass, "parse");
+      JSValue j_str = JS_NewString(ctx, str);
+      JSValue stringified = JS_Call(ctx, parseFunc, jsonClass, 1, &j_str);
+      JS_FreeValue(ctx, global);
+      JS_FreeValue(ctx, parseFunc);
+      JS_FreeValue(ctx, jsonClass);
+
+      return stringified;
+    }
+    default: {
+      VALUE r_inspect_str = rb_funcall(r_value, rb_intern("inspect"), 0, NULL);
+      char *str = StringValueCStr(r_inspect_str);
+
+      return JS_NewString(ctx, str);
+    }
+  }
+}
+
+VALUE to_rb_value(JSValue jsv, JSContext *ctx) {
   switch(JS_VALUE_GET_NORM_TAG(jsv)) {
   case JS_TAG_INT: {
     int int_res = 0;
@@ -31,6 +121,13 @@ VALUE to_rb_value (JSValue jsv, JSContext *ctx) {
     return rb_str_new2(msg);
   }
   case JS_TAG_OBJECT: {
+    int promiseState = JS_PromiseState(ctx, jsv);
+    if (promiseState == JS_PROMISE_FULFILLED || promiseState == JS_PROMISE_PENDING) {
+      return to_rb_value(js_std_await(ctx, jsv), ctx);
+    } else if (promiseState == JS_PROMISE_REJECTED) {
+      return to_rb_value(JS_Throw(ctx, JS_PromiseResult(ctx, jsv)), ctx);
+    }
+
     JSValue global = JS_GetGlobalObject(ctx);
     JSValue jsonClass = JS_GetPropertyStr(ctx, global, "JSON");
     JSValue stringifyFunc = JS_GetPropertyStr(ctx, jsonClass, "stringify");
@@ -50,9 +147,28 @@ VALUE to_rb_value (JSValue jsv, JSContext *ctx) {
     return Qnil;
   case JS_TAG_UNDEFINED:
     return ID2SYM(rb_intern(undefinedId));
-  case JS_TAG_EXCEPTION:
-    rb_raise(rb_eRuntimeError, "Something happened by evaluating as JavaScript code");
+  case JS_TAG_EXCEPTION: {
+    JSValue exceptionVal = JS_GetException(ctx);
+    if (JS_IsError(ctx, exceptionVal)) {
+      JSValue jsErrorClassName = JS_GetPropertyStr(ctx, exceptionVal, "name");
+      const char *errorClassName = JS_ToCString(ctx, jsErrorClassName);
+
+      JSValue jsErrorClassMessage = JS_GetPropertyStr(ctx, exceptionVal, "message");
+      const char *errorClassMessage = JS_ToCString(ctx, jsErrorClassMessage);
+
+      JS_FreeValue(ctx, jsErrorClassMessage);
+      JS_FreeValue(ctx, jsErrorClassName);
+
+      rb_raise(rb_eRuntimeError, "%s: %s", errorClassName, errorClassMessage);
+    } else {
+      const char *errorMessage = JS_ToCString(ctx, exceptionVal);
+
+      rb_raise(rb_eRuntimeError, "%s", errorMessage);
+    }
+
+    JS_FreeValue(ctx, exceptionVal);
     return Qnil;
+  }
   case JS_TAG_BIG_INT: {
     JSValue toStringFunc = JS_GetPropertyStr(ctx, jsv, "toString");
     JSValue strigified = JS_Call(ctx, toStringFunc, jsv, 0, NULL);
@@ -72,40 +188,22 @@ VALUE to_rb_value (JSValue jsv, JSContext *ctx) {
   }
 }
 
-struct qvmdata {
-  struct JSContext *context;
-  char alive;
-};
-
-void qvm_free(void* data)
-{
-  free(data);
-}
-
-size_t qvm_size(const void* data)
-{
-  return sizeof(data);
-}
-
-static const rb_data_type_t qvm_type = {
-  .wrap_struct_name = "qvm",
-  .function = {
-    .dmark = NULL,
-    .dfree = qvm_free,
-    .dsize = qvm_size,
-  },
-  .data = NULL,
-  .flags = RUBY_TYPED_FREE_IMMEDIATELY,
-};
+static JSValue js_quickjsrb_call_global(JSContext *ctx, JSValueConst _this, int _argc, JSValueConst *argv) {
+  VMData *data = JS_GetContextOpaque(ctx);
+  JSValue maybeFuncName = JS_ToString(ctx, argv[0]);
+  const char *funcName = JS_ToCString(ctx, maybeFuncName);
+  JS_FreeValue(ctx, maybeFuncName);
 
-VALUE qvm_alloc(VALUE self)
-{
-  struct qvmdata *data;
+  VALUE proc = get_proc(data->procs, funcName);
+  if (proc == Qnil) { // Shouldn't happen
+    return JS_ThrowReferenceError(ctx, "Proc `%s` is not defined", funcName);
+  }
 
-  return TypedData_Make_Struct(self, struct qvmdata, &qvm_type, data);
+  VALUE r_result = rb_apply(proc, rb_intern("call"), to_rb_value(argv[1], ctx));
+  return to_js_value(ctx, r_result);
 }
 
-VALUE qvm_m_initialize(int argc, VALUE* argv, VALUE self)
+VALUE vm_m_initialize(int argc, VALUE* argv, VALUE self)
 {
   VALUE r_opts;
   rb_scan_args(argc, argv, ":", &r_opts);
@@ -118,11 +216,14 @@ VALUE qvm_m_initialize(int argc, VALUE* argv, VALUE self)
   VALUE r_features = rb_hash_aref(r_opts, ID2SYM(rb_intern("features")));
   if (NIL_P(r_features)) r_features = rb_ary_new();
 
-  struct qvmdata *data;
-  TypedData_Get_Struct(self, struct qvmdata, &qvm_type, data);
+  VMData *data;
+  TypedData_Get_Struct(self, VMData, &vm_type, data);
+
   JSRuntime *runtime = JS_NewRuntime();
   data->context = JS_NewContext(runtime);
+  data->procs = create_proc_entries();
   data->alive = 1;
+  JS_SetContextOpaque(data->context, data);
 
   JS_SetMemoryLimit(runtime, NUM2UINT(r_memoryLimit));
   JS_SetMaxStackSize(runtime, NUM2UINT(r_maxStackSize));
@@ -152,13 +253,22 @@ VALUE qvm_m_initialize(int argc, VALUE* argv, VALUE self)
     JS_FreeValue(data->context, osEval);
   }
 
+  const char *setupGlobalRuby = "globalThis.__ruby = {};\n";
+  JSValue rubyEval = JS_Eval(data->context, setupGlobalRuby, strlen(setupGlobalRuby), "<vm>", JS_EVAL_TYPE_MODULE);
+  JS_FreeValue(data->context, rubyEval);
+
+  JSValue global = JS_GetGlobalObject(data->context);
+  JSValue func = JS_NewCFunction(data->context, js_quickjsrb_call_global, "rubyGlobal", 2);
+  JS_SetPropertyStr(data->context, global, "rubyGlobal", func);
+  JS_FreeValue(data->context, global);
+
   return self;
 }
 
-VALUE qvm_m_evalCode(VALUE self, VALUE r_code)
+VALUE vm_m_evalCode(VALUE self, VALUE r_code)
 {
-  struct qvmdata *data;
-  TypedData_Get_Struct(self, struct qvmdata, &qvm_type, data);
+  VMData *data;
+  TypedData_Get_Struct(self, VMData, &vm_type, data);
 
   if (data->alive < 1) {
     rb_raise(rb_eRuntimeError, "Quickjs::VM was disposed");
@@ -172,13 +282,43 @@ VALUE qvm_m_evalCode(VALUE self, VALUE r_code)
   return result;
 }
 
-VALUE qvm_m_dispose(VALUE self)
+VALUE vm_m_defineGlobalFunction(VALUE self, VALUE r_name)
+{
+  rb_need_block();
+
+  VMData *data;
+  TypedData_Get_Struct(self, VMData, &vm_type, data);
+
+  if (rb_block_given_p()) {
+    VALUE proc = rb_block_proc();
+
+    char *funcName = StringValueCStr(r_name);
+
+    set_proc(data->procs, funcName, proc);
+
+    const char* template = "globalThis.__ruby['%s'] = (...args) => rubyGlobal('%s', args);\nglobalThis['%s'] = globalThis.__ruby['%s'];\n";
+    int length = snprintf(NULL, 0, template, funcName, funcName, funcName, funcName);
+    char* result = (char*)malloc(length + 1);
+    snprintf(result, length + 1, template, funcName, funcName, funcName, funcName);
+
+    JSValue codeResult = JS_Eval(data->context, result, strlen(result), "<vm>", JS_EVAL_TYPE_MODULE);
+
+    JS_FreeValue(data->context, codeResult);
+    free(result);
+    return rb_funcall(r_name, rb_intern("to_sym"), 0, NULL);
+  }
+
+  return Qnil;
+}
+
+VALUE vm_m_dispose(VALUE self)
 {
-  struct qvmdata *data;
-  TypedData_Get_Struct(self, struct qvmdata, &qvm_type, data);
+  VMData *data;
+  TypedData_Get_Struct(self, VMData, &vm_type, data);
 
   JSRuntime *runtime = JS_GetRuntime(data->context);
   js_std_free_handlers(runtime);
+  free_proc_entry_map(data->procs);
   JS_FreeContext(data->context);
   JS_FreeRuntime(runtime);
   data->alive = 0;
@@ -198,8 +338,9 @@ Init_quickjsrb(void)
   rb_define_const(valueClass, "NAN", ID2SYM(rb_intern(nanId)));
 
   VALUE vmClass = rb_define_class_under(rb_mQuickjs, "VM", rb_cObject);
-  rb_define_alloc_func(vmClass, qvm_alloc);
-  rb_define_method(vmClass, "initialize", qvm_m_initialize, -1);
-  rb_define_method(vmClass, "eval_code", qvm_m_evalCode, 1);
-  rb_define_method(vmClass, "dispose!", qvm_m_dispose, 0);
+  rb_define_alloc_func(vmClass, vm_alloc);
+  rb_define_method(vmClass, "initialize", vm_m_initialize, -1);
+  rb_define_method(vmClass, "eval_code", vm_m_evalCode, 1);
+  rb_define_method(vmClass, "define_function", vm_m_defineGlobalFunction, 1);
+  rb_define_method(vmClass, "dispose!", vm_m_dispose, 0);
 }

data/ext/quickjsrb/quickjsrb.h

@@ -11,4 +11,6 @@
 #include <stdio.h>
 #include <string.h>
 
+#include "procs.h"
+
 #endif /* QUICKJSRB_H */

data/lib/quickjs/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: quickjs
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.1.7
 platform: ruby
 authors:
 - hmsk
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-07-01 00:00:00.000000000 Z
+date: 2024-07-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -37,6 +37,8 @@ files:
 - README.md
 - Rakefile
 - ext/quickjsrb/extconf.rb
+- ext/quickjsrb/procs.c
+- ext/quickjsrb/procs.h
 - ext/quickjsrb/quickjs/LICENSE
 - ext/quickjsrb/quickjs/cutils.c
 - ext/quickjsrb/quickjs/cutils.h