mini_racer 0.6.2 → 0.8.0

data/ext/mini_racer_extension/mini_racer_extension.cc

@@ -305,8 +305,7 @@ static std::unique_ptr<Platform> current_platform = NULL;
 static std::mutex platform_lock;
 
 static pthread_attr_t *thread_attr_p;
-static pthread_rwlock_t exit_lock = PTHREAD_RWLOCK_INITIALIZER;
-static bool ruby_exiting = false; // guarded by exit_lock
+static std::atomic_int ruby_exiting(0);
 static bool single_threaded = false;
 
 static void mark_context(void *);
@@ -335,10 +334,7 @@ static const rb_data_type_t isolate_type = {
 static VALUE rb_platform_set_flag_as_str(VALUE _klass, VALUE flag_as_str) {
     bool platform_already_initialized = false;
 
-    if(TYPE(flag_as_str) != T_STRING) {
-        rb_raise(rb_eArgError, "wrong type argument %" PRIsVALUE" (should be a string)",
-                rb_obj_class(flag_as_str));
-    }
+    Check_Type(flag_as_str, T_STRING);
 
     platform_lock.lock();
 
@@ -522,7 +518,7 @@ nogvl_context_eval(void* arg) {
     MaybeLocal<Script> parsed_script;
 
     if (eval_params->filename) {
-        origin = new v8::ScriptOrigin(*eval_params->filename);
+        origin = new v8::ScriptOrigin(isolate, *eval_params->filename);
     }
 
     parsed_script = Script::Compile(context, *eval_params->eval, origin);
@@ -662,13 +658,9 @@ static VALUE convert_v8_to_ruby(Isolate* isolate, Local<Context> context,
 
     if (value->IsSymbol()) {
 	v8::String::Utf8Value symbol_name(isolate,
-	    Local<Symbol>::Cast(value)->Name());
+	    Local<Symbol>::Cast(value)->Description(isolate));
 
-	VALUE str_symbol = rb_enc_str_new(
-	    *symbol_name,
-	    symbol_name.length(),
-	    rb_enc_find("utf-8")
-	);
+	VALUE str_symbol = rb_utf8_str_new(*symbol_name, symbol_name.length());
 
 	return rb_str_intern(str_symbol);
     }
@@ -679,7 +671,7 @@ static VALUE convert_v8_to_ruby(Isolate* isolate, Local<Context> context,
 	return Qnil;
     } else {
 	Local<String> rstr = rstr_maybe.ToLocalChecked();
-	return rb_enc_str_new(*String::Utf8Value(isolate, rstr), rstr->Utf8Length(isolate), rb_enc_find("utf-8"));
+	return rb_utf8_str_new(*String::Utf8Value(isolate, rstr), rstr->Utf8Length(isolate));
     }
 }
 
@@ -799,7 +791,7 @@ static bool run_extra_code(Isolate *isolate, Local<v8::Context> context,
     }
     Local<String> resource_name =
             String::NewFromUtf8(isolate, name).ToLocalChecked();
-    ScriptOrigin origin(resource_name);
+    ScriptOrigin origin(isolate, resource_name);
     ScriptCompiler::Source source(source_string, origin);
     Local<Script> script;
     if (!ScriptCompiler::Compile(context, &source).ToLocal(&script))
@@ -861,7 +853,7 @@ StartupData warm_up_snapshot_data_blob(StartupData cold_snapshot_blob,
     return result;
 }
 
-static VALUE rb_snapshot_size(VALUE self, VALUE str) {
+static VALUE rb_snapshot_size(VALUE self) {
     SnapshotInfo* snapshot_info;
     TypedData_Get_Struct(self, SnapshotInfo, &snapshot_type, snapshot_info);
 
@@ -872,10 +864,7 @@ static VALUE rb_snapshot_load(VALUE self, VALUE str) {
     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)",
-                rb_obj_class(str));
-    }
+    Check_Type(str, T_STRING);
 
     init_v8();
 
@@ -891,7 +880,7 @@ static VALUE rb_snapshot_load(VALUE self, VALUE str) {
     return Qnil;
 }
 
-static VALUE rb_snapshot_dump(VALUE self, VALUE str) {
+static VALUE rb_snapshot_dump(VALUE self) {
     SnapshotInfo* snapshot_info;
     TypedData_Get_Struct(self, SnapshotInfo, &snapshot_type, snapshot_info);
 
@@ -902,10 +891,7 @@ static VALUE rb_snapshot_warmup_unsafe(VALUE self, VALUE str) {
     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)",
-                rb_obj_class(str));
-    }
+    Check_Type(str, T_STRING);
 
     init_v8();
 
@@ -1084,8 +1070,7 @@ static VALUE convert_result_to_ruby(VALUE self /* context */,
             // If we were terminated or have the memory softlimit flag set
             if (marshal_stack_maxdepth_reached) {
                 ruby_exception = rb_eScriptRuntimeError;
-                std::string msg = std::string("Marshal object depth too deep. Script terminated.");
-                message = rb_enc_str_new(msg.c_str(), msg.length(), rb_enc_find("utf-8"));
+                message = rb_utf8_str_new_literal("Marshal object depth too deep. Script terminated.");
             } else if (result.terminated || mem_softlimit_reached) {
                 ruby_exception = mem_softlimit_reached ? rb_eV8OutOfMemoryError : rb_eScriptTerminatedError;
             } else {
@@ -1120,7 +1105,7 @@ static VALUE convert_result_to_ruby(VALUE self /* context */,
 
         if (result.json) {
             Local<String> rstr = tmp->ToString(p_ctx->Get(isolate)).ToLocalChecked();
-            VALUE json_string = rb_enc_str_new(*String::Utf8Value(isolate, rstr), rstr->Utf8Length(isolate), rb_enc_find("utf-8"));
+            VALUE json_string = rb_utf8_str_new(*String::Utf8Value(isolate, rstr), rstr->Utf8Length(isolate));
             ret = rb_funcall(rb_mJSON, rb_intern("parse"), 1, json_string);
         } else {
             StackCounter::Reset(isolate);
@@ -1149,13 +1134,10 @@ static VALUE rb_context_eval_unsafe(VALUE self, VALUE str, VALUE filename) {
     TypedData_Get_Struct(self, ContextInfo, &context_type, context_info);
     Isolate* isolate = context_info->isolate_info->isolate;
 
-    if(TYPE(str) != T_STRING) {
-        rb_raise(rb_eArgError, "wrong type argument %" PRIsVALUE " (should be a string)",
-                rb_obj_class(str));
-    }
-    if(filename != Qnil && TYPE(filename) != T_STRING) {
-        rb_raise(rb_eArgError, "wrong type argument %" PRIsVALUE " (should be nil or a string)",
-                rb_obj_class(filename));
+    Check_Type(str, T_STRING);
+
+    if (!NIL_P(filename)) {
+        Check_Type(filename, T_STRING);
     }
 
     {
@@ -1474,42 +1456,33 @@ static void free_context_raw(void *arg) {
     if (isolate_info) {
         isolate_info->release();
     }
-
-    xfree(context_info);
 }
 
 static void *free_context_thr(void* arg) {
-    if (pthread_rwlock_tryrdlock(&exit_lock) != 0) {
-        return NULL;
+    if (ruby_exiting.load() == 0) {
+        free_context_raw(arg);
+        xfree(arg);
     }
-    if (ruby_exiting) {
-        return NULL;
-    }
-
-    free_context_raw(arg);
-
-    pthread_rwlock_unlock(&exit_lock);
-
     return NULL;
 }
 
 // destroys everything except freeing the ContextInfo struct (see deallocate())
 static void free_context(ContextInfo* context_info) {
-
     IsolateInfo* isolate_info = context_info->isolate_info;
 
-    ContextInfo* context_info_copy = ALLOC(ContextInfo);
-    context_info_copy->isolate_info = context_info->isolate_info;
-    context_info_copy->context = context_info->context;
-
     if (isolate_info && isolate_info->refs() > 1) {
         pthread_t free_context_thread;
+        ContextInfo* context_info_copy = ALLOC(ContextInfo);
+
+        context_info_copy->isolate_info = context_info->isolate_info;
+        context_info_copy->context = context_info->context;
         if (pthread_create(&free_context_thread, thread_attr_p,
                            free_context_thr, (void*)context_info_copy)) {
             fprintf(stderr, "WARNING failed to release memory in MiniRacer, thread to release could not be created, process will leak memory\n");
+            xfree(context_info_copy);
         }
     } else {
-        free_context_raw(context_info_copy);
+        free_context_raw(context_info);
     }
 
     context_info->context = NULL;
@@ -1782,9 +1755,7 @@ static VALUE rb_context_call_unsafe(int argc, VALUE *argv, VALUE self) {
     }
 
     VALUE function_name = argv[0];
-    if (TYPE(function_name) != T_STRING) {
-        rb_raise(rb_eTypeError, "first argument should be a String");
-    }
+    Check_Type(function_name, T_STRING);
 
     char *fname = RSTRING_PTR(function_name);
     if (!fname) {
@@ -1870,12 +1841,7 @@ static VALUE rb_context_create_isolate_value(VALUE self) {
 static void set_ruby_exiting(VALUE value) {
     (void)value;
 
-    int res = pthread_rwlock_wrlock(&exit_lock);
-
-    ruby_exiting  = true;
-    if (res == 0) {
-        pthread_rwlock_unlock(&exit_lock);
-    }
+    ruby_exiting.store(1);
 }
 
 extern "C" {
@@ -1941,9 +1907,5 @@ extern "C" {
                 thread_attr_p = &attr;
             }
         }
-        auto on_fork_for_child = []() {
-            exit_lock = PTHREAD_RWLOCK_INITIALIZER;
-        };
-        pthread_atfork(nullptr, nullptr, on_fork_for_child);
     }
 }

data/ext/mini_racer_loader/extconf.rb

@@ -1,5 +1,10 @@
 require 'mkmf'
 
+if RUBY_ENGINE == "truffleruby"
+  File.write("Makefile", dummy_makefile($srcdir).join(""))
+  return
+end
+
 extension_name = 'mini_racer_loader'
 dir_config extension_name
 

data/lib/mini_racer/truffleruby.rb

@@ -0,0 +1,355 @@
+# frozen_string_literal: true
+
+module MiniRacer
+
+  class Context
+
+    class ExternalFunction
+      private
+
+      def notify_v8
+        name = @name.encode(::Encoding::UTF_8)
+        wrapped = lambda do |*args|
+          converted = @parent.send(:convert_js_to_ruby, args)
+          begin
+            result = @callback.call(*converted)
+          rescue Polyglot::ForeignException => e
+            e = RuntimeError.new(e.message)
+            e.set_backtrace(e.backtrace)
+            @parent.instance_variable_set(:@current_exception, e)
+            raise e
+          rescue => e
+            @parent.instance_variable_set(:@current_exception, e)
+            raise e
+          end
+          @parent.send(:convert_ruby_to_js, result)
+        end
+
+        if @parent_object.nil?
+          # set global name to proc
+          result = @parent.eval_in_context('this')
+          result[name] = wrapped
+        else
+          parent_object_eval = @parent_object_eval.encode(::Encoding::UTF_8)
+          begin
+            result = @parent.eval_in_context(parent_object_eval)
+          rescue Polyglot::ForeignException, StandardError => e
+            raise ParseError, "Was expecting #{@parent_object} to be an object", e.backtrace
+          end
+          result[name] = wrapped
+          # set evaluated object results name to proc
+        end
+      end
+    end
+
+    def heap_stats
+      {
+        total_physical_size: 0,
+        total_heap_size_executable: 0,
+        total_heap_size: 0,
+        used_heap_size: 0,
+        heap_size_limit: 0,
+      }
+    end
+
+    def stop
+      if @entered
+        @context.stop
+        @stopped = true
+        stop_attached
+      end
+    end
+
+    private
+
+    @context_initialized = false
+    @use_strict = false
+
+    def init_unsafe(isolate, snapshot)
+      unless defined?(Polyglot::InnerContext)
+        raise "TruffleRuby #{RUBY_ENGINE_VERSION} does not have support for inner contexts, use a more recent version"
+      end
+
+      unless Polyglot.languages.include? "js"
+        raise "The language 'js' is not available, you likely need to `export TRUFFLERUBYOPT='--jvm --polyglot'`\n" \
+          "You also need to install the 'js' component with 'gu install js' on GraalVM 22.2+\n" \
+          "Note that you need TruffleRuby+GraalVM and not just the TruffleRuby standalone to use MiniRacer"
+      end
+
+      @context = Polyglot::InnerContext.new(on_cancelled: -> { 
+        raise ScriptTerminatedError, 'JavaScript was terminated (either by timeout or explicitly)' 
+      })
+      Context.instance_variable_set(:@context_initialized, true)
+      @js_object = @context.eval('js', 'Object')
+      @isolate_mutex = Mutex.new
+      @stopped = false
+      @entered = false
+      @has_entered = false
+      @current_exception = nil
+      if isolate && snapshot
+        isolate.instance_variable_set(:@snapshot, snapshot)
+      end
+      if snapshot
+        @snapshot = snapshot
+      elsif isolate
+        @snapshot = isolate.instance_variable_get(:@snapshot)
+      else
+        @snapshot = nil
+      end
+      @is_object_or_array_func, @is_time_func, @js_date_to_time_func, @is_symbol_func, @js_symbol_to_symbol_func, @js_new_date_func, @js_new_array_func = eval_in_context <<-CODE
+        [
+          (x) => { return (x instanceof Object || x instanceof Array) && !(x instanceof Date) && !(x instanceof Function) },
+          (x) => { return x instanceof Date },
+          (x) => { return x.getTime(x) },
+          (x) => { return typeof x === 'symbol' },
+          (x) => { var r = x.description; return r === undefined ? 'undefined' : r },
+          (x) => { return new Date(x) },
+          (x) => { return new Array(x) },
+        ]
+      CODE
+    end
+
+    def dispose_unsafe
+      @context.close
+    end
+
+    def eval_unsafe(str, filename)
+      @entered = true
+      if !@has_entered && @snapshot
+        snapshot_src = encode(@snapshot.instance_variable_get(:@source))
+        begin
+          eval_in_context(snapshot_src, filename)
+        rescue Polyglot::ForeignException => e
+          raise RuntimeError, e.message, e.backtrace
+        end
+      end
+      @has_entered = true
+      raise RuntimeError, "TruffleRuby does not support eval after stop" if @stopped
+      raise TypeError, "wrong type argument #{str.class} (should be a string)" unless str.is_a?(String)
+      raise TypeError, "wrong type argument #{filename.class} (should be a string)" unless filename.nil? || filename.is_a?(String)
+
+      str = encode(str)
+      begin
+        translate do
+          eval_in_context(str, filename)
+        end
+      rescue Polyglot::ForeignException => e
+        raise RuntimeError, e.message, e.backtrace
+      rescue ::RuntimeError => e
+        if @current_exception
+          e = @current_exception
+          @current_exception = nil
+          raise e
+        else
+          raise e, e.message
+        end
+      end
+    ensure
+      @entered = false
+    end
+
+    def call_unsafe(function_name, *arguments)
+      @entered = true
+      if !@has_entered && @snapshot
+        src = encode(@snapshot.instance_variable_get(:source))
+        begin
+          eval_in_context(src)
+        rescue Polyglot::ForeignException => e
+          raise RuntimeError, e.message, e.backtrace
+        end
+      end
+      @has_entered = true
+      raise RuntimeError, "TruffleRuby does not support call after stop" if @stopped
+      begin
+        translate do
+          function = eval_in_context(function_name)
+          function.call(*convert_ruby_to_js(arguments))
+        end
+      rescue Polyglot::ForeignException => e
+        raise RuntimeError, e.message, e.backtrace
+      end
+    ensure
+      @entered = false
+    end
+
+    def create_isolate_value
+      # Returning a dummy object since TruffleRuby does not have a 1-1 concept with isolate.
+      # However, code and ASTs are shared between contexts.
+      Isolate.new
+    end
+
+    def isolate_mutex
+      @isolate_mutex
+    end
+
+    def translate
+      convert_js_to_ruby yield
+    rescue Object => e
+      message = e.message
+      if @current_exception
+        raise @current_exception
+      elsif e.message && e.message.start_with?('SyntaxError:')
+        error_class = MiniRacer::ParseError
+      elsif e.is_a?(MiniRacer::ScriptTerminatedError)
+        error_class = MiniRacer::ScriptTerminatedError
+      else
+        error_class = MiniRacer::RuntimeError
+      end
+
+      if error_class == MiniRacer::RuntimeError
+        bls = e.backtrace_locations&.select { |bl| bl&.source_location&.language == 'js' }
+        if bls && !bls.empty?
+          if '(eval)' != bls[0].path
+            message = "#{e.message}\n at #{bls[0]}\n" + bls[1..].map(&:to_s).join("\n")
+          else
+            message = "#{e.message}\n" + bls.map(&:to_s).join("\n")
+          end
+        end
+        raise error_class, message
+      else
+        raise error_class, message, e.backtrace
+      end
+    end
+
+    def convert_js_to_ruby(value)
+      case value
+      when true, false, Integer, Float
+        value
+      else
+        if value.nil?
+          nil
+        elsif value.respond_to?(:call)
+          MiniRacer::JavaScriptFunction.new
+        elsif value.respond_to?(:to_str)
+          value.to_str.dup
+        elsif value.respond_to?(:to_ary)
+          value.to_ary.map do |e|
+            if e.respond_to?(:call)
+              nil
+            else
+              convert_js_to_ruby(e)
+            end
+          end
+        elsif time?(value)
+          js_date_to_time(value)
+        elsif symbol?(value)
+          js_symbol_to_symbol(value)
+        else
+          object = value
+          h = {}
+          object.instance_variables.each do |member|
+            v = object[member]
+            unless v.respond_to?(:call)
+              h[member.to_s] = convert_js_to_ruby(v)
+            end
+          end
+          h
+        end
+      end
+    end
+
+    def object_or_array?(val)
+      @is_object_or_array_func.call(val)
+    end
+
+    def time?(value)
+      @is_time_func.call(value)
+    end
+
+    def js_date_to_time(value)
+      millis = @js_date_to_time_func.call(value)
+      Time.at(Rational(millis, 1000))
+    end
+
+    def symbol?(value)
+      @is_symbol_func.call(value)
+    end
+
+    def js_symbol_to_symbol(value)
+      @js_symbol_to_symbol_func.call(value).to_s.to_sym
+    end
+
+    def js_new_date(value)
+      @js_new_date_func.call(value)
+    end
+
+    def js_new_array(size)
+      @js_new_array_func.call(size)
+    end
+
+    def convert_ruby_to_js(value)
+      case value
+      when nil, true, false, Integer, Float
+        value
+      when Array
+        ary = js_new_array(value.size)
+        value.each_with_index do |v, i|
+          ary[i] = convert_ruby_to_js(v)
+        end
+        ary
+      when Hash
+        h = @js_object.new
+        value.each_pair do |k, v|
+          h[convert_ruby_to_js(k.to_s)] = convert_ruby_to_js(v)
+        end
+        h
+      when String, Symbol
+        Truffle::Interop.as_truffle_string value
+      when Time
+        js_new_date(value.to_f * 1000)
+      when DateTime
+        js_new_date(value.to_time.to_f * 1000)
+      else
+        "Undefined Conversion"
+      end
+    end
+
+    def encode(string)
+      raise ArgumentError unless string
+      string.encode(::Encoding::UTF_8)
+    end
+
+    class_eval <<-'RUBY', "(mini_racer)", 1
+        def eval_in_context(code, file = nil); code = ('"use strict";' + code) if Context.instance_variable_get(:@use_strict); @context.eval('js', code, file || '(mini_racer)'); end
+    RUBY
+
+  end
+
+  class Isolate
+    def init_with_snapshot(snapshot)
+      # TruffleRuby does not have a 1-1 concept with isolate.
+      # However, isolate can hold a snapshot, and code and ASTs are shared between contexts.
+      @snapshot = snapshot
+    end
+
+    def low_memory_notification
+      GC.start
+    end
+
+    def idle_notification(idle_time)
+      true
+    end
+  end
+
+  class Platform
+    def self.set_flag_as_str!(flag)
+      raise TypeError, "wrong type argument #{flag.class} (should be a string)" unless flag.is_a?(String)
+      raise MiniRacer::PlatformAlreadyInitialized, "The platform is already initialized." if Context.instance_variable_get(:@context_initialized)
+      Context.instance_variable_set(:@use_strict, true) if "--use_strict" == flag
+    end
+  end
+
+  class Snapshot
+    def load(str)
+      raise TypeError, "wrong type argument #{str.class} (should be a string)" unless str.is_a?(String)
+      # Intentionally noop since TruffleRuby mocks the snapshot API
+    end
+
+    def warmup_unsafe!(src)
+      raise TypeError, "wrong type argument #{src.class} (should be a string)" unless src.is_a?(String)
+      # Intentionally noop since TruffleRuby mocks the snapshot API
+      # by replaying snapshot source before the first eval/call
+      self
+    end
+  end
+end

data/lib/mini_racer/version.rb

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

data/lib/mini_racer.rb

@@ -1,17 +1,22 @@
 require "mini_racer/version"
-require "mini_racer_loader"
 require "pathname"
 
-ext_filename = "mini_racer_extension.#{RbConfig::CONFIG['DLEXT']}"
-ext_path = Gem.loaded_specs['mini_racer'].require_paths
-  .map { |p| (p = Pathname.new(p)).absolute? ? p : Pathname.new(__dir__).parent + p }
-ext_found = ext_path.map { |p| p + ext_filename }.find { |p| p.file? }
-
-raise LoadError, "Could not find #{ext_filename} in #{ext_path.map(&:to_s)}" unless ext_found
-MiniRacer::Loader.load(ext_found.to_s)
+if RUBY_ENGINE == "truffleruby"
+  require "mini_racer/truffleruby"
+else
+  require "mini_racer_loader" 
+  ext_filename = "mini_racer_extension.#{RbConfig::CONFIG['DLEXT']}"
+  ext_path = Gem.loaded_specs['mini_racer'].require_paths
+    .map { |p| (p = Pathname.new(p)).absolute? ? p : Pathname.new(__dir__).parent + p }
+  ext_found = ext_path.map { |p| p + ext_filename }.find { |p| p.file? }
+
+  raise LoadError, "Could not find #{ext_filename} in #{ext_path.map(&:to_s)}" unless ext_found
+  MiniRacer::Loader.load(ext_found.to_s)
+end
 
 require "thread"
 require "json"
+require "io/wait"
 
 module MiniRacer
 
@@ -202,7 +207,7 @@ module MiniRacer
       end
 
       if !(File === f)
-        raise ArgumentError("file_or_io")
+        raise ArgumentError, "file_or_io"
       end
 
       write_heap_snapshot_unsafe(f)
@@ -349,7 +354,7 @@ module MiniRacer
 
       t = Thread.new do
         begin
-          result = IO.select([rp],[],[],(@timeout/1000.0))
+          result = rp.wait_readable(@timeout/1000.0)
           if !result
             mutex.synchronize do
               stop unless done
@@ -366,7 +371,7 @@ module MiniRacer
         done = true
       end
 
-      wp.write("done")
+      wp.close
 
       # ensure we do not leak a thread in state
       t.join
@@ -375,12 +380,9 @@ module MiniRacer
       rval
     ensure
       # exceptions need to be handled
-      if t && wp
-        wp.write("done")
-        t.join
-      end
-      wp.close if wp
-      rp.close if rp
+      wp&.close
+      t&.join
+      rp&.close
     end
 
     def check_init_options!(isolate:, snapshot:, max_memory:, marshal_stack_depth:, ensure_gc_after_idle:, timeout:)

data/lib/mini_racer_extension.so

@@ -0,0 +1,4 @@
+[diffend] Oversized file quarantined before diffing.
+name: data/lib/mini_racer_extension.so
+size: 53136240 bytes
+sha256: dfec40a5bc882e4ef9298c4954ea9b6aab8a64b428379d5b1a5e79a63b17b1d0