quickjs 0.14.0 → 0.15.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 69b86d7c5040dba161c1d6f67cb3eab3fd8a3dc51b30eb6d355c2580dbc29602
-  data.tar.gz: 5e174baed18d79e0ac18a496f97cd580fd20830a98fb240351eeea46abe57683
+  metadata.gz: e13c4664328e497bb8c2179807e8c110c4709b6df84a9a60f888e5a822075de2
+  data.tar.gz: c43d43f3c0b928798545ecf57bf9956df1912e3867220915dd5b13c8aeb0031f
 SHA512:
-  metadata.gz: 9f7abcc1733fcfe9c51aacf81c9e34b05e7e44142a9db79a8bd4525ba67570f897cd7c1fb200428507876dad35a67b9a3f383711a3b0cfc9ff1b46728cd1c125
-  data.tar.gz: a15abae6b482f0df7efc89e9b0a3b9d3ca3bab8bb8d04ce7844f60b195a0314d8e12d2b3bbdf8cf01dae763e75945d4e84cf3c1efbe2a99d4cfa525e2279625e
+  metadata.gz: 581463e6df8d5559f9aa1f91e4512b68f745942d771b2246202d3137a378876c6662db800381abd4dc065b4a6a8acb03f247feda4b78aa9ce1fc31cdd6ed6836
+  data.tar.gz: cd4f64a7d98a75c5e388b99e1cdbd44c6ad4cfc4cd96f8e23259f12aa8cbe18f8c580ad41633cb65c9f77a6f9732fbb6e042b6805cc034a0c4c060f4ecdb3635

data/ext/quickjsrb/extconf.rb

@@ -3,6 +3,7 @@
 require 'mkmf'
 
 $VPATH << "$(srcdir)/quickjs"
+$INCFLAGS << " -I$(srcdir)/quickjs"
 
 $srcs = [
   'dtoa.c',
@@ -21,8 +22,6 @@ $srcs = [
   'quickjsrb_crypto_subtle.c',
 ]
 
-append_cflags('-I$(srcdir)/quickjs')
-
 append_cflags('-g')
 append_cflags('-O2')
 append_cflags('-Wall')

data/ext/quickjsrb/quickjsrb.c

@@ -26,6 +26,9 @@ const int num_native_errors = sizeof(native_errors) / sizeof(native_errors[0]);
 
 static int dispatch_log(VMData *data, const char *severity, VALUE r_row);
 
+JSValue to_js_value(JSContext *ctx, VALUE r_value);
+VALUE to_rb_value(JSContext *ctx, JSValue j_val);
+
 JSValue j_error_from_ruby_error(JSContext *ctx, VALUE r_error)
 {
   JSValue j_error = JS_NewError(ctx); // may wanna have custom error class to determine in JS' end
@@ -45,6 +48,20 @@ JSValue j_error_from_ruby_error(JSContext *ctx, VALUE r_error)
   return j_error;
 }
 
+typedef struct
+{
+  JSContext *ctx;
+  JSValue j_obj;
+} RbHashToJsArg;
+
+static int rb_hash_entry_to_js(VALUE r_key, VALUE r_val, VALUE extra)
+{
+  RbHashToJsArg *arg = (RbHashToJsArg *)extra;
+  VALUE r_key_str = rb_funcall(r_key, rb_intern("to_s"), 0);
+  JS_SetPropertyStr(arg->ctx, arg->j_obj, StringValueCStr(r_key_str), to_js_value(arg->ctx, r_val));
+  return ST_CONTINUE;
+}
+
 JSValue to_js_value(JSContext *ctx, VALUE r_value)
 {
   switch (TYPE(r_value))
@@ -74,6 +91,15 @@ JSValue to_js_value(JSContext *ctx, VALUE r_value)
   }
   case T_SYMBOL:
   {
+    if (r_value == QUICKJSRB_SYM(undefinedId))
+      return JS_UNDEFINED;
+    if (r_value == QUICKJSRB_SYM(nanId))
+    {
+      JSValue j_global = JS_GetGlobalObject(ctx);
+      JSValue j_nan = JS_GetPropertyStr(ctx, j_global, "NaN");
+      JS_FreeValue(ctx, j_global);
+      return j_nan;
+    }
     VALUE r_str = rb_funcall(r_value, rb_intern("to_s"), 0);
     char *str = StringValueCStr(r_str);
 
@@ -83,14 +109,22 @@ JSValue to_js_value(JSContext *ctx, VALUE r_value)
     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);
-    char *str = StringValueCStr(r_json_str);
-    JSValue j_parsed = JS_ParseJSON(ctx, str, strlen(str), "<quickjsrb.c>");
-
-    return j_parsed;
+    int len = RARRAY_LEN(r_value);
+    JSValue j_arr = JS_NewArray(ctx);
+    for (int i = 0; i < len; i++)
+    {
+      JS_SetPropertyUint32(ctx, j_arr, (uint32_t)i, to_js_value(ctx, RARRAY_AREF(r_value, i)));
+    }
+    return j_arr;
+  }
+  case T_HASH:
+  {
+    JSValue j_obj = JS_NewObject(ctx);
+    RbHashToJsArg arg = {ctx, j_obj};
+    rb_hash_foreach(r_value, rb_hash_entry_to_js, (VALUE)&arg);
+    return j_obj;
   }
   default:
   {
@@ -157,6 +191,59 @@ VALUE to_r_json(JSContext *ctx, JSValue j_val)
   return r_str;
 }
 
+static int js_is_plain_object(JSContext *ctx, JSValue j_val)
+{
+  JSValue j_proto = JS_GetPrototype(ctx, j_val);
+  if (JS_IsNull(j_proto))
+    return 1; // Object.create(null)
+  JSValue j_global = JS_GetGlobalObject(ctx);
+  JSValue j_Object = JS_GetPropertyStr(ctx, j_global, "Object");
+  JSValue j_Object_proto = JS_GetPropertyStr(ctx, j_Object, "prototype");
+  int result = JS_StrictEq(ctx, j_proto, j_Object_proto);
+  JS_FreeValue(ctx, j_proto);
+  JS_FreeValue(ctx, j_global);
+  JS_FreeValue(ctx, j_Object);
+  JS_FreeValue(ctx, j_Object_proto);
+  return result;
+}
+
+static VALUE js_array_to_rb(JSContext *ctx, JSValue j_val)
+{
+  JSValue j_length = JS_GetPropertyStr(ctx, j_val, "length");
+  uint32_t length = 0;
+  JS_ToUint32(ctx, &length, j_length);
+  JS_FreeValue(ctx, j_length);
+
+  VALUE r_array = rb_ary_new_capa(length);
+  for (uint32_t i = 0; i < length; i++)
+  {
+    JSValue j_elem = JS_GetPropertyUint32(ctx, j_val, i);
+    rb_ary_push(r_array, to_rb_value(ctx, j_elem));
+    JS_FreeValue(ctx, j_elem);
+  }
+  return r_array;
+}
+
+static VALUE js_plain_object_to_rb(JSContext *ctx, JSValue j_val)
+{
+  JSPropertyEnum *ptab;
+  uint32_t plen;
+  if (JS_GetOwnPropertyNames(ctx, &ptab, &plen, j_val, JS_GPN_STRING_MASK | JS_GPN_ENUM_ONLY) < 0)
+    return rb_hash_new();
+
+  VALUE r_hash = rb_hash_new();
+  for (uint32_t i = 0; i < plen; i++)
+  {
+    const char *key = JS_AtomToCString(ctx, ptab[i].atom);
+    JSValue j_prop = JS_GetProperty(ctx, j_val, ptab[i].atom);
+    rb_hash_aset(r_hash, rb_str_new2(key), to_rb_value(ctx, j_prop));
+    JS_FreeCString(ctx, key);
+    JS_FreeValue(ctx, j_prop);
+  }
+  JS_FreePropertyEnum(ctx, ptab, plen);
+  return r_hash;
+}
+
 VALUE to_rb_value(JSContext *ctx, JSValue j_val)
 {
   switch (JS_VALUE_GET_NORM_TAG(j_val))
@@ -200,6 +287,18 @@ VALUE to_rb_value(JSContext *ctx, JSValue j_val)
       return Qnil;
     }
 
+    if (JS_IsFunction(ctx, j_val))
+    {
+      JSValue j_toStringFunc = JS_GetPropertyStr(ctx, j_val, "toString");
+      JSValue j_source = JS_Call(ctx, j_toStringFunc, j_val, 0, NULL);
+      JS_FreeValue(ctx, j_toStringFunc);
+      const char *source = JS_ToCString(ctx, j_source);
+      JS_FreeValue(ctx, j_source);
+      VALUE r_source = rb_str_new2(source);
+      JS_FreeCString(ctx, source);
+      return rb_funcall(rb_path2class("Quickjs::Function"), rb_intern("new"), 1, r_source);
+    }
+
     if (JS_IsError(ctx, j_val))
     {
       VALUE r_maybe_ruby_error = find_ruby_error(ctx, j_val);
@@ -239,6 +338,13 @@ VALUE to_rb_value(JSContext *ctx, JSValue j_val)
         return r_maybe_file;
     }
 
+    if (JS_IsArray(ctx, j_val))
+      return js_array_to_rb(ctx, j_val);
+
+    if (js_is_plain_object(ctx, j_val))
+      return js_plain_object_to_rb(ctx, j_val);
+
+    // Fallback: non-plain objects (Date, RegExp, Map, class instances, functions, etc.)
     VALUE r_str = to_r_json(ctx, j_val);
 
     if (rb_funcall(r_str, rb_intern("=="), 1, rb_str_new2("undefined")))
@@ -769,33 +875,117 @@ static VALUE vm_m_defineGlobalFunction(int argc, VALUE *argv, VALUE r_self)
   VALUE r_block;
   rb_scan_args(argc, argv, "10*&", &r_name, &r_flags, &r_block);
 
-  if (!(SYMBOL_P(r_name) || RB_TYPE_P(r_name, T_STRING)))
-  {
-    rb_raise(rb_eTypeError, "function's name should be a Symbol or a String");
-  }
-
   VMData *data;
   TypedData_Get_Struct(r_self, VMData, &vm_type, data);
 
-  VALUE r_name_sym = rb_funcall(r_name, rb_intern("to_sym"), 0);
+  if (RB_TYPE_P(r_name, T_ARRAY))
+  {
+    long path_len = RARRAY_LEN(r_name);
+    if (path_len < 1)
+      rb_raise(rb_eArgError, "function's path array must not be empty");
 
-  rb_hash_aset(data->defined_functions, r_name_sym, r_block);
-  VALUE r_name_str = rb_funcall(r_name, rb_intern("to_s"), 0);
-  char *funcName = StringValueCStr(r_name_str);
+    for (long i = 0; i < path_len; i++)
+    {
+      VALUE r_seg = RARRAY_AREF(r_name, i);
+      if (!(SYMBOL_P(r_seg) || RB_TYPE_P(r_seg, T_STRING)))
+        rb_raise(rb_eTypeError, "function's name should be a Symbol or a String");
+    }
 
-  JSValueConst ruby_data[2];
-  ruby_data[0] = JS_NewString(data->context, funcName);
-  ruby_data[1] = JS_NewBool(data->context, RTEST(rb_funcall(r_flags, rb_intern("include?"), 1, ID2SYM(rb_intern("async")))));
+    // Build internal lookup key by joining path segments with "."
+    // e.g. ["myLib", "hello"] -> :"myLib.hello"
+    VALUE r_segs = rb_ary_new();
+    for (long i = 0; i < path_len; i++)
+      rb_ary_push(r_segs, rb_funcall(RARRAY_AREF(r_name, i), rb_intern("to_s"), 0));
+    VALUE r_key_str = rb_funcall(r_segs, rb_intern("join"), 1, rb_str_new2("."));
+    VALUE r_key_sym = rb_funcall(r_key_str, rb_intern("to_sym"), 0);
+    rb_hash_aset(data->defined_functions, r_key_sym, r_block);
+
+    VALUE r_func_seg_str = rb_funcall(RARRAY_AREF(r_name, path_len - 1), rb_intern("to_s"), 0);
+    char *funcName = StringValueCStr(r_func_seg_str);
+
+    JSValueConst ruby_data[2];
+    ruby_data[0] = JS_NewString(data->context, StringValueCStr(r_key_str));
+    ruby_data[1] = JS_NewBool(data->context, RTEST(rb_funcall(r_flags, rb_intern("include?"), 1, ID2SYM(rb_intern("async")))));
+
+    // Resolve the parent object to attach the function to.
+    // For a single-element array, parent is the global object.
+    // For multi-element arrays, traverse path[0..n-2] using JS_Eval for the first
+    // segment (so lexical const/let bindings are resolved, not just global properties)
+    // and JS_GetPropertyStr for subsequent segments.
+    JSValue j_parent;
+    if (path_len == 1)
+    {
+      j_parent = JS_GetGlobalObject(data->context);
+    }
+    else
+    {
+      VALUE r_first_str = rb_funcall(RARRAY_AREF(r_name, 0), rb_intern("to_s"), 0);
+      const char *first_seg = StringValueCStr(r_first_str);
+      j_parent = JS_Eval(data->context, first_seg, strlen(first_seg), "<vm>", JS_EVAL_TYPE_GLOBAL);
 
-  JSValue j_global = JS_GetGlobalObject(data->context);
-  JS_SetPropertyStr(
-      data->context, j_global, funcName,
-      JS_NewCFunctionData(data->context, js_quickjsrb_call_global, 1, 0, 2, ruby_data));
-  JS_FreeValue(data->context, j_global);
-  JS_FreeValue(data->context, ruby_data[0]);
-  JS_FreeValue(data->context, ruby_data[1]);
+      if (JS_IsException(j_parent) || !JS_IsObject(j_parent))
+      {
+        JS_FreeValue(data->context, j_parent);
+        JS_FreeValue(data->context, ruby_data[0]);
+        JS_FreeValue(data->context, ruby_data[1]);
+        rb_raise(rb_eArgError, "cannot define function: '%s' is not an object", first_seg);
+      }
+
+      for (long i = 1; i < path_len - 1; i++)
+      {
+        VALUE r_seg_str = rb_funcall(RARRAY_AREF(r_name, i), rb_intern("to_s"), 0);
+        JSValue j_next = JS_GetPropertyStr(data->context, j_parent, StringValueCStr(r_seg_str));
+        JS_FreeValue(data->context, j_parent);
 
-  return r_name_sym;
+        if (JS_IsException(j_next) || !JS_IsObject(j_next))
+        {
+          JS_FreeValue(data->context, j_next);
+          JS_FreeValue(data->context, ruby_data[0]);
+          JS_FreeValue(data->context, ruby_data[1]);
+          rb_raise(rb_eArgError, "cannot define function: '%s' is not an object", StringValueCStr(r_seg_str));
+        }
+        j_parent = j_next;
+      }
+    }
+
+    JS_SetPropertyStr(
+        data->context, j_parent, funcName,
+        JS_NewCFunctionData(data->context, js_quickjsrb_call_global, 1, 0, 2, ruby_data));
+    JS_FreeValue(data->context, j_parent);
+    JS_FreeValue(data->context, ruby_data[0]);
+    JS_FreeValue(data->context, ruby_data[1]);
+
+    VALUE r_result = rb_ary_new();
+    for (long i = 0; i < path_len; i++)
+      rb_ary_push(r_result, rb_funcall(RARRAY_AREF(r_name, i), rb_intern("to_sym"), 0));
+    return r_result;
+  }
+  else if (SYMBOL_P(r_name) || RB_TYPE_P(r_name, T_STRING))
+  {
+    VALUE r_name_sym = rb_funcall(r_name, rb_intern("to_sym"), 0);
+
+    rb_hash_aset(data->defined_functions, r_name_sym, r_block);
+    VALUE r_name_str = rb_funcall(r_name, rb_intern("to_s"), 0);
+    char *funcName = StringValueCStr(r_name_str);
+
+    JSValueConst ruby_data[2];
+    ruby_data[0] = JS_NewString(data->context, funcName);
+    ruby_data[1] = JS_NewBool(data->context, RTEST(rb_funcall(r_flags, rb_intern("include?"), 1, ID2SYM(rb_intern("async")))));
+
+    JSValue j_global = JS_GetGlobalObject(data->context);
+    JS_SetPropertyStr(
+        data->context, j_global, funcName,
+        JS_NewCFunctionData(data->context, js_quickjsrb_call_global, 1, 0, 2, ruby_data));
+    JS_FreeValue(data->context, j_global);
+    JS_FreeValue(data->context, ruby_data[0]);
+    JS_FreeValue(data->context, ruby_data[1]);
+
+    return r_name_sym;
+  }
+  else
+  {
+    rb_raise(rb_eTypeError, "function's name should be a Symbol or a String");
+  }
 }
 
 static VALUE vm_m_callGlobalFunction(int argc, VALUE *argv, VALUE r_self)

data/lib/quickjs/function.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Quickjs
+  class Function
+    def initialize(source)
+      @source = source
+    end
+
+    def source
+      @source
+    end
+
+    def call(*args, on: nil)
+      case on
+      when Quickjs::VM
+        _call_on(on, args)
+      when nil, Hash
+        vm = Quickjs::VM.new(**on || {})
+        res = _call_on(vm, args)
+        vm = nil
+        res
+      else
+        raise ArgumentError, 'on: must be a Quickjs::VM, a Hash of VM options, or nil'
+      end
+    end
+
+    private
+
+    def _call_on(vm, args)
+      args_js = args.map { |a| JSON.generate(a) }.join(', ')
+      vm.eval_code("(#{@source})(#{args_js})")
+    end
+  end
+end

data/lib/quickjs/version.rb

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

data/lib/quickjs.rb

@@ -5,6 +5,7 @@ require "timeout"
 require_relative "quickjs/version"
 require_relative "quickjs/subtle_crypto"
 require_relative "quickjs/crypto_key"
+require_relative "quickjs/function"
 require_relative "quickjs/quickjsrb"
 
 module Quickjs

data/polyfills/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "quickjs-rb-polyfills",
-  "version": "0.14.0",
+  "version": "0.15.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "quickjs-rb-polyfills",
-      "version": "0.14.0",
+      "version": "0.15.0",
       "dependencies": {
         "@formatjs/intl-datetimeformat": "^7.3.1",
         "@formatjs/intl-getcanonicallocales": "^3.2.2",

data/polyfills/package.json

@@ -1,6 +1,6 @@
 {
   "name": "quickjs-rb-polyfills",
-  "version": "0.14.0",
+  "version": "0.15.0",
   "private": true,
   "scripts": {
     "build": "rolldown -c rolldown.config.mjs",

data/sig/quickjs.rbs

@@ -26,6 +26,7 @@ module Quickjs
     def call: (String | Symbol name, *untyped args) -> untyped
 
     def define_function: (String | Symbol name, *Symbol flags) { (*untyped) -> untyped } -> Symbol
+                       | (Array[String | Symbol] path, *Symbol flags) { (*untyped) -> untyped } -> Array[Symbol]
 
     def import: (String | Array[String] | Hash[Symbol, String] imported, from: String, ?code_to_expose: String?) -> true
 
@@ -42,6 +43,14 @@ module Quickjs
     end
   end
 
+  class Function
+    def initialize: (String source) -> void
+
+    def source: () -> String
+
+    def call: (*untyped args, ?on: VM | Hash[Symbol, untyped] | nil) -> untyped
+  end
+
   class RuntimeError < ::RuntimeError
     def initialize: (String message, String? js_name) -> void
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: quickjs
 version: !ruby/object:Gem::Version
-  version: 0.14.0
+  version: 0.15.0
 platform: ruby
 authors:
 - hmsk
@@ -90,6 +90,7 @@ files:
 - ext/quickjsrb/vendor/polyfill-url.min.js
 - lib/quickjs.rb
 - lib/quickjs/crypto_key.rb
+- lib/quickjs/function.rb
 - lib/quickjs/subtle_crypto.rb
 - lib/quickjs/version.rb
 - polyfills/check-licenses.mjs