mini_racer 0.5.0.pre → 0.6.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b0a067ca868ffe75b89fc350d6d62b6e4d2670a4319eda9f6cd05fe424c762ec
-  data.tar.gz: 26c865123cceec38530a9be40e32c1042063f3cbb400172438308a7eb0e06568
+  metadata.gz: e832863760637f983976194ebef263d8815c149d48ff26c7200367ab33640dda
+  data.tar.gz: 7c1c393ae6403a75d2a413395d56e7d5f3affe706b81c121273b4c6b5d471bf4
 SHA512:
-  metadata.gz: 0e1de5f130d4cf5ddca606f57cf7864f9d05d87c9775cd6873d6bb6151983216f74bc7a7eb3e20a9382e5cf95a2ccd8958c7a548ddb491ac8cb9cb89d1c17fd8
-  data.tar.gz: 7df5b7f82afbc9040a6d317bdd8d8600d6656a965bcb44c3ce4f7b6f02007ae1e9fc088022e6c5c10c4755aa4c0dea9badbd4ca8087e3e9185f6f93f42835775
+  metadata.gz: 4504cb3a564e5b311b65de74bac321b058995af17df47f9f3dc01fcb589a87eebfda55497e0ddb135a2ab15ef1818760652561d434d3f497c0dbd036451934c6
+  data.tar.gz: b83df123a61092ab4041212bb6e4f15b276d5e32e8be8d2b5cbc014988b8cf20ed0e0b3b30595de53ca4c0d599a86112d695009cda13891fe177742aff7d911e

data/CHANGELOG

@@ -1,5 +1,35 @@
+- 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
+   - Fixes memory leak in heap snapshotting
+   - Improved compilation ergonomics in clang
+   - Migrated internal storage in c extension to TypedData
+
 - 11-04-2021
 
+- 0.5.0
+  - Fixes issues on aarch (Apple M1)
+  - Update to use libv8-node 16.x (#210) [Loic Nageleisen]
+  - FEATURE: Configurable max marshal stack depth (#202) [seanmakesgames]
+  - Ruby 2.3 and 2.4 are EOL, we no longer support them
+
 - 0.4.0
 
   - FEATURE: upgrade to libv8 node 15.14.0 (v8 8.6.395.17)

data/Rakefile

@@ -92,5 +92,5 @@ task :lint do
               portability-*
               readability-*).join(',')
 
-  sh RbConfig::expand("clang-tidy -checks='#{checks}' ext/mini_racer_extension/mini_racer_extension.cc -- #$INCFLAGS #$CPPFLAGS", conf)
+  sh RbConfig::expand("clang-tidy -checks='#{checks}' ext/mini_racer_extension/mini_racer_extension.cc -- #$INCFLAGS #$CXXFLAGS", conf)
 end

data/ext/mini_racer_extension/extconf.rb

@@ -7,18 +7,25 @@ IS_DARWIN = RUBY_PLATFORM =~ /darwin/
 
 have_library('pthread')
 have_library('objc') if IS_DARWIN
-$CPPFLAGS += " -Wall" unless $CPPFLAGS.split.include? "-Wall"
-$CPPFLAGS += " -g" unless $CPPFLAGS.split.include? "-g"
-$CPPFLAGS += " -rdynamic" unless $CPPFLAGS.split.include? "-rdynamic"
-$CPPFLAGS += " -fPIC" unless $CPPFLAGS.split.include? "-rdynamic" or IS_DARWIN
-$CPPFLAGS += " -std=c++14"
-$CPPFLAGS += " -fpermissive"
-#$CPPFLAGS += " -DV8_COMPRESS_POINTERS"
-$CPPFLAGS += " -fvisibility=hidden "
-
-$CPPFLAGS += " -Wno-reserved-user-defined-literal" if IS_DARWIN
-
-$LDFLAGS.insert(0, " -stdlib=libc++ ") if IS_DARWIN
+$CXXFLAGS += " -Wall" unless $CXXFLAGS.split.include? "-Wall"
+$CXXFLAGS += " -g" unless $CXXFLAGS.split.include? "-g"
+$CXXFLAGS += " -rdynamic" unless $CXXFLAGS.split.include? "-rdynamic"
+$CXXFLAGS += " -fPIC" unless $CXXFLAGS.split.include? "-rdynamic" or IS_DARWIN
+$CXXFLAGS += " -std=c++14"
+$CXXFLAGS += " -fpermissive"
+#$CXXFLAGS += " -DV8_COMPRESS_POINTERS"
+$CXXFLAGS += " -fvisibility=hidden "
+
+# __declspec gets used by clang via ruby 3.x headers...
+$CXXFLAGS += " -fms-extensions"
+
+$CXXFLAGS += " -Wno-reserved-user-defined-literal" if IS_DARWIN
+
+if IS_DARWIN
+  $LDFLAGS.insert(0, " -stdlib=libc++ ")
+else
+  $LDFLAGS.insert(0, " -lstdc++ ")
+end
 
 # check for missing symbols at link time
 # $LDFLAGS += " -Wl,--no-undefined " unless IS_DARWIN
@@ -64,8 +71,13 @@ end
 Libv8::Node.configure_makefile
 
 if enable_config('asan')
-  $CPPFLAGS.insert(0, " -fsanitize=address ")
+  $CXXFLAGS.insert(0, " -fsanitize=address ")
   $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>
@@ -11,6 +12,15 @@
 #include <mutex>
 #include <atomic>
 #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;
 
@@ -299,6 +309,29 @@ static pthread_rwlock_t exit_lock = PTHREAD_RWLOCK_INITIALIZER;
 static bool ruby_exiting = false; // guarded by exit_lock
 static bool single_threaded = false;
 
+static void mark_context(void *);
+static void deallocate(void *);
+static size_t context_memsize(const void *);
+static const rb_data_type_t context_type = {
+    "mini_racer/context_info",
+    { mark_context, deallocate, context_memsize }
+};
+
+static void deallocate_snapshot(void *);
+static size_t snapshot_memsize(const void *);
+static const rb_data_type_t snapshot_type = {
+    "mini_racer/snapshot_info",
+    { NULL, deallocate_snapshot, snapshot_memsize }
+};
+
+static void mark_isolate(void *);
+static void deallocate_isolate(void *);
+static size_t isolate_memsize(const void *);
+static const rb_data_type_t isolate_type = {
+    "mini_racer/isolate_info",
+    { mark_isolate, deallocate_isolate, isolate_memsize }
+};
+
 static VALUE rb_platform_set_flag_as_str(VALUE _klass, VALUE flag_as_str) {
     bool platform_already_initialized = false;
 
@@ -313,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;
     }
@@ -336,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();
     }
@@ -381,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);
@@ -453,7 +494,7 @@ static void prepare_result(MaybeLocal<Value> v8res,
     }
 }
 
-void*
+static void*
 nogvl_context_eval(void* arg) {
 
     EvalParams* eval_params = (EvalParams*)arg;
@@ -683,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:
@@ -711,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)
@@ -786,6 +827,7 @@ create_snapshot_data_blob(const char *embedded_source = nullptr) {
             SnapshotCreator::FunctionCodeHandling::kClear);
     }
 
+static
 StartupData warm_up_snapshot_data_blob(StartupData cold_snapshot_blob,
                                        const char *warmup_source) {
     // Use following steps to create a warmed up snapshot blob from a cold one:
@@ -821,14 +863,14 @@ StartupData warm_up_snapshot_data_blob(StartupData cold_snapshot_blob,
 
 static VALUE rb_snapshot_size(VALUE self, VALUE str) {
     SnapshotInfo* snapshot_info;
-    Data_Get_Struct(self, SnapshotInfo, snapshot_info);
+    TypedData_Get_Struct(self, SnapshotInfo, &snapshot_type, snapshot_info);
 
     return INT2NUM(snapshot_info->raw_size);
 }
 
 static VALUE rb_snapshot_load(VALUE self, VALUE str) {
     SnapshotInfo* snapshot_info;
-    Data_Get_Struct(self, SnapshotInfo, snapshot_info);
+    TypedData_Get_Struct(self, SnapshotInfo, &snapshot_type, snapshot_info);
 
     if(TYPE(str) != T_STRING) {
         rb_raise(rb_eArgError, "wrong type argument %" PRIsVALUE " (should be a string)",
@@ -851,14 +893,14 @@ static VALUE rb_snapshot_load(VALUE self, VALUE str) {
 
 static VALUE rb_snapshot_dump(VALUE self, VALUE str) {
     SnapshotInfo* snapshot_info;
-    Data_Get_Struct(self, SnapshotInfo, snapshot_info);
+    TypedData_Get_Struct(self, SnapshotInfo, &snapshot_type, snapshot_info);
 
     return rb_str_new(snapshot_info->data, snapshot_info->raw_size);
 }
 
 static VALUE rb_snapshot_warmup_unsafe(VALUE self, VALUE str) {
     SnapshotInfo* snapshot_info;
-    Data_Get_Struct(self, SnapshotInfo, snapshot_info);
+    TypedData_Get_Struct(self, SnapshotInfo, &snapshot_type, snapshot_info);
 
     if(TYPE(str) != T_STRING) {
         rb_raise(rb_eArgError, "wrong type argument %" PRIsVALUE " (should be a string)",
@@ -905,13 +947,13 @@ void IsolateInfo::init(SnapshotInfo* snapshot_info) {
 
 static VALUE rb_isolate_init_with_snapshot(VALUE self, VALUE snapshot) {
     IsolateInfo* isolate_info;
-    Data_Get_Struct(self, IsolateInfo, isolate_info);
+    TypedData_Get_Struct(self, IsolateInfo, &isolate_type, isolate_info);
 
     init_v8();
 
     SnapshotInfo* snapshot_info = nullptr;
     if (!NIL_P(snapshot)) {
-        Data_Get_Struct(snapshot, SnapshotInfo, snapshot_info);
+        TypedData_Get_Struct(snapshot, SnapshotInfo, &snapshot_type, snapshot_info);
     }
 
     isolate_info->init(snapshot_info);
@@ -922,7 +964,7 @@ static VALUE rb_isolate_init_with_snapshot(VALUE self, VALUE snapshot) {
 
 static VALUE rb_isolate_idle_notification(VALUE self, VALUE idle_time_in_ms) {
     IsolateInfo* isolate_info;
-    Data_Get_Struct(self, IsolateInfo, isolate_info);
+    TypedData_Get_Struct(self, IsolateInfo, &isolate_type, isolate_info);
 
     if (current_platform == NULL) return Qfalse;
 
@@ -933,7 +975,7 @@ static VALUE rb_isolate_idle_notification(VALUE self, VALUE idle_time_in_ms) {
 
 static VALUE rb_isolate_low_memory_notification(VALUE self) {
     IsolateInfo* isolate_info;
-    Data_Get_Struct(self, IsolateInfo, isolate_info);
+    TypedData_Get_Struct(self, IsolateInfo, &isolate_type, isolate_info);
 
     if (current_platform == NULL) return Qfalse;
 
@@ -943,7 +985,7 @@ static VALUE rb_isolate_low_memory_notification(VALUE self) {
 
 static VALUE rb_isolate_pump_message_loop(VALUE self) {
     IsolateInfo* isolate_info;
-    Data_Get_Struct(self, IsolateInfo, isolate_info);
+    TypedData_Get_Struct(self, IsolateInfo, &isolate_type, isolate_info);
 
     if (current_platform == NULL) return Qfalse;
 
@@ -956,7 +998,7 @@ static VALUE rb_isolate_pump_message_loop(VALUE self) {
 
 static VALUE rb_context_init_unsafe(VALUE self, VALUE isolate, VALUE snap) {
     ContextInfo* context_info;
-    Data_Get_Struct(self, ContextInfo, context_info);
+    TypedData_Get_Struct(self, ContextInfo, &context_type, context_info);
 
     init_v8();
 
@@ -967,11 +1009,11 @@ static VALUE rb_context_init_unsafe(VALUE self, VALUE isolate, VALUE snap) {
 
         SnapshotInfo *snapshot_info = nullptr;
         if (!NIL_P(snap) && rb_obj_is_kind_of(snap, rb_cSnapshot)) {
-            Data_Get_Struct(snap, SnapshotInfo, snapshot_info);
+            TypedData_Get_Struct(snap, SnapshotInfo, &snapshot_type, snapshot_info);
         }
         isolate_info->init(snapshot_info);
     } else { // given isolate or snapshot
-        Data_Get_Struct(isolate, IsolateInfo, isolate_info);
+        TypedData_Get_Struct(isolate, IsolateInfo, &isolate_type, isolate_info);
     }
 
     context_info->isolate_info = isolate_info;
@@ -1001,7 +1043,7 @@ static VALUE rb_context_init_unsafe(VALUE self, VALUE isolate, VALUE snap) {
 static VALUE convert_result_to_ruby(VALUE self /* context */,
                                     EvalResult& result) {
     ContextInfo *context_info;
-    Data_Get_Struct(self, ContextInfo, context_info);
+    TypedData_Get_Struct(self, ContextInfo, &context_type, context_info);
 
     Isolate *isolate = context_info->isolate_info->isolate;
     Persistent<Context> *p_ctx = context_info->context;
@@ -1028,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");
         }
@@ -1052,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);
         }
     }
 
@@ -1102,7 +1146,7 @@ static VALUE rb_context_eval_unsafe(VALUE self, VALUE str, VALUE filename) {
     EvalResult eval_result;
     ContextInfo* context_info;
 
-    Data_Get_Struct(self, ContextInfo, context_info);
+    TypedData_Get_Struct(self, ContextInfo, &context_type, context_info);
     Isolate* isolate = context_info->isolate_info->isolate;
 
     if(TYPE(str) != T_STRING) {
@@ -1120,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;
@@ -1190,7 +1234,7 @@ VALUE rescue_callback(VALUE rdata, VALUE exception) {
     return exception;
 }
 
-void*
+static void*
 gvl_ruby_callback(void* data) {
 
     FunctionCallbackInfo<Value>* args = (FunctionCallbackInfo<Value>*)data;
@@ -1206,7 +1250,7 @@ gvl_ruby_callback(void* data) {
         HandleScope scope(args->GetIsolate());
         Local<External> external = Local<External>::Cast(args->Data());
 
-        self = *(VALUE*)(external->Value());
+        self = (VALUE)(external->Value());
         callback = rb_iv_get(self, "@callback");
 
         parent = rb_iv_get(self, "@parent");
@@ -1214,7 +1258,7 @@ gvl_ruby_callback(void* data) {
             return NULL;
         }
 
-        Data_Get_Struct(parent, ContextInfo, context_info);
+        TypedData_Get_Struct(parent, ContextInfo, &context_type, context_info);
 
         if (length > 0) {
             ruby_args = rb_ary_tmp_new(length);
@@ -1243,7 +1287,6 @@ gvl_ruby_callback(void* data) {
         args->GetIsolate()->TerminateExecution();
         if (length > 0) {
             rb_ary_clear(ruby_args);
-            rb_gc_force_recycle(ruby_args);
         }
         return NULL;
     }
@@ -1251,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(RUBY_METHOD_FUNC(protected_callback), callback_data_value,
-            RUBY_METHOD_FUNC(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);
@@ -1266,7 +1309,6 @@ gvl_ruby_callback(void* data) {
 
     if (length > 0) {
         rb_ary_clear(ruby_args);
-        rb_gc_force_recycle(ruby_args);
     }
 
     if (IsolateData::Get(args->GetIsolate(), IsolateData::DO_TERMINATE)) {
@@ -1301,7 +1343,7 @@ static VALUE rb_external_function_notify_v8(VALUE self) {
     bool parse_error = false;
     bool attach_error = false;
 
-    Data_Get_Struct(parent, ContextInfo, context_info);
+    TypedData_Get_Struct(parent, ContextInfo, &context_type, context_info);
     Isolate* isolate = context_info->isolate_info->isolate;
 
     {
@@ -1314,15 +1356,12 @@ 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();
 
-        // copy self so we can access from v8 external
-        VALUE* self_copy;
-        Data_Get_Struct(self, VALUE, self_copy);
-        *self_copy = self;
-
-        Local<Value> external = External::New(isolate, self_copy);
+        // Note that self (rb_cExternalFunction) is a pure Ruby T_OBJECT,
+        // not a T_DATA type like most other classes in this file
+        Local<Value> external = External::New(isolate, (void *)self);
 
         if (parent_object == Qnil) {
             Maybe<bool> success = context->Global()->Set(
@@ -1337,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);
@@ -1379,7 +1418,7 @@ static VALUE rb_external_function_notify_v8(VALUE self) {
 
 static VALUE rb_context_isolate_mutex(VALUE self) {
     ContextInfo* context_info;
-    Data_Get_Struct(self, ContextInfo, context_info);
+    TypedData_Get_Struct(self, ContextInfo, &context_type, context_info);
 
     if (!context_info->isolate_info) {
         rb_raise(rb_eScriptRuntimeError, "Context has no Isolate available anymore");
@@ -1489,6 +1528,11 @@ static void mark_isolate(void* data) {
     isolate_info->mark();
 }
 
+static size_t isolate_memsize(const void *ptr) {
+     const IsolateInfo *isolate_info = (const IsolateInfo *)ptr;
+     return sizeof(*isolate_info);
+}
+
 static void deallocate(void* data) {
     ContextInfo* context_info = (ContextInfo*)data;
 
@@ -1497,6 +1541,11 @@ static void deallocate(void* data) {
     xfree(data);
 }
 
+static size_t context_memsize(const void *ptr)
+{
+    return sizeof(ContextInfo);
+}
+
 static void mark_context(void* data) {
     ContextInfo* context_info = (ContextInfo*)data;
     if (context_info->isolate_info) {
@@ -1504,48 +1553,39 @@ static void mark_context(void* data) {
     }
 }
 
-static void deallocate_external_function(void * data) {
-    xfree(data);
-}
-
 static void deallocate_snapshot(void * data) {
     SnapshotInfo* snapshot_info = (SnapshotInfo*)data;
     delete[] snapshot_info->data;
     xfree(snapshot_info);
 }
 
-static VALUE allocate_external_function(VALUE klass) {
-    VALUE* self = ALLOC(VALUE);
-    return Data_Wrap_Struct(klass, NULL, deallocate_external_function, (void*)self);
+static size_t snapshot_memsize(const void *data) {
+    SnapshotInfo* snapshot_info = (SnapshotInfo*)data;
+    return sizeof(*snapshot_info) + snapshot_info->raw_size;
 }
 
 static VALUE allocate(VALUE klass) {
-    ContextInfo* context_info = ALLOC(ContextInfo);
-    context_info->isolate_info = NULL;
-    context_info->context = NULL;
-
-    return Data_Wrap_Struct(klass, mark_context, deallocate, (void*)context_info);
+    ContextInfo* context_info;
+    return TypedData_Make_Struct(klass, ContextInfo, &context_type, context_info);
 }
 
 static VALUE allocate_snapshot(VALUE klass) {
-    SnapshotInfo* snapshot_info = ALLOC(SnapshotInfo);
-    snapshot_info->data = NULL;
-    snapshot_info->raw_size = 0;
+    SnapshotInfo* snapshot_info;
 
-    return Data_Wrap_Struct(klass, NULL, deallocate_snapshot, (void*)snapshot_info);
+    return TypedData_Make_Struct(klass, SnapshotInfo, &snapshot_type, snapshot_info);
 }
 
 static VALUE allocate_isolate(VALUE klass) {
     IsolateInfo* isolate_info = new IsolateInfo();
 
-    return Data_Wrap_Struct(klass, mark_isolate, deallocate_isolate, (void*)isolate_info);
+    return TypedData_Wrap_Struct(klass, &isolate_type, isolate_info);
 }
 
 static VALUE
 rb_heap_stats(VALUE self) {
 
     ContextInfo* context_info;
-    Data_Get_Struct(self, ContextInfo, context_info);
+    TypedData_Get_Struct(self, ContextInfo, &context_type, context_info);
     Isolate* isolate;
     v8::HeapStatistics stats;
 
@@ -1577,7 +1617,9 @@ rb_heap_stats(VALUE self) {
 // https://github.com/bnoordhuis/node-heapdump/blob/master/src/heapdump.cc
 class FileOutputStream : public OutputStream {
  public:
-  FileOutputStream(FILE* stream) : stream_(stream) {}
+  int err;
+
+  FileOutputStream(int fd) : fd(fd) { err = 0; }
 
   virtual int GetChunkSize() {
     return 65536;
@@ -1586,17 +1628,27 @@ class FileOutputStream : public OutputStream {
   virtual void EndOfStream() {}
 
   virtual WriteResult WriteAsciiChunk(char* data, int size) {
-    const size_t len = static_cast<size_t>(size);
-    size_t off = 0;
-
-    while (off < len && !feof(stream_) && !ferror(stream_))
-      off += fwrite(data + off, 1, len - off, stream_);
-
-    return off == len ? kContinue : kAbort;
+    size_t len = static_cast<size_t>(size);
+
+    while (len) {
+        ssize_t w = write(fd, data, len);
+
+        if (w > 0) {
+            data += w;
+            len -= w;
+        } else if (w < 0) {
+            err = errno;
+            return kAbort;
+        } else { /* w == 0, could be out-of-space */
+            err = -1;
+            return kAbort;
+        }
+    }
+    return kContinue;
   }
 
  private:
-  FILE* stream_;
+  int fd;
 };
 
 
@@ -1609,13 +1661,11 @@ rb_heap_snapshot(VALUE self, VALUE file) {
 
     if (!fptr) return Qfalse;
 
-    FILE* fp;
-    fp = fdopen(fptr->fd, "w");
-    if (fp == NULL) return Qfalse;
-
+    // prepare for unbuffered write(2) below:
+    rb_funcall(file, rb_intern("flush"), 0);
 
     ContextInfo* context_info;
-    Data_Get_Struct(self, ContextInfo, context_info);
+    TypedData_Get_Struct(self, ContextInfo, &context_type, context_info);
     Isolate* isolate;
     isolate = context_info->isolate_info ? context_info->isolate_info->isolate : NULL;
 
@@ -1629,13 +1679,14 @@ rb_heap_snapshot(VALUE self, VALUE file) {
 
     const HeapSnapshot* const snap = heap_profiler->TakeHeapSnapshot();
 
-    FileOutputStream stream(fp);
+    FileOutputStream stream(fptr->fd);
     snap->Serialize(&stream, HeapSnapshot::kJSON);
 
-    fflush(fp);
-
     const_cast<HeapSnapshot*>(snap)->Delete();
 
+    /* TODO: perhaps rb_sys_fail here */
+    if (stream.err) return Qfalse;
+
     return Qtrue;
 }
 
@@ -1643,7 +1694,7 @@ static VALUE
 rb_context_stop(VALUE self) {
 
     ContextInfo* context_info;
-    Data_Get_Struct(self, ContextInfo, context_info);
+    TypedData_Get_Struct(self, ContextInfo, &context_type, context_info);
 
     Isolate* isolate = context_info->isolate_info->isolate;
 
@@ -1660,7 +1711,7 @@ static VALUE
 rb_context_dispose(VALUE self) {
 
     ContextInfo* context_info;
-    Data_Get_Struct(self, ContextInfo, context_info);
+    TypedData_Get_Struct(self, ContextInfo, &context_type, context_info);
 
     free_context(context_info);
 
@@ -1723,7 +1774,7 @@ static VALUE rb_context_call_unsafe(int argc, VALUE *argv, VALUE self) {
     FunctionCall call;
     VALUE *call_argv = NULL;
 
-    Data_Get_Struct(self, ContextInfo, context_info);
+    TypedData_Get_Struct(self, ContextInfo, &context_type, context_info);
     Isolate* isolate = context_info->isolate_info->isolate;
 
     if (argc < 1) {
@@ -1784,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);
         }
     }
 
@@ -1813,7 +1856,7 @@ static VALUE rb_context_call_unsafe(int argc, VALUE *argv, VALUE self) {
 
 static VALUE rb_context_create_isolate_value(VALUE self) {
     ContextInfo* context_info;
-    Data_Get_Struct(self, ContextInfo, context_info);
+    TypedData_Get_Struct(self, ContextInfo, &context_type, context_info);
     IsolateInfo *isolate_info = context_info->isolate_info;
 
     if (!isolate_info) {
@@ -1821,7 +1864,7 @@ static VALUE rb_context_create_isolate_value(VALUE self) {
     }
 
     isolate_info->hold();
-    return Data_Wrap_Struct(rb_cIsolate, NULL, &deallocate_isolate, isolate_info);
+    return TypedData_Wrap_Struct(rb_cIsolate, &isolate_type, isolate_info);
 }
 
 static void set_ruby_exiting(VALUE value) {
@@ -1877,7 +1920,6 @@ extern "C" {
         rb_define_alloc_func(rb_cIsolate, allocate_isolate);
 
         rb_define_private_method(rb_cExternalFunction, "notify_v8", (VALUE(*)(...))&rb_external_function_notify_v8, 0);
-        rb_define_alloc_func(rb_cExternalFunction, allocate_external_function);
 
         rb_define_method(rb_cSnapshot, "size", (VALUE(*)(...))&rb_snapshot_size, 0);
         rb_define_method(rb_cSnapshot, "dump", (VALUE(*)(...))&rb_snapshot_dump, 0);

data/ext/mini_racer_loader/extconf.rb

@@ -3,6 +3,6 @@ require 'mkmf'
 extension_name = 'mini_racer_loader'
 dir_config extension_name
 
-$CPPFLAGS += " -fvisibility=hidden "
+$CXXFLAGS += " -fvisibility=hidden "
 
 create_makefile extension_name

data/lib/mini_racer/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module MiniRacer
-  VERSION = "0.5.0.pre"
+  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.5.0.pre
+  version: 0.6.2
 platform: ruby
 authors:
 - Sam Saffron
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-11-03 00:00:00.000000000 Z
+date: 2022-01-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -128,10 +128,10 @@ licenses:
 - MIT
 metadata:
   bug_tracker_uri: https://github.com/discourse/mini_racer/issues
-  changelog_uri: https://github.com/discourse/mini_racer/blob/v0.5.0.pre/CHANGELOG
-  documentation_uri: https://www.rubydoc.info/gems/mini_racer/0.5.0.pre
-  source_code_uri: https://github.com/discourse/mini_racer/tree/v0.5.0.pre
-post_install_message: 
+  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:
 - lib
@@ -143,12 +143,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '2.6'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubygems_version: 3.1.6
-signing_key: 
+signing_key:
 specification_version: 4
 summary: Minimal embedded v8 for Ruby
 test_files: []