mini_racer 0.6.0 → 0.6.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 179c0a63082cf1ec6bc7f8ead94fbcba3c41255ee91b1639482570d1ec3f7646
-  data.tar.gz: cdef6f06a6ab72060aa43b21518c6f0103bf80c034bee09b7cf1d6f215620c31
+  metadata.gz: e832863760637f983976194ebef263d8815c149d48ff26c7200367ab33640dda
+  data.tar.gz: 7c1c393ae6403a75d2a413395d56e7d5f3affe706b81c121273b4c6b5d471bf4
 SHA512:
-  metadata.gz: 0efd1873f139141ac489ed24ebcad3e289092ea67ea7823d0b94fe07a3acfcd602ed64c287b39b556d370db5c17b094d38a9c5ff06f31f546dddda7694d01c81
-  data.tar.gz: 1ccc24b53320211be2b3cd887ac1193ee0654e0b54c0d2b3da636a382ce00c95d4af3ba5acd23a931436d08e0707dc0b4d348b6bbd0863cb56df9fb2fbd2678e
+  metadata.gz: 4504cb3a564e5b311b65de74bac321b058995af17df47f9f3dc01fcb589a87eebfda55497e0ddb135a2ab15ef1818760652561d434d3f497c0dbd036451934c6
+  data.tar.gz: b83df123a61092ab4041212bb6e4f15b276d5e32e8be8d2b5cbc014988b8cf20ed0e0b3b30595de53ca4c0d599a86112d695009cda13891fe177742aff7d911e

data/CHANGELOG

@@ -1,5 +1,20 @@
+- 17-01-2021
+
+- 0.6.2
+
+  - Fix support for compilation on 2.6, llvm compiles
+  - Stability patches to handle rare memory leaks
+  - Corrected re-raising of exceptions to support strings
+  - During early termination of context under certain conditions MiniRacer could crash
+
+
 - 31-12-2021
 
+- 0.6.1
+
+  - Added support for single threaded platform: `MiniRacer::Platform.set_flags! :single_threaded`
+  must be called prior to booting ANY MiniRacer::Context
+
 - 0.6.0
 
    - Ruby 3.1 support
@@ -13,7 +28,6 @@
   - Fixes issues on aarch (Apple M1)
   - Update to use libv8-node 16.x (#210) [Loic Nageleisen]
   - FEATURE: Configurable max marshal stack depth (#202) [seanmakesgames]
-  - FEATURE: Configurable max marshal stack depth (#202) [seanmakesgames]
   - Ruby 2.3 and 2.4 are EOL, we no longer support them
 
 - 0.4.0

data/ext/mini_racer_extension/extconf.rb

@@ -75,4 +75,9 @@ if enable_config('asan')
   $LDFLAGS.insert(0, " -fsanitize=address ")
 end
 
+# there doesn't seem to be a CPP macro for this in Ruby 2.6:
+if RUBY_ENGINE == 'ruby'
+  $CPPFLAGS += ' -DENGINE_IS_CRUBY '
+end
+
 create_makefile 'mini_racer_extension'

data/ext/mini_racer_extension/mini_racer_extension.cc

@@ -2,6 +2,7 @@
 #include <ruby.h>
 #include <ruby/thread.h>
 #include <ruby/io.h>
+#include <ruby/version.h>
 #include <v8.h>
 #include <v8-profiler.h>
 #include <libplatform/libplatform.h>
@@ -13,6 +14,14 @@
 #include <math.h>
 #include <errno.h>
 
+/* workaround C Ruby <= 2.x problems w/ clang in C++ mode */
+#if defined(ENGINE_IS_CRUBY) && \
+	RUBY_API_VERSION_MAJOR == 2 && RUBY_API_VERSION_MINOR <= 6
+#  define MR_METHOD_FUNC(fn) RUBY_METHOD_FUNC(fn)
+#else
+#  define MR_METHOD_FUNC(fn) fn
+#endif
+
 using namespace v8;
 
 typedef struct {
@@ -337,7 +346,7 @@ static VALUE rb_platform_set_flag_as_str(VALUE _klass, VALUE flag_as_str) {
 	if (!strcmp(RSTRING_PTR(flag_as_str), "--single_threaded")) {
 	   single_threaded = true;
 	}
-        V8::SetFlagsFromString(RSTRING_PTR(flag_as_str), (int)RSTRING_LEN(flag_as_str));
+        V8::SetFlagsFromString(RSTRING_PTR(flag_as_str), RSTRING_LENINT(flag_as_str));
     } else {
         platform_already_initialized = true;
     }
@@ -360,7 +369,11 @@ static void init_v8() {
 
     if (current_platform == NULL) {
         V8::InitializeICU();
-        current_platform = platform::NewDefaultPlatform();
+	if (single_threaded) {
+	    current_platform = platform::NewSingleThreadedDefaultPlatform();
+	} else {
+	    current_platform = platform::NewDefaultPlatform();
+	}
         V8::InitializePlatform(current_platform.get());
         V8::Initialize();
     }
@@ -405,28 +418,32 @@ static void prepare_result(MaybeLocal<Value> v8res,
         Local<Value> local_value = v8res.ToLocalChecked();
         if ((local_value->IsObject() || local_value->IsArray()) &&
                 !local_value->IsDate() && !local_value->IsFunction()) {
-            Local<Object> JSON = context->Global()->Get(
-                        context, String::NewFromUtf8Literal(isolate, "JSON"))
-                    .ToLocalChecked().As<Object>();
-
-            Local<Function> stringify = JSON->Get(
-                        context, v8::String::NewFromUtf8Literal(isolate, "stringify"))
-                    .ToLocalChecked().As<Function>();
+            MaybeLocal<v8::Value> ml = context->Global()->Get(
+                        context, String::NewFromUtf8Literal(isolate, "JSON"));
 
-            Local<Object> object = local_value->ToObject(context).ToLocalChecked();
-            const unsigned argc = 1;
-            Local<Value> argv[argc] = { object };
-            MaybeLocal<Value> json = stringify->Call(context, JSON, argc, argv);
-
-            if (json.IsEmpty()) {
+            if (ml.IsEmpty()) { // exception
                 evalRes.executed = false;
             } else {
-                evalRes.json = true;
-                Persistent<Value>* persistent = new Persistent<Value>();
-                persistent->Reset(isolate, json.ToLocalChecked());
-                evalRes.value = persistent;
+                Local<Object> JSON = ml.ToLocalChecked().As<Object>();
+
+                Local<Function> stringify = JSON->Get(
+                            context, v8::String::NewFromUtf8Literal(isolate, "stringify"))
+                        .ToLocalChecked().As<Function>();
+
+                Local<Object> object = local_value->ToObject(context).ToLocalChecked();
+                const unsigned argc = 1;
+                Local<Value> argv[argc] = { object };
+                MaybeLocal<Value> json = stringify->Call(context, JSON, argc, argv);
+
+                if (json.IsEmpty()) {
+                    evalRes.executed = false;
+                } else {
+                    evalRes.json = true;
+                    Persistent<Value>* persistent = new Persistent<Value>();
+                    persistent->Reset(isolate, json.ToLocalChecked());
+                    evalRes.value = persistent;
+                }
             }
-
         } else {
             Persistent<Value>* persistent = new Persistent<Value>();
             persistent->Reset(isolate, local_value);
@@ -707,7 +724,7 @@ static Local<Value> convert_ruby_to_v8(Isolate* isolate, Local<Context> context,
     case T_FLOAT:
 	return scope.Escape(Number::New(isolate, NUM2DBL(value)));
     case T_STRING:
-	return scope.Escape(String::NewFromUtf8(isolate, RSTRING_PTR(value), NewStringType::kNormal, (int)RSTRING_LEN(value)).ToLocalChecked());
+	return scope.Escape(String::NewFromUtf8(isolate, RSTRING_PTR(value), NewStringType::kNormal, RSTRING_LENINT(value)).ToLocalChecked());
     case T_NIL:
 	return scope.Escape(Null(isolate));
     case T_TRUE:
@@ -735,7 +752,7 @@ static Local<Value> convert_ruby_to_v8(Isolate* isolate, Local<Context> context,
 	return scope.Escape(object);
     case T_SYMBOL:
 	value = rb_funcall(value, rb_intern("to_s"), 0);
-	return scope.Escape(String::NewFromUtf8(isolate, RSTRING_PTR(value), NewStringType::kNormal, (int)RSTRING_LEN(value)).ToLocalChecked());
+	return scope.Escape(String::NewFromUtf8(isolate, RSTRING_PTR(value), NewStringType::kNormal, RSTRING_LENINT(value)).ToLocalChecked());
     case T_DATA:
         klass = rb_funcall(value, rb_intern("class"), 0);
         if (klass == rb_cTime || klass == rb_cDateTime)
@@ -1053,7 +1070,7 @@ static VALUE convert_result_to_ruby(VALUE self /* context */,
     // a v8 scope, if we do the scope is never cleaned up properly and we leak
     if (!result.parsed) {
         if(TYPE(message) == T_STRING) {
-            rb_raise(rb_eParseError, "%s", RSTRING_PTR(message));
+            rb_raise(rb_eParseError, "%" PRIsVALUE, message);
         } else {
             rb_raise(rb_eParseError, "Unknown JavaScript Error during parse");
         }
@@ -1077,15 +1094,17 @@ static VALUE convert_result_to_ruby(VALUE self /* context */,
 
             // exception report about what happened
             if (TYPE(backtrace) == T_STRING) {
-                rb_raise(ruby_exception, "%s", RSTRING_PTR(backtrace));
+                rb_raise(ruby_exception, "%" PRIsVALUE, backtrace);
             } else if(TYPE(message) == T_STRING) {
-                rb_raise(ruby_exception, "%s", RSTRING_PTR(message));
+                rb_raise(ruby_exception, "%" PRIsVALUE, message);
             } else {
                 rb_raise(ruby_exception, "Unknown JavaScript Error during execution");
             }
+        } else if (rb_obj_is_kind_of(ruby_exception, rb_eException)) {
+            rb_exc_raise(ruby_exception);
         } else {
             VALUE rb_str = rb_funcall(ruby_exception, rb_intern("to_s"), 0);
-            rb_raise(CLASS_OF(ruby_exception), "%s", RSTRING_PTR(rb_str));
+            rb_raise(CLASS_OF(ruby_exception), "%" PRIsVALUE, rb_str);
         }
     }
 
@@ -1145,13 +1164,13 @@ static VALUE rb_context_eval_unsafe(VALUE self, VALUE str, VALUE filename) {
         HandleScope handle_scope(isolate);
 
         Local<String> eval = String::NewFromUtf8(isolate, RSTRING_PTR(str),
-                    NewStringType::kNormal, (int)RSTRING_LEN(str)).ToLocalChecked();
+                    NewStringType::kNormal, RSTRING_LENINT(str)).ToLocalChecked();
 
         Local<String> local_filename;
 
         if (filename != Qnil) {
             local_filename = String::NewFromUtf8(isolate, RSTRING_PTR(filename),
-                NewStringType::kNormal, (int)RSTRING_LEN(filename)).ToLocalChecked();
+                NewStringType::kNormal, RSTRING_LENINT(filename)).ToLocalChecked();
             eval_params.filename = &local_filename;
         } else {
             eval_params.filename = NULL;
@@ -1275,8 +1294,8 @@ gvl_ruby_callback(void* data) {
     VALUE callback_data_value = (VALUE)&callback_data;
 
     // TODO: use rb_vrescue2 in Ruby 2.7 and above
-    result = rb_rescue2(protected_callback, callback_data_value,
-            rescue_callback, callback_data_value, rb_eException, (VALUE)0);
+    result = rb_rescue2(MR_METHOD_FUNC(protected_callback), callback_data_value,
+            MR_METHOD_FUNC(rescue_callback), callback_data_value, rb_eException, (VALUE)0);
 
     if(callback_data.failed) {
         rb_iv_set(parent, "@current_exception", result);
@@ -1337,7 +1356,7 @@ static VALUE rb_external_function_notify_v8(VALUE self) {
 
         Local<String> v8_str =
             String::NewFromUtf8(isolate, RSTRING_PTR(name),
-                                NewStringType::kNormal, (int)RSTRING_LEN(name))
+                                NewStringType::kNormal, RSTRING_LENINT(name))
                 .ToLocalChecked();
 
         // Note that self (rb_cExternalFunction) is a pure Ruby T_OBJECT,
@@ -1357,7 +1376,7 @@ static VALUE rb_external_function_notify_v8(VALUE self) {
             Local<String> eval =
                 String::NewFromUtf8(isolate, RSTRING_PTR(parent_object_eval),
                                     NewStringType::kNormal,
-                                    (int)RSTRING_LEN(parent_object_eval))
+                                    RSTRING_LENINT(parent_object_eval))
                     .ToLocalChecked();
 
             MaybeLocal<Script> parsed_script = Script::Compile(context, eval);
@@ -1816,23 +1835,15 @@ static VALUE rb_context_call_unsafe(int argc, VALUE *argv, VALUE self) {
         if (val.IsEmpty() || !val.ToLocalChecked()->IsFunction()) {
             missingFunction = true;
         } else {
-
             Local<v8::Function> fun = Local<v8::Function>::Cast(val.ToLocalChecked());
+            VALUE tmp;
             call.fun = fun;
-            int fun_argc = call.argc;
-
-            if (fun_argc > 0) {
-                call.argv = (v8::Local<Value> *) malloc(sizeof(void *) * fun_argc);
-                if (!call.argv) {
-                    return Qnil;
-                }
-                for(int i=0; i < fun_argc; i++) {
-                    call.argv[i] = convert_ruby_to_v8(isolate, context, call_argv[i]);
-                }
+            call.argv = (v8::Local<Value> *)RB_ALLOCV_N(void *, tmp, call.argc);
+            for(int i=0; i < call.argc; i++) {
+                call.argv[i] = convert_ruby_to_v8(isolate, context, call_argv[i]);
             }
             rb_thread_call_without_gvl(nogvl_context_call, &call, unblock_function, &call);
-            free(call.argv);
-
+            RB_ALLOCV_END(tmp);
         }
     }
 

data/lib/mini_racer/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module MiniRacer
-  VERSION = "0.6.0"
+  VERSION = "0.6.2"
   LIBV8_NODE_VERSION = "~> 16.10.0.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mini_racer
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.6.2
 platform: ruby
 authors:
 - Sam Saffron
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-12-31 00:00:00.000000000 Z
+date: 2022-01-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -128,9 +128,9 @@ licenses:
 - MIT
 metadata:
   bug_tracker_uri: https://github.com/discourse/mini_racer/issues
-  changelog_uri: https://github.com/discourse/mini_racer/blob/v0.6.0/CHANGELOG
-  documentation_uri: https://www.rubydoc.info/gems/mini_racer/0.6.0
-  source_code_uri: https://github.com/discourse/mini_racer/tree/v0.6.0
+  changelog_uri: https://github.com/discourse/mini_racer/blob/v0.6.2/CHANGELOG
+  documentation_uri: https://www.rubydoc.info/gems/mini_racer/0.6.2
+  source_code_uri: https://github.com/discourse/mini_racer/tree/v0.6.2
 post_install_message:
 rdoc_options: []
 require_paths: