mini_racer 0.18.1 → 0.19.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d136b28eba55fb9518691cd3dc38a0e95af3171d6d1796c7e892ce411023cfe6
-  data.tar.gz: '07829f6048ef890b28574629b94f0371f441fcef176cb3c70c78da266280dd1f'
+  metadata.gz: 8c2110c8c14882bd775ad556afdeb79e1ab42bfabddc24101b82f8390a5be830
+  data.tar.gz: 8c70e50ac0edbe545ddd0a17737c045f21ebd6a2aa47f8d730a7f7ced79248b3
 SHA512:
-  metadata.gz: a0a80d3d34ba093a39f95fea716048c448800515667a426558fe00d6ffbd70614a375b64c2be923750d57e868c01a959c4396ab5c9afd25e0caefd2816ca4a82
-  data.tar.gz: a3d7655f8f1ec369a1f279f8d983098d4f8fac381e6404116a0d72133e32a06f8c99309001d33628a440085b7b36079bcba318ae6dedd1a1eff0f381e6b8b9d4
+  metadata.gz: e8b17ae50c4455ed2c3db185f5e03d9554bb30096fc1540989cc7aa0e56f471ade5a7d0f815f1a24b3e492cd9c8c7db80bb5146bcf52dfdcb707caaf7323daaa
+  data.tar.gz: f1ef6b7225779091ab4c488f0177da8b7d8dd19e779d80a99ae307e9efbfd49e654c645f76315c4b766090cc50ce7f2ec2568586432a122d7d7aef3f7ba93d0d

data/CHANGELOG

@@ -1,3 +1,11 @@
+- 0.19.1 - 20-10-2025
+  - JS code can now catch ruby exceptions - Ben Noordhuis
+  - Retain string encoding when raising exceptions - Ben Noordhuis
+  - Fix object identity bug with Ruby to JS conversion - Benjamin Wood
+
+- 0.19.0 - 24-06-2025
+  - upgrade to node 24.1.0 
+
 - 0.18.1 - 03-04-2025
   - Convert round doubles to fixnum for very big floats - this has better parity with JavaScript - Ben Noorhuis
 

data/ext/mini_racer_extension/mini_racer_extension.c

@@ -13,6 +13,13 @@
 #include "serde.c"
 #include "mini_racer_v8.h"
 
+// for debugging
+#define RB_PUTS(v)                                          \
+    do {                                                    \
+        fflush(stdout);                                     \
+        rb_funcall(rb_mKernel, rb_intern("puts"), 1, v);    \
+    } while (0)
+
 #if RUBY_API_VERSION_CODE < 3*10000+4*100 // 3.4.0
 static inline void rb_thread_lock_native_thread(void)
 {
@@ -154,6 +161,7 @@ static VALUE platform_init_error;
 static VALUE context_disposed_error;
 static VALUE parse_error;
 static VALUE memory_error;
+static VALUE script_error;
 static VALUE runtime_error;
 static VALUE internal_error;
 static VALUE snapshot_error;
@@ -327,8 +335,19 @@ static void des_bigint(void *arg, const void *p, size_t n, int sign)
     if (t >> 63)
         *a++ = 0; // suppress sign extension
     v = rb_big_unpack(limbs, a-limbs);
-    if (sign < 0)
-        v = rb_big_mul(v, LONG2FIX(-1));
+    if (sign < 0) {
+        // rb_big_unpack returns T_FIXNUM for smallish bignums
+        switch (TYPE(v)) {
+        case T_BIGNUM:
+            v = rb_big_mul(v, LONG2FIX(-1));
+            break;
+        case T_FIXNUM:
+            v = LONG2FIX(-1 * FIX2LONG(v));
+            break;
+        default:
+            abort();
+        }
+    }
     put(c, v);
 }
 
@@ -471,12 +490,36 @@ static void des_object_ref(void *arg, uint32_t id)
 
 static void des_error_begin(void *arg)
 {
-    push(arg, rb_class_new_instance(0, NULL, rb_eRuntimeError));
+    push(arg, rb_ary_new());
 }
 
 static void des_error_end(void *arg)
 {
-    pop(arg);
+    VALUE *a, h, message, stack, cause, newline;
+    DesCtx *c;
+
+    c = arg;
+    if (*c->err)
+        return;
+    if (c->tos == c->stack) {
+        snprintf(c->err, sizeof(c->err), "stack underflow");
+        return;
+    }
+    a = &c->tos->a;
+    h = rb_ary_pop(*a);
+    message = rb_hash_aref(h, rb_str_new_cstr("message"));
+    stack = rb_hash_aref(h, rb_str_new_cstr("stack"));
+    cause = rb_hash_aref(h, rb_str_new_cstr("cause"));
+    if (NIL_P(message))
+        message = rb_str_new_cstr("JS exception");
+    if (!NIL_P(stack)) {
+        newline = rb_str_new_cstr("\n");
+        message = rb_funcall(message, rb_intern("concat"), 2, newline, stack);
+    }
+    *a = rb_class_new_instance(1, &message, script_error);
+    if (!NIL_P(cause))
+        rb_iv_set(*a, "@cause", cause);
+    pop(c);
 }
 
 static int collect(VALUE k, VALUE v, VALUE a)
@@ -516,52 +559,58 @@ static int serialize1(Ser *s, VALUE refs, VALUE v)
         return -1;
     switch (TYPE(v)) {
     case T_ARRAY:
-        id = rb_hash_lookup(refs, v);
-        if (NIL_P(id)) {
-            n = RARRAY_LENINT(v);
-            i = rb_hash_size_num(refs);
-            rb_hash_aset(refs, v, LONG2FIX(i));
-            ser_array_begin(s, n);
-            for (i = 0; i < n; i++)
-                if (serialize1(s, refs, rb_ary_entry(v, i)))
-                    return -1;
-            ser_array_end(s, n);
-        } else {
-            ser_object_ref(s, FIX2LONG(id));
+        {
+            VALUE obj_id = rb_obj_id(v);
+            id = rb_hash_lookup(refs, obj_id);
+            if (NIL_P(id)) {
+                n = RARRAY_LENINT(v);
+                i = rb_hash_size_num(refs);
+                rb_hash_aset(refs, obj_id, LONG2FIX(i));
+                ser_array_begin(s, n);
+                for (i = 0; i < n; i++)
+                    if (serialize1(s, refs, rb_ary_entry(v, i)))
+                        return -1;
+                ser_array_end(s, n);
+            } else {
+                ser_object_ref(s, FIX2LONG(id));
+            }
         }
         break;
     case T_HASH:
-        id = rb_hash_lookup(refs, v);
-        if (NIL_P(id)) {
-            a = rb_ary_new();
-            i = rb_hash_size_num(refs);
-            n = rb_hash_size_num(v);
-            rb_hash_aset(refs, v, LONG2FIX(i));
-            rb_hash_foreach(v, collect, a);
-            for (i = 0; i < 2*n; i += 2) {
-                t = rb_ary_entry(a, i);
-                switch (TYPE(t)) {
-                case T_FIXNUM:
-                case T_STRING:
-                case T_SYMBOL:
-                    continue;
-                }
-                break;
-            }
-            if (i == 2*n) {
-                ser_object_begin(s);
+        {
+            VALUE obj_id = rb_obj_id(v);
+            id = rb_hash_lookup(refs, obj_id);
+            if (NIL_P(id)) {
+                a = rb_ary_new();
+                i = rb_hash_size_num(refs);
+                n = rb_hash_size_num(v);
+                rb_hash_aset(refs, obj_id, LONG2FIX(i));
+                rb_hash_foreach(v, collect, a);
                 for (i = 0; i < 2*n; i += 2) {
-                    if (serialize1(s, refs, rb_ary_entry(a, i+0)))
-                        return -1;
-                    if (serialize1(s, refs, rb_ary_entry(a, i+1)))
-                        return -1;
+                    t = rb_ary_entry(a, i);
+                    switch (TYPE(t)) {
+                    case T_FIXNUM:
+                    case T_STRING:
+                    case T_SYMBOL:
+                        continue;
+                    }
+                    break;
+                }
+                if (i == 2*n) {
+                    ser_object_begin(s);
+                    for (i = 0; i < 2*n; i += 2) {
+                        if (serialize1(s, refs, rb_ary_entry(a, i+0)))
+                            return -1;
+                        if (serialize1(s, refs, rb_ary_entry(a, i+1)))
+                            return -1;
+                    }
+                    ser_object_end(s, n);
+                } else {
+                    return bail(&s->err, "TODO serialize as Map");
                 }
-                ser_object_end(s, n);
             } else {
-                return bail(&s->err, "TODO serialize as Map");
+                ser_object_ref(s, FIX2LONG(id));
             }
-        } else {
-            ser_object_ref(s, FIX2LONG(id));
         }
         break;
     case T_DATA:
@@ -620,14 +669,16 @@ static int serialize1(Ser *s, VALUE refs, VALUE v)
             struct timeval tv = rb_time_timeval(v);
             ser_date(s, tv.tv_sec*1e3 + tv.tv_usec/1e3);
         } else {
-	    snprintf(s->err, sizeof(s->err), "unsupported type %s", rb_class2name(CLASS_OF(v)));
-	    return -1;
+            snprintf(s->err, sizeof(s->err), "unsupported type %s", rb_class2name(CLASS_OF(v)));
+            return -1;
         }
         break;
     default:
         snprintf(s->err, sizeof(s->err), "unsupported type %x", TYPE(v));
         return -1;
     }
+    if (*s->err)
+        return -1;
     return 0;
 }
 
@@ -875,6 +926,7 @@ static VALUE rendezvous_callback_do(VALUE arg)
 static void *rendezvous_callback(void *arg)
 {
     struct rendezvous_nogvl *a;
+    const char *err;
     Context *c;
     int exc;
     VALUE r;
@@ -898,7 +950,12 @@ out:
     buf_move(&s.b, a->req);
     return NULL;
 fail:
-    ser_init1(&s, 'e'); // exception pending
+    ser_init0(&s);   // ruby exception pending
+    w_byte(&s, 'e'); // send ruby error message to v8 thread
+    r = rb_funcall(c->exception, rb_intern("to_s"), 0);
+    err = StringValueCStr(r);
+    if (err)
+        w(&s, err, strlen(err));
     goto out;
 }
 
@@ -956,6 +1013,13 @@ static VALUE rendezvous1(Context *c, Buf *req, DesCtx *d)
     int exc;
 
     rendezvous_no_des(c, req, &res); // takes ownership of |req|
+    r = c->exception;
+    c->exception = Qnil;
+    // if js land didn't handle exception from ruby callback, re-raise it now
+    if (res.len == 1 && *res.buf == 'e') {
+        assert(!NIL_P(r));
+        rb_exc_raise(r);
+    }
     r = rb_protect(deserialize, (VALUE)&(struct rendezvous_des){d, &res}, &exc);
     buf_reset(&res);
     if (exc) {
@@ -963,11 +1027,6 @@ static VALUE rendezvous1(Context *c, Buf *req, DesCtx *d)
         rb_set_errinfo(Qnil);
         rb_exc_raise(r);
     }
-    if (!NIL_P(c->exception)) {
-        r = c->exception;
-        c->exception = Qnil;
-        rb_exc_raise(r);
-    }
     return r;
 }
 
@@ -986,8 +1045,8 @@ static void handle_exception(VALUE e)
 
     if (NIL_P(e))
         return;
-    StringValue(e);
-    s = RSTRING_PTR(e);
+    e = StringValue(e);
+    s = StringValueCStr(e);
     switch (*s) {
     case NO_ERROR:
         return;
@@ -1009,7 +1068,7 @@ static void handle_exception(VALUE e)
     default:
         rb_raise(internal_error, "bad error class %02x", *s);
     }
-    rb_raise(klass, "%s", s+1);
+    rb_enc_raise(rb_enc_get(e), klass, "%s", s+1);
 }
 
 static VALUE context_alloc(VALUE klass)
@@ -1615,6 +1674,11 @@ static VALUE snapshot_size0(VALUE self)
     return LONG2FIX(RSTRING_LENINT(ss->blob));
 }
 
+static VALUE script_error_cause(VALUE self)
+{
+    return rb_iv_get(self, "@cause");
+}
+
 __attribute__((visibility("default")))
 void Init_mini_racer_extension(void)
 {
@@ -1629,10 +1693,13 @@ void Init_mini_racer_extension(void)
     c = rb_define_class_under(m, "EvalError", c);
     parse_error = rb_define_class_under(m, "ParseError", c);
     memory_error = rb_define_class_under(m, "V8OutOfMemoryError", c);
+    script_error = rb_define_class_under(m, "ScriptError", c);
     runtime_error = rb_define_class_under(m, "RuntimeError", c);
     internal_error = rb_define_class_under(m, "InternalError", c);
     terminated_error = rb_define_class_under(m, "ScriptTerminatedError", c);
 
+    rb_define_method(script_error, "cause", script_error_cause, 0);
+
     c = context_class = rb_define_class_under(m, "Context", rb_cObject);
     rb_define_method(c, "initialize", context_initialize, -1);
     rb_define_method(c, "attach", context_attach, 2);

data/ext/mini_racer_extension/mini_racer_v8.cc

@@ -86,6 +86,7 @@ struct State
     v8::Persistent<v8::Context> persistent_context;         // single-thread mode only
     v8::Persistent<v8::Context> persistent_safe_context;    // single-thread mode only
     v8::Persistent<v8::Function> persistent_safe_context_function;  // single-thread mode only
+    v8::Persistent<v8::Value> ruby_exception;
     Context *ruby_context;
     int64_t max_memory;
     int err_reason;
@@ -122,6 +123,20 @@ struct Serialized
     }
 };
 
+bool bubble_up_ruby_exception(State& st, v8::TryCatch *try_catch)
+{
+    auto exception = try_catch->Exception();
+    if (exception.IsEmpty()) return false;
+    auto ruby_exception = v8::Local<v8::Value>::New(st.isolate, st.ruby_exception);
+    if (ruby_exception.IsEmpty()) return false;
+    if (!ruby_exception->SameValue(exception)) return false;
+    // signal that the ruby thread should reraise the exception
+    // that it caught earlier when executing a js->ruby callback
+    uint8_t c = 'e';
+    v8_reply(st.ruby_context, &c, 1);
+    return true;
+}
+
 // throws JS exception on serialization error
 bool reply(State& st, v8::Local<v8::Value> v)
 {
@@ -388,8 +403,17 @@ void v8_api_callback(const v8::FunctionCallbackInfo<v8::Value>& info)
         v8_roundtrip(st.ruby_context, &p, &n);
         if (*p == 'c') // callback reply
             break;
-        if (*p == 'e') // ruby exception pending
-            return st.isolate->TerminateExecution();
+        if (*p == 'e') { // ruby exception pending
+            v8::Local<v8::String> message;
+            auto type = v8::NewStringType::kNormal;
+            if (!v8::String::NewFromOneByte(st.isolate, p+1, type, n-1).ToLocal(&message)) {
+                message = v8::String::NewFromUtf8Literal(st.isolate, "Ruby exception");
+            }
+            auto exception = v8::Exception::Error(message);
+            st.ruby_exception.Reset(st.isolate, exception);
+            st.isolate->ThrowException(exception);
+            return;
+        }
         v8_dispatch(st.ruby_context);
     }
     v8::ValueDeserializer des(st.isolate, p+1, n-1);
@@ -523,6 +547,7 @@ fail:
         cause = st.err_reason ? st.err_reason : TERMINATED_ERROR;
         st.err_reason = NO_ERROR;
     }
+    if (bubble_up_ruby_exception(st, &try_catch)) return;
     if (!cause && try_catch.HasCaught()) cause = RUNTIME_ERROR;
     if (cause) result = v8::Undefined(st.isolate);
     auto err = to_error(st, &try_catch, cause);
@@ -571,6 +596,7 @@ fail:
         cause = st.err_reason ? st.err_reason : TERMINATED_ERROR;
         st.err_reason = NO_ERROR;
     }
+    if (bubble_up_ruby_exception(st, &try_catch)) return;
     if (!cause && try_catch.HasCaught()) cause = RUNTIME_ERROR;
     if (cause) result = v8::Undefined(st.isolate);
     auto err = to_error(st, &try_catch, cause);
@@ -895,6 +921,7 @@ State::~State()
         v8::Isolate::Scope isolate_scope(isolate);
         persistent_safe_context.Reset();
         persistent_context.Reset();
+        ruby_exception.Reset();
     }
     isolate->Dispose();
     for (Callback *cb : callbacks)

data/ext/mini_racer_extension/serde.c

@@ -194,17 +194,21 @@ static inline int r_zigzag(const uint8_t **p, const uint8_t *pe, int64_t *r)
     return 0;
 }
 
-static inline void ser_init(Ser *s)
+static void ser_init0(Ser *s)
 {
     memset(s, 0, sizeof(*s));
     buf_init(&s->b);
+}
+
+static inline void ser_init(Ser *s)
+{
+    ser_init0(s);
     w(s, "\xFF\x0F", 2);
 }
 
 static void ser_init1(Ser *s, uint8_t c)
 {
-    memset(s, 0, sizeof(*s));
-    buf_init(&s->b);
+    ser_init0(s);
     w_byte(s, c);
     w(s, "\xFF\x0F", 2);
 }
@@ -239,15 +243,44 @@ static void ser_num(Ser *s, double v)
     }
 }
 
+// ser_bigint: |n| is in bytes, not quadwords
+static void ser_bigint(Ser *s, const uint64_t *p, size_t n, int sign)
+{
+    if (*s->err)
+        return;
+    if (n % 8) {
+        snprintf(s->err, sizeof(s->err), "bad bigint");
+        return;
+    }
+    w_byte(s, 'Z');
+    // chop off high all-zero words
+    n /= 8;
+    while (n--)
+        if (p[n])
+            break;
+    if (n == (size_t)-1) {
+        w_byte(s, 0); // normalized zero
+    } else {
+        n = 8*n + 8;
+        w_varint(s, 2*n + (sign < 0));
+        w(s, p, n);
+    }
+}
+
 static void ser_int(Ser *s, int64_t v)
 {
+    uint64_t t;
+    int sign;
+
     if (*s->err)
         return;
     if (v < INT32_MIN || v > INT32_MAX) {
         if (v > INT64_MIN/1024)
             if (v <= INT64_MAX/1024)
                 return ser_num(s, v);
-        snprintf(s->err, sizeof(s->err), "out of range: %lld", (long long)v);
+        t = v < 0 ? -v : v;
+        sign = v < 0 ? -1 : 1;
+        ser_bigint(s, &t, sizeof(t), sign);
     } else {
         w_byte(s, 'I');
         w_zigzag(s, v);
@@ -265,30 +298,6 @@ static void ser_date(Ser *s, double v)
     }
 }
 
-// ser_bigint: |n| is in bytes, not quadwords
-static void ser_bigint(Ser *s, const uint64_t *p, size_t n, int sign)
-{
-    if (*s->err)
-        return;
-    if (n % 8) {
-        snprintf(s->err, sizeof(s->err), "bad bigint");
-        return;
-    }
-    w_byte(s, 'Z');
-    // chop off high all-zero words
-    n /= 8;
-    while (n--)
-        if (p[n])
-            break;
-    if (n == (size_t)-1) {
-        w_byte(s, 0); // normalized zero
-    } else {
-        n = 8*n + 8;
-        w_varint(s, 2*n + (sign < 0));
-        w(s, p, n);
-    }
-}
-
 // string must be utf8
 static void ser_string(Ser *s, const char *p, size_t n)
 {

data/lib/mini_racer/truffleruby.rb

@@ -246,6 +246,10 @@ module MiniRacer
           js_map_to_hash(value)
         elsif map_iterator?(value)
           value.map { |e| convert_js_to_ruby(e) }
+        elsif Polyglot::ForeignException === value
+          exc = MiniRacer::ScriptError.new(value.message)
+          exc.set_backtrace(value.backtrace)
+          exc
         else
           object = value
           h = {}

data/lib/mini_racer/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module MiniRacer
-  VERSION = "0.18.1"
-  LIBV8_NODE_VERSION = "~> 23.6.1.0"
+  VERSION = "0.19.1"
+  LIBV8_NODE_VERSION = "~> 24.1.0.0"
 end

data/lib/mini_racer.rb

@@ -51,6 +51,19 @@ module MiniRacer
     end
   end
 
+  class ScriptError < EvalError
+    def initialize(message)
+      message, *@frames = message.split("\n")
+      @frames.map! { "JavaScript #{_1.strip}" }
+      super(message)
+    end
+
+    def backtrace
+      frames = super || []
+      @frames + frames
+    end
+  end
+
   class SnapshotError < Error
     def initialize(message)
       message, *@frames = message.split("\n")

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mini_racer
 version: !ruby/object:Gem::Version
-  version: 0.18.1
+  version: 0.19.1
 platform: ruby
 authors:
 - Sam Saffron
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-04-03 00:00:00.000000000 Z
+date: 2025-10-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -100,14 +100,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 23.6.1.0
+        version: 24.1.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 23.6.1.0
+        version: 24.1.0.0
 description: Minimal embedded v8 engine for Ruby
 email:
 - sam.saffron@gmail.com
@@ -137,9 +137,9 @@ licenses:
 - MIT
 metadata:
   bug_tracker_uri: https://github.com/discourse/mini_racer/issues
-  changelog_uri: https://github.com/discourse/mini_racer/blob/v0.18.1/CHANGELOG
-  documentation_uri: https://www.rubydoc.info/gems/mini_racer/0.18.1
-  source_code_uri: https://github.com/discourse/mini_racer/tree/v0.18.1
+  changelog_uri: https://github.com/discourse/mini_racer/blob/v0.19.1/CHANGELOG
+  documentation_uri: https://www.rubydoc.info/gems/mini_racer/0.19.1
+  source_code_uri: https://github.com/discourse/mini_racer/tree/v0.19.1
 post_install_message:
 rdoc_options: []
 require_paths: