quickjs 0.1.4 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3e230674190897ed1edcd6b9918deb3f9f073746f28410bdbe3e20e7622baea0
-  data.tar.gz: 8aeddfc2188ab5c1c34216a9f0e853339d784d2476967a2309171a654e633cc0
+  metadata.gz: 6fa772eb6185fa2bc744d7bb7b0cdb2024ccaf2d2ce34cb221139aaf2e819371
+  data.tar.gz: de4b5651b61eaaafe975ba56ae24b954c28efc9ea0ba2a6fb34f149b62d4aa58
 SHA512:
-  metadata.gz: dd1069fadcd70b58c8fe25d88f091304be1956cc43d62f64a389671ef0ed7ee79b53023852bdfe4be321f2aee53d3c00784ef7d3d2d1a329bad370087f388e74
-  data.tar.gz: cc4b076a5cfa578805c4108377ab148d4a5c4ec78b65fb6247dd0e906fbf083e0762173926bf4f6cbd37e469ad58f474a276df38a11e834d2207c6ad688b73cb
+  metadata.gz: 1095f8d04c0c90756506b8bd16a519b207b3b2a0eda64abecec8fb541a0a5a5c0e11240abce18b03e4ee4d7b4c3a53138513218f12afa4d7e46462f3a93680ef
+  data.tar.gz: 3237ad5b23217199900665605629c5b69c0333ea5951f3a43cf2e26ac65d6a718ff94f262fdaeb5bf0c3b132e60cb0561d60a121045a26bb201bbfd63e8e3a9c

data/README.md

@@ -2,7 +2,7 @@
 
 A Ruby wrapper for [QuickJS](https://bellard.org/quickjs) to run JavaScript codes via Ruby with a smaller footprint.
 
-[![Gem Version](https://img.shields.io/gem/v/quickjs?style=for-the-badge)](https://rubygems.org/gems/quickjs) [![GitHub Actions Workflow Status](https://img.shields.io/github/actions/workflow/status/hmsk/quickjs.rb/main?style=for-the-badge)](https://github.com/hmsk/quickjs.rb/actions/workflows/main.yml)
+[![Gem Version](https://img.shields.io/gem/v/quickjs?style=for-the-badge)](https://rubygems.org/gems/quickjs) [![GitHub Actions Workflow Status](https://img.shields.io/github/actions/workflow/status/hmsk/quickjs.rb/main.yml?style=for-the-badge)](https://github.com/hmsk/quickjs.rb/actions/workflows/main.yml)
 
 
 ## Installation
@@ -17,33 +17,33 @@ gem 'quickjs'
 
 ## Usage
 
-### `Quickjs.evalCode`: Evaluate JavaScript code
+### `Quickjs.eval_code`: Evaluate JavaScript code instantly
 
 ```rb
 require 'quickjs'
 
-Quickjs.evalCode('const fn = (n, pow) => n ** pow; fn(2,8);') # => 256
-Quickjs.evalCode('const fn = (name) => `Hi, ${name}!`; fn("Itadori");') # => "Hi, Itadori!
-Quickjs.evalCode("const isOne = (n) => 1 === n; func(1);") #=> true (TrueClass)
-Quickjs.evalCode("const isOne = (n) => 1 === n; func(3);") #=> false (FalseClass)
+Quickjs.eval_code('const fn = (n, pow) => n ** pow; fn(2,8);') # => 256
+Quickjs.eval_code('const fn = (name) => `Hi, ${name}!`; fn("Itadori");') # => "Hi, Itadori!
+Quickjs.eval_code("const isOne = (n) => 1 === n; func(1);") #=> true (TrueClass)
+Quickjs.eval_code("const isOne = (n) => 1 === n; func(3);") #=> false (FalseClass)
 
 # When code returns 'object' for `typeof`, the result is converted via JSON.stringify (JS) -> JSON.parse (Ruby)
-Quickjs.evalCode("[1,2,3]") #=> [1, 2, 3] (Array)
-Quickjs.evalCode("({ a: '1', b: 1 })") #=> { 'a' => '1', 'b' => 1 } (Hash)
+Quickjs.eval_code("[1,2,3]") #=> [1, 2, 3] (Array)
+Quickjs.eval_code("({ a: '1', b: 1 })") #=> { 'a' => '1', 'b' => 1 } (Hash)
 
-Quickjs.evalCode("null") #=> nil
-Quickjs.evalCode('const obj = {}; obj.missingKey;') # => :undefined (Quickjs::Value::Undefined)
-Quickjs.evalCode("Number('whatever')") #=> :NaN (Quickjs::Value::NAN)
+Quickjs.eval_code("null") #=> nil
+Quickjs.eval_code('const obj = {}; obj.missingKey;') # => :undefined (Quickjs::Value::Undefined)
+Quickjs.eval_code("Number('whatever')") #=> :NaN (Quickjs::Value::NAN)
 ```
 
 #### Limit resources
 
 ```rb
 # 1GB memory limit
-Quickjs.evalCode(code, { memoryLimit: 1024 ** 3 })
+Quickjs.eval_code(code, { memory_limit: 1024 ** 3 })
 
 # 1MB max stack size
-Quickjs.evalCode(code, { memoryLimit: 1024 ** 2 })
+Quickjs.eval_code(code, { max_stack_size: 1024 ** 2 })
 ```
 
 #### Enable built-in modules
@@ -51,11 +51,61 @@ Quickjs.evalCode(code, { memoryLimit: 1024 ** 2 })
 ```rb
 # enable std module
 # https://bellard.org/quickjs/quickjs.html#std-module
-Quickjs.evalCode(code, { features: [Quickjs::MODULE_STD] })
+Quickjs.eval_code(code, { features: [Quickjs::MODULE_STD] })
 
 # enable os module
 # https://bellard.org/quickjs/quickjs.html#os-module
-Quickjs.evalCode(code, { features: [Quickjs::MODULE_OS] })
+Quickjs.eval_code(code, { features: [Quickjs::MODULE_OS] })
+```
+
+### `Quickjs::VM`: Maintain a consistent VM/runtime
+
+```rb
+vm = Quickjs::VM.new
+vm.eval_code('const a = { b: "c" };')
+vm.eval_code('a.b;') #=> "c"
+vm.eval_code('a.b = "d";')
+vm.eval_code('a.b;') #=> "d"
+```
+
+#### Config VM
+
+```rb
+vm = Quickjs::VM.new(
+  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],
+)
+```
+
+#### Dispose VM explicitly
+
+```rb
+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

data/ext/quickjsrb/extconf.rb

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

data/ext/quickjsrb/quickjsrb-runtime-state.c

@@ -0,0 +1,92 @@
+#include "quickjsrb-runtime-state.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_PROC;
+}
+
+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_PROC);
+  for (int i = 0; i < MAX_NUM_OF_PROC; ++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_PROC; ++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);
+}
+
+QuickjsrbRuntimeState *create_quickjsrb_runtime_state() {
+  QuickjsrbRuntimeState *state = malloc(sizeof(QuickjsrbRuntimeState));
+  state->procs = create_proc_entries();
+
+  return state;
+}
+
+void free_quickjsrb_runtime_state(QuickjsrbRuntimeState *state) {
+  free_proc_entry_map(state->procs);
+  free(state);
+}

data/ext/quickjsrb/quickjsrb-runtime-state.h

@@ -0,0 +1,22 @@
+#include "ruby.h"
+
+#define MAX_NUM_OF_PROC 100
+
+typedef struct ProcEntry {
+  char *key;
+  VALUE proc;
+  struct ProcEntry *next;
+} ProcEntry;
+
+typedef struct ProcEntryMap {
+  ProcEntry **entries;
+} ProcEntryMap;
+
+typedef struct QuickjsrbRuntimeState {
+  ProcEntryMap *procs;
+} QuickjsrbRuntimeState;
+
+QuickjsrbRuntimeState *create_quickjsrb_runtime_state();
+VALUE get_proc(ProcEntryMap *entryMap, const char *key);
+void set_proc(ProcEntryMap *entryMap, const char *key, VALUE proc);
+void free_quickjsrb_runtime_state(QuickjsrbRuntimeState *state);

data/ext/quickjsrb/quickjsrb.c

@@ -1,114 +1,303 @@
 #include "quickjsrb.h"
+#include "quickjsrb-runtime-state.h"
+
+struct qvmdata {
+  char alive;
+  struct JSContext *context;
+  struct QuickjsrbRuntimeState *state;
+};
+
+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,
+};
+
+VALUE qvm_alloc(VALUE self)
+{
+  struct qvmdata *data;
+
+  return TypedData_Make_Struct(self, struct qvmdata, &qvm_type, data);
+}
+
+static JSValue js_quickjsrb_call_global (JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) {
+  struct qvmdata *data = JS_GetContextOpaque(ctx);
+  JSValue maybeFuncName = JS_ToString(ctx, argv[0]);
+  const char *funcName = JS_ToCString(ctx, maybeFuncName);
+
+  VALUE proc = get_proc(data->state->procs, funcName);
+  if (proc == Qnil) {
+    return JS_NewString(ctx, "missing");
+  }
+  JS_FreeValue(ctx, maybeFuncName);
+
+  // TODO: support multiple args
+  JSValue maybeString;
+  VALUE r_array = rb_ary_new2(argc);
+  for (int i = 1; i < argc; ++i) {
+    maybeString = JS_ToString(ctx, argv[i]);
+    const char *msg = JS_ToCString(ctx, maybeString);
+    rb_ary_push(r_array, rb_str_new2(msg));
+  }
+  JS_FreeValue(ctx, maybeString);
+
+  VALUE r_result = rb_funcall(proc, rb_intern("call"), argc - 1, r_array);
+  char *result = StringValueCStr(r_result);
+  return JS_NewString(ctx, result);
+}
 
 VALUE rb_mQuickjs;
-VALUE rb_mQuickjsValue;
 const char *undefinedId = "undefined";
 const char *nanId = "NaN";
 
-VALUE rb_module_eval_js_code(
-  VALUE klass,
-  VALUE r_code,
-  VALUE r_memoryLimit,
-  VALUE r_maxStackSize,
-  VALUE r_enableStd,
-  VALUE r_enableOs
-) {
-  JSRuntime *rt = JS_NewRuntime();
-  JSContext *ctx = JS_NewContext(rt);
-
-  JS_SetMemoryLimit(rt, NUM2UINT(r_memoryLimit));
-  JS_SetMaxStackSize(rt, NUM2UINT(r_maxStackSize));
-
-  JS_AddIntrinsicBigFloat(ctx);
-  JS_AddIntrinsicBigDecimal(ctx);
-  JS_AddIntrinsicOperators(ctx);
-  JS_EnableBignumExt(ctx, TRUE);
-
-  JS_SetModuleLoaderFunc(rt, NULL, js_module_loader, NULL);
-  js_std_add_helpers(ctx, 0, NULL);
-
-  js_std_init_handlers(rt);
-  if (r_enableStd == Qtrue) {
-    js_init_module_std(ctx, "std");
-    const char *enableStd = "import * as std from 'std';\n"
-        "globalThis.std = std;\n";
-    JSValue stdEval = JS_Eval(ctx, enableStd, strlen(enableStd), "<code>", JS_EVAL_TYPE_MODULE);
-    JS_FreeValue(ctx, stdEval);
-  }
-
-  if (r_enableOs == Qtrue) {
-    js_init_module_os(ctx, "os");
+const char *featureStdId = "feature_std";
+const char *featureOsId = "feature_os";
 
-    const char *enableOs = "import * as os from 'os';\n"
-        "globalThis.os = os;\n";
-    JSValue osEval = JS_Eval(ctx, enableOs, strlen(enableOs), "<code>", JS_EVAL_TYPE_MODULE);
-    JS_FreeValue(ctx, osEval);
+VALUE to_rb_value (JSValue jsv, JSContext *ctx) {
+  switch(JS_VALUE_GET_NORM_TAG(jsv)) {
+  case JS_TAG_INT: {
+    int int_res = 0;
+    JS_ToInt32(ctx, &int_res, jsv);
+    return INT2NUM(int_res);
   }
+  case JS_TAG_FLOAT64: {
+    if (JS_VALUE_IS_NAN(jsv)) {
+      return ID2SYM(rb_intern(nanId));
+    }
+    double double_res;
+    JS_ToFloat64(ctx, &double_res, jsv);
+    return DBL2NUM(double_res);
+  }
+  case JS_TAG_BOOL: {
+    return JS_ToBool(ctx, jsv) > 0 ? Qtrue : Qfalse;
+  }
+  case JS_TAG_STRING: {
+    JSValue maybeString = JS_ToString(ctx, jsv);
+    const char *msg = JS_ToCString(ctx, maybeString);
+    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);
+    }
 
-  char *code = StringValueCStr(r_code);
-  JSValue res = JS_Eval(ctx, code, strlen(code), "<code>", JS_EVAL_TYPE_GLOBAL);
-
-  VALUE result;
-  if (JS_IsException(res)) {
-    rb_raise(rb_eRuntimeError, "Something happened by evaluating as JavaScript code");
-    result = Qnil;
-  } else if (JS_IsObject(res)) {
     JSValue global = JS_GetGlobalObject(ctx);
     JSValue jsonClass = JS_GetPropertyStr(ctx, global, "JSON");
     JSValue stringifyFunc = JS_GetPropertyStr(ctx, jsonClass, "stringify");
-    JSValue strigified = JS_Call(ctx, stringifyFunc, jsonClass, 1, &res);
+    JSValue strigified = JS_Call(ctx, stringifyFunc, jsonClass, 1, &jsv);
 
     const char *msg = JS_ToCString(ctx, strigified);
     VALUE rbString = rb_str_new2(msg);
-    VALUE rb_cJson = rb_const_get(rb_cClass, rb_intern("JSON"));
-    result = rb_funcall(rb_cJson, rb_intern("parse"), 1, rbString);
 
     JS_FreeValue(ctx, global);
     JS_FreeValue(ctx, strigified);
     JS_FreeValue(ctx, stringifyFunc);
     JS_FreeValue(ctx, jsonClass);
-  } else if (JS_VALUE_IS_NAN(res)) {
-    result = ID2SYM(rb_intern(nanId));
-  } else if (JS_IsNumber(res)) {
-    int tag = JS_VALUE_GET_TAG(res);
-    if (JS_TAG_IS_FLOAT64(tag)) {
-      double double_res;
-      JS_ToFloat64(ctx, &double_res, res);
-      result = DBL2NUM(double_res);
+
+    return rb_funcall(rb_const_get(rb_cClass, rb_intern("JSON")), rb_intern("parse"), 1, rbString);
+  }
+  case JS_TAG_NULL:
+    return Qnil;
+  case JS_TAG_UNDEFINED:
+    return ID2SYM(rb_intern(undefinedId));
+  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 {
-      int int_res;
-      JS_ToInt32(ctx, &int_res, res);
-      result = INT2NUM(int_res);
+      const char *errorMessage = JS_ToCString(ctx, exceptionVal);
+
+      rb_raise(rb_eRuntimeError, "%s", errorMessage);
     }
-  } else if (JS_IsString(res)) {
-    JSValue maybeString = JS_ToString(ctx, res);
-    const char *msg = JS_ToCString(ctx, maybeString);
-    result = rb_str_new2(msg);
-  } else if (JS_IsBool(res)) {
-    result = JS_ToBool(ctx, res) > 0 ? Qtrue : Qfalse;
-  } else if (JS_IsUndefined(res)) {
-    result = ID2SYM(rb_intern(undefinedId));
-  } else if (JS_IsNull(res)) {
-    result = Qnil;
-  } else {
-    result = Qnil;
+
+    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);
+
+    const char *msg = JS_ToCString(ctx, strigified);
+    VALUE rbString = rb_str_new2(msg);
+    JS_FreeValue(ctx, strigified);
+    JS_FreeValue(ctx, toStringFunc);
+
+    return rb_funcall(rbString, rb_intern("to_i"), 0, NULL);
+  }
+  case JS_TAG_BIG_FLOAT:
+  case JS_TAG_BIG_DECIMAL:
+  case JS_TAG_SYMBOL:
+  default:
+    return Qnil;
   }
-  JS_FreeValue(ctx, res);
+}
+
+VALUE qvm_m_initialize(int argc, VALUE* argv, VALUE self)
+{
+  VALUE r_opts;
+  rb_scan_args(argc, argv, ":", &r_opts);
+  if (NIL_P(r_opts)) r_opts = rb_hash_new();
+
+  VALUE r_memoryLimit = rb_hash_aref(r_opts, ID2SYM(rb_intern("memory_limit")));
+  if (NIL_P(r_memoryLimit)) r_memoryLimit = UINT2NUM(1024 * 1024 * 128);
+  VALUE r_maxStackSize = rb_hash_aref(r_opts, ID2SYM(rb_intern("max_stack_size")));
+  if (NIL_P(r_maxStackSize)) r_maxStackSize = UINT2NUM(1024 * 1024 * 4);
+  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);
+
+  QuickjsrbRuntimeState *state= create_quickjsrb_runtime_state();
+  JSRuntime *runtime = JS_NewRuntime();
+  data->context = JS_NewContext(runtime);
+  data->state = state;
+  data->alive = 1;
+  JS_SetContextOpaque(data->context, data);
+
+  JS_SetMemoryLimit(runtime, NUM2UINT(r_memoryLimit));
+  JS_SetMaxStackSize(runtime, NUM2UINT(r_maxStackSize));
+
+  JS_AddIntrinsicBigFloat(data->context);
+  JS_AddIntrinsicBigDecimal(data->context);
+  JS_AddIntrinsicOperators(data->context);
+  JS_EnableBignumExt(data->context, TRUE);
+  js_std_add_helpers(data->context, 0, NULL);
+
+  JS_SetModuleLoaderFunc(runtime, NULL, js_module_loader, NULL);
+  js_std_init_handlers(runtime);
+
+  if (RTEST(rb_funcall(r_features, rb_intern("include?"), 1, ID2SYM(rb_intern(featureStdId))))) {
+    js_init_module_std(data->context, "std");
+    const char *enableStd = "import * as std from 'std';\n"
+        "globalThis.std = std;\n";
+    JSValue stdEval = JS_Eval(data->context, enableStd, strlen(enableStd), "<vm>", JS_EVAL_TYPE_MODULE);
+    JS_FreeValue(data->context, stdEval);
+  }
+
+  if (RTEST(rb_funcall(r_features, rb_intern("include?"), 1, ID2SYM(rb_intern(featureOsId))))) {
+    js_init_module_os(data->context, "os");
+    const char *enableOs = "import * as os from 'os';\n"
+        "globalThis.os = os;\n";
+    JSValue osEval = JS_Eval(data->context, enableOs, strlen(enableOs), "<vm>", JS_EVAL_TYPE_MODULE);
+    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)
+{
+  struct qvmdata *data;
+  TypedData_Get_Struct(self, struct qvmdata, &qvm_type, data);
 
-  js_std_free_handlers(rt);
-  JS_FreeContext(ctx);
-  JS_FreeRuntime(rt);
+  if (data->alive < 1) {
+    rb_raise(rb_eRuntimeError, "Quickjs::VM was disposed");
+    return Qnil;
+  }
+  char *code = StringValueCStr(r_code);
+  JSValue codeResult = JS_Eval(data->context, code, strlen(code), "<code>", JS_EVAL_TYPE_GLOBAL);
+  VALUE result = to_rb_value(codeResult, data->context);
 
+  JS_FreeValue(data->context, codeResult);
   return result;
 }
 
+VALUE qvm_m_defineGlobalFunction(VALUE self, VALUE r_name)
+{
+  rb_need_block();
+
+  struct qvmdata *data;
+  TypedData_Get_Struct(self, struct qvmdata, &qvm_type, data);
+
+  if (rb_block_given_p()) {
+    VALUE proc = rb_block_proc();
+
+    char *funcName = StringValueCStr(r_name);
+
+    set_proc(data->state->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 qvm_m_dispose(VALUE self)
+{
+  struct qvmdata *data;
+  TypedData_Get_Struct(self, struct qvmdata, &qvm_type, data);
+
+  JSRuntime *runtime = JS_GetRuntime(data->context);
+  js_std_free_handlers(runtime);
+  free_quickjsrb_runtime_state(data->state);
+  JS_FreeContext(data->context);
+  JS_FreeRuntime(runtime);
+  data->alive = 0;
+
+  return Qnil;
+}
+
 RUBY_FUNC_EXPORTED void
 Init_quickjsrb(void)
 {
   rb_mQuickjs = rb_define_module("Quickjs");
-  rb_define_module_function(rb_mQuickjs, "_evalCode", rb_module_eval_js_code, 5);
+  rb_define_const(rb_mQuickjs, "MODULE_STD", ID2SYM(rb_intern(featureStdId)));
+  rb_define_const(rb_mQuickjs, "MODULE_OS", ID2SYM(rb_intern(featureOsId)));
 
   VALUE valueClass = rb_define_class_under(rb_mQuickjs, "Value", rb_cObject);
   rb_define_const(valueClass, "UNDEFINED", ID2SYM(rb_intern(undefinedId)));
   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, "define_function", qvm_m_defineGlobalFunction, 1);
+  rb_define_method(vmClass, "dispose!", qvm_m_dispose, 0);
 }

data/lib/quickjs/version.rb

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

data/lib/quickjs.rb

@@ -5,25 +5,8 @@ require_relative "quickjs/version"
 require_relative "quickjs/quickjsrb"
 
 module Quickjs
-  MODULE_STD = :std
-  MODULE_OS = :os
-
-  def evalCode(
-    code,
-    opts = {
-      memoryLimit: nil,
-      maxStackSize: nil,
-      features: []
-    }
-  )
-
-    _evalCode(
-      code,
-      opts[:memoryLimit] || 1024 * 1024 * 128,
-      opts[:maxStackSize] || 1024 * 1024 * 4,
-      opts[:features].include?(Quickjs::MODULE_STD),
-      opts[:features].include?(Quickjs::MODULE_OS),
-    )
+  def eval_code(code, overwrite_opts = {})
+    Quickjs::VM.new(**overwrite_opts).eval_code(code)
   end
-  module_function :evalCode
+  module_function :eval_code
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: quickjs
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.6
 platform: ruby
 authors:
 - hmsk
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-06-19 00:00:00.000000000 Z
+date: 2024-07-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -62,6 +62,8 @@ files:
 - ext/quickjsrb/quickjs/run-test262.c
 - ext/quickjsrb/quickjs/unicode_gen.c
 - ext/quickjsrb/quickjs/unicode_gen_def.h
+- ext/quickjsrb/quickjsrb-runtime-state.c
+- ext/quickjsrb/quickjsrb-runtime-state.h
 - ext/quickjsrb/quickjsrb.c
 - ext/quickjsrb/quickjsrb.h
 - lib/quickjs.rb