mini_racer 0.6.2 → 0.6.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e832863760637f983976194ebef263d8815c149d48ff26c7200367ab33640dda
-  data.tar.gz: 7c1c393ae6403a75d2a413395d56e7d5f3affe706b81c121273b4c6b5d471bf4
+  metadata.gz: 2d643f2cd1fb220fc7ac49d502671334d2e9390cd6eac47b62cdecfc39f2dd82
+  data.tar.gz: 2c1cbb7cb254dddefdeac0c7bd246d62e2f08dfb9df24c91680ef0e6016ea483
 SHA512:
-  metadata.gz: 4504cb3a564e5b311b65de74bac321b058995af17df47f9f3dc01fcb589a87eebfda55497e0ddb135a2ab15ef1818760652561d434d3f497c0dbd036451934c6
-  data.tar.gz: b83df123a61092ab4041212bb6e4f15b276d5e32e8be8d2b5cbc014988b8cf20ed0e0b3b30595de53ca4c0d599a86112d695009cda13891fe177742aff7d911e
+  metadata.gz: be7c745abba5a2bd5caf0e30f066601a58d00f847092bde4865d3faf7b79987af5bfe0c6cd9c2783f0ab7a7edc1e39b6a53afa489ce4e5dde0713981e26dfc51
+  data.tar.gz: e6128f7619cdb105b04f5a7abb0ed2c0964a2b2b353c3a4eecc79dfa3d329d88695f9885c7250d2d6615ff9bc93c22cf111d24bca54d9e57fbaa02672998879c

data/.github/workflows/ci.yml

@@ -1,48 +1,92 @@
-name: Test
+name: Tests
+
 on:
-  - push
+  pull_request:
+  push:
+    branches:
+      - master
 
 jobs:
+  test-truffleruby:
+    strategy:
+      fail-fast: false
+      matrix:
+        os:
+          - "macos-11"
+          - "macos-12"
+          - "ubuntu-20.04"
+        ruby:
+          - "truffleruby+graalvm-head"
+
+    name: ${{ matrix.os }} - ${{ matrix.ruby }}
+    runs-on: ${{ matrix.os }}
+
+    env:
+      TRUFFLERUBYOPT: "--jvm --polyglot"
+
+    steps:
+      - uses: actions/checkout@v3
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+          bundler-cache: true
+      - name: Install GraalVM JS component
+        run: gu install js
+      - name: Compile
+        run: bundle exec rake compile
+      - name: Test
+        run: bundle exec rake test
+
   test-darwin:
     strategy:
       fail-fast: false
       matrix:
         os:
-          - '10.15'
-          - '11.0'
-        platform:
-          - x86_64
-          # arm64
-    name: Test (darwin)
-    runs-on: macos-${{ matrix.os }}
+          - "macos-11"
+          - "macos-12"
+        ruby:
+          - "ruby-2.6"
+          - "ruby-2.7"
+          - "ruby-3.0"
+          - "ruby-3.1"
+
+    name: ${{ matrix.os }} - ${{ matrix.ruby }}
+    runs-on: ${{ matrix.os }}
+
     steps:
-      - name: Checkout
-        uses: actions/checkout@v2
-      - name: Bundle
-        run: bundle install
+      - uses: actions/checkout@v3
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+          bundler-cache: true
       - name: Compile
         run: bundle exec rake compile
       - name: Test
         run: bundle exec rake test
+
   test-linux:
     strategy:
       fail-fast: false
       matrix:
         ruby:
-          - '2.6'
-          - '2.7'
-          - '3.0'
+          - "2.6"
+          - "2.7"
+          - "3.0"
+          - "3.1"
         platform:
-          - amd64
-          - arm64
-          # arm
-          # ppc64le
-          # s390x
+          - "amd64"
+          - "arm64"
         libc:
-          - gnu
-          - musl
-    name: Test (linux)
+          - "gnu"
+          - "musl"
+        exclude:
+          # there's no libv8-node (v16) for aarch64-linux-musl at the moment
+          - platform: "arm64"
+            libc: "musl"
+
+    name: linux-${{ matrix.platform }} - ruby-${{ matrix.ruby }} - ${{ matrix.libc }}
     runs-on: ubuntu-20.04
+
     steps:
       - name: Enable ${{ matrix.platform }} platform
         id: qemu
@@ -67,9 +111,11 @@ jobs:
           echo "::set-output name=id::$(cat container_id)"
       - name: Install Alpine system dependencies
         if: ${{ matrix.libc == 'musl' }}
-        run: docker exec -w "${PWD}" ${{ steps.container.outputs.id }} apk add --no-cache build-base linux-headers bash python2 python3 git curl tar clang binutils-gold
+        run: docker exec -w "${PWD}" ${{ steps.container.outputs.id }} apk add --no-cache build-base bash git
       - name: Checkout
-        uses: actions/checkout@v2
+        uses: actions/checkout@v3
+      - name: Update Rubygems
+        run: docker exec -w "${PWD}" ${{ steps.container.outputs.id }} gem update --system
       - name: Bundle
         run: docker exec -w "${PWD}" ${{ steps.container.outputs.id }} bundle install
       - name: Compile

data/CHANGELOG

@@ -1,4 +1,20 @@
-- 17-01-2021
+- 25-05-2022
+
+- 0.6.4
+
+  - Target Node 16.19.0.0
+
+- 16-08-2022
+
+- 0.6.3
+
+  - Truffle ruby support! Thanks to Brandon Fish and the truffle team
+  - Hide libv8 symbols on ELF targets
+  - Slightly shrunk binary size
+  - Simplified timeout implementation
+  - Some stability fixes
+
+- 17-01-2022
 
 - 0.6.2
 

data/README.md

@@ -1,6 +1,6 @@
 # MiniRacer
 
-[![Build Status](https://travis-ci.org/rubyjs/mini_racer.svg?branch=master)](https://travis-ci.org/rubyjs/mini_racer)
+[![Test](https://github.com/rubyjs/mini_racer/actions/workflows/ci.yml/badge.svg)](https://github.com/rubyjs/mini_racer/actions/workflows/ci.yml)
 
 Minimal, modern embedded V8 for Ruby.
 
@@ -10,12 +10,14 @@ It was created as an alternative to the excellent [therubyracer](https://github.
 
 MiniRacer has an adapter for [execjs](https://github.com/rails/execjs) so it can be used directly with Rails projects to minify assets, run babel or compile CoffeeScript.
 
-### A note about Ruby version Support
+### Supported Ruby Versions
 
-MiniRacer only supports non-EOL versions of Ruby. See [Ruby](https://www.ruby-lang.org/en/downloads) to see the list of non-EOL Rubies.
+MiniRacer only supports non-EOL versions of Ruby. See [Ruby Maintenance Branches](https://www.ruby-lang.org/en/downloads/branches/) for the list of non-EOL Rubies.
 
 If you require support for older versions of Ruby install an older version of the gem.
 
+MiniRacer **does not support** [Ruby built on MinGW](https://github.com/rubyjs/mini_racer/issues/252#issuecomment-1201172236, "pure windows" no Cygwin, no WSL2) (see https://github.com/rubyjs/libv8-node/issues/9).
+
 ## Features
 
 ### Simple eval for JavaScript
@@ -112,16 +114,21 @@ context.eval('bar()', filename: 'a/bar.js')
 
 ### Fork safety
 
-Some Ruby web servers employ forking (for example unicorn or puma in clustered mode). V8 is not fork safe.
-Sadly Ruby does not have support for fork notifications per [#5446](https://bugs.ruby-lang.org/issues/5446).
+Some Ruby web servers employ forking (for example unicorn or puma in clustered mode). V8 is not fork safe by default and sadly Ruby does not have support for fork notifications per [#5446](https://bugs.ruby-lang.org/issues/5446).
+
+Since 0.6.1 mini_racer does support V8 single threaded platform mode which should remove most forking related issues. To enable run this before using `MiniRacer::Context`:
+
+```ruby
+MiniRacer::Platform.set_flags!(:single_threaded)
+```
 
 If you want to ensure your application does not leak memory after fork either:
 
-1. Ensure no MiniRacer::Context objects are created in the master process
+1. Ensure no `MiniRacer::Context` objects are created in the master process
 
 Or
 
-2. Dispose manually of all MiniRacer::Context objects prior to forking
+2. Dispose manually of all `MiniRacer::Context` objects prior to forking
 
 ```ruby
 # before fork
@@ -419,18 +426,15 @@ Or install it yourself as:
 **Note** using v8.h and compiling MiniRacer requires a C++11 standard compiler, more specifically clang 3.5 (or later) or GCC 6.3 (or later).
 
 
-## Travis-ci
+### Troubleshooting
 
-To install `mini-racer` you will need a version of GCC that supports C++11 (GCC 6.3) this is included by default in ubuntu trusty based images.
+If you have a problem installing mini_racer, please consider the following steps:
 
-Travis today ships by default with a precise based image. Precise Pangolin (12.04 LTS) was first released in August 2012. Even though you can install GCC 6.3 on precise the simpler approach is to opt for the trusty based image.
-
-Add this to your .travis.yml file:
-
-```
-- sudo: required
-- dist: trusty
-```
+* make sure you try the latest released version of mini_racer
+* make sure you have Rubygems >= 3.2.13 and bundler >= 2.2.13 installed via `gem update --system`
+* if you are using bundler, make sure to have `PLATFORMS` set correctly in `Gemfile.lock` via `bundle lock --add-platform`
+* make sure to recompile/reinstall `mini_racer` and `libv8-node` after system upgrades (for example via `gem uninstall --all mini_racer libv8-node`)
+* make sure you are on the latest patch/teeny version of a supported Ruby branch
 
 ## Similar Projects
 

data/Rakefile

@@ -1,6 +1,5 @@
 require "bundler/gem_tasks"
 require "rake/testtask"
-require "rake/extensiontask"
 
 Rake::TestTask.new(:test) do |t|
   t.libs << "test"
@@ -11,8 +10,21 @@ end
 task :default => [:compile, :test]
 
 gem = Gem::Specification.load( File.dirname(__FILE__) + '/mini_racer.gemspec' )
-Rake::ExtensionTask.new( 'mini_racer_loader', gem )
-Rake::ExtensionTask.new( 'mini_racer_extension', gem )
+
+if RUBY_ENGINE == "truffleruby"
+  task :compile do
+    # noop
+  end
+
+  task :clean do
+    # noop
+  end
+else
+  require 'rake/extensiontask'
+  Rake::ExtensionTask.new( 'mini_racer_loader', gem )
+  Rake::ExtensionTask.new( 'mini_racer_extension', gem )
+end
+
 
 
 # via http://blog.flavorjon.es/2009/06/easily-valgrind-gdb-your-ruby-c.html

data/ext/mini_racer_extension/extconf.rb

@@ -1,4 +1,10 @@
 require 'mkmf'
+
+if RUBY_ENGINE == "truffleruby"
+  File.write("Makefile", dummy_makefile($srcdir).join(""))
+  return
+end
+
 require_relative '../../lib/mini_racer/version'
 gem 'libv8-node', MiniRacer::LIBV8_NODE_VERSION
 require 'libv8-node'
@@ -70,6 +76,9 @@ end
 
 Libv8::Node.configure_makefile
 
+# --exclude-libs is only for i386 PE and ELF targeted ports
+append_ldflags("-Wl,--exclude-libs=ALL ")
+
 if enable_config('asan')
   $CXXFLAGS.insert(0, " -fsanitize=address ")
   $LDFLAGS.insert(0, " -fsanitize=address ")

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();
 
@@ -664,11 +660,7 @@ static VALUE convert_v8_to_ruby(Isolate* isolate, Local<Context> context,
 	v8::String::Utf8Value symbol_name(isolate,
 	    Local<Symbol>::Cast(value)->Name());
 
-	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));
     }
 }
 
@@ -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.6.4"
+  LIBV8_NODE_VERSION = "~> 16.19.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:)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mini_racer
 version: !ruby/object:Gem::Version
-  version: 0.6.2
+  version: 0.6.4
 platform: ruby
 authors:
 - Sam Saffron
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-01-16 00:00:00.000000000 Z
+date: 2023-05-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -86,14 +86,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 16.10.0.0
+        version: 16.19.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 16.10.0.0
+        version: 16.19.0.0
 description: Minimal embedded v8 engine for Ruby
 email:
 - sam.saffron@gmail.com
@@ -106,7 +106,6 @@ files:
 - ".dockerignore"
 - ".github/workflows/ci.yml"
 - ".gitignore"
-- ".travis.yml"
 - CHANGELOG
 - CODE_OF_CONDUCT.md
 - Dockerfile
@@ -121,6 +120,7 @@ files:
 - ext/mini_racer_loader/extconf.rb
 - ext/mini_racer_loader/mini_racer_loader.c
 - lib/mini_racer.rb
+- lib/mini_racer/truffleruby.rb
 - lib/mini_racer/version.rb
 - mini_racer.gemspec
 homepage: https://github.com/discourse/mini_racer
@@ -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.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
+  changelog_uri: https://github.com/discourse/mini_racer/blob/v0.6.4/CHANGELOG
+  documentation_uri: https://www.rubydoc.info/gems/mini_racer/0.6.4
+  source_code_uri: https://github.com/discourse/mini_racer/tree/v0.6.4
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -147,7 +147,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.6
+rubygems_version: 3.4.6
 signing_key:
 specification_version: 4
 summary: Minimal embedded v8 for Ruby

data/.travis.yml

@@ -1,23 +0,0 @@
-language: ruby
-os: linux
-rvm:
-  - 2.6
-  - 2.7
-  - 3.0
-  - ruby-head
-arch:
-  - amd64
-  - arm64
-jobs:
-  include:
-    - rvm: 2.6
-      os: osx
-      osx_image: xcode11.3
-    - rvm: 2.6
-      os: osx
-      osx_image: xcode12.2
-    - rvm: 2.7
-      os: osx
-      osx_image: xcode12.2
-dist: xenial
-cache: bundler