sq_mini_racer 0.2.4.sqreen3 → 0.2.5.0.1.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: da4cace43c9af136e8d30f3918dbd99af25f72fd904d7db9a888a843925000ba
-  data.tar.gz: 3f234d5dafea154baa80d0a459bcff351cb0c0d01ed2604b293bd22756809303
+  metadata.gz: a4deece72e6d02478b4381a59ab9b1988a2fbff6a30e811596183240699fd018
+  data.tar.gz: ac83f077c9b56423cd8b8e716d8102bec73050c8a4ae0e525fda931f43ec6762
 SHA512:
-  metadata.gz: 9b461007d884a961d3b081ceac7c5d815477d3993ced64f108ae078ede7d54318a0a3aa3b504431b50d6b7167ea4f0ac592f097406e31c35cd184bb25e84ac6b
-  data.tar.gz: a8e76f1ddd78a6578aaa35424f87ffce467065cf1b981af9673a6a7e01d5c6e0263161eaa68f1263acffd20e400ae0453a9a388cc0735d7d75b539f6d2973b09
+  metadata.gz: cad6011c1066ccc51e1c3bfe3064c50e7dbdc6dd04127ce24f855a97f9ba8fd492a5de3b1af54b810b4a112d74f03bcd746c8d95af822a5f9d59e8cd9cdce8a2
+  data.tar.gz: f985a398202455acfadd914606306d5469928bfbf69394fd39b5a79b097f81a6994bf4875bb7765d01b4fd2797b00378a5e3d23de4a05b4d3588216e3ac59cc9

data/CHANGELOG

@@ -1,3 +1,18 @@
+- 14-05-2019
+
+- 0.2.6
+
+  - FEATURE: add support for write_heap_snapshot which helps you analyze memory
+
+- 25-04-2019
+
+- 0.2.5
+
+  - FIX: Compatiblity fixes for V8 7 and above @ignisf
+  - FIX: Memory leak in gc_callback @messense
+  - IMPROVEMENT: Added example of sourcemap support @ianks
+  - URGENT: you will need this release for latest version of libv8 to work
+
 - 02-11-2018
 
 - 0.2.4

data/README.md

@@ -101,6 +101,27 @@ 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).
+
+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
+
+Or
+
+2. Dispose manually of all MiniRacer::Context objects prior to forking
+
+```ruby
+# before fork
+
+require 'objspace'
+ObjectSpace.each_object(MiniRacer::Context){|c| c.dispose}
+
+# fork here
+```
 
 ### Threadsafe
 
@@ -350,6 +371,10 @@ Note how the global interpreter lock release leads to 2 threads doing the same w
 
 As a rule MiniRacer strives to always support and depend on the latest stable version of libv8.
 
+## Source Maps
+
+MiniRacer can fully support source maps but must be configured correctly to do so. [Check out this example](./examples/source-map-support/) for a working implementation.
+
 ## Installation
 
 Add this line to your application's Gemfile:

data/Rakefile

@@ -19,6 +19,22 @@ Rake::ExtensionTask.new('prv_ext_loader', gem)
 
 # via http://blog.flavorjon.es/2009/06/easily-valgrind-gdb-your-ruby-c.html
 namespace :test do
+  desc "run test suite with Address Sanitizer"
+  task :asan do
+    ENV["CONFIGURE_ARGS"] = [ENV["CONFIGURE_ARGS"], '--enable-asan'].compact.join(' ')
+    Rake::Task['compile'].invoke
+
+    asan_path = `ldconfig -N -p |grep libasan | grep -v 32 | sed 's/.* => \\(.*\\)$/\\1/'`.chomp.split("\n")[-1]
+
+
+    cmdline = "env LD_PRELOAD=\"#{asan_path}\" ruby test/test_leak.rb"
+    puts cmdline
+    system cmdline
+
+    cmdline = "env LD_PRELOAD=\"#{asan_path}\" rake test"
+    puts cmdline
+    system cmdline
+  end
   # partial-loads-ok and undef-value-errors necessary to ignore
   # spurious (and eminently ignorable) warnings from the ruby
   # interpreter
@@ -55,3 +71,28 @@ namespace :test do
     end
   end
 end
+
+desc 'run clang-tidy linter on mini_racer_extension.cc'
+task :lint do
+  require 'mkmf'
+  require 'libv8'
+
+  Libv8.configure_makefile
+
+  conf = RbConfig::CONFIG.merge('hdrdir' => $hdrdir.quote, 'srcdir' => $srcdir.quote,
+                                'arch_hdrdir' => $arch_hdrdir.quote,
+                                'top_srcdir' => $top_srcdir.quote)
+  if $universal and (arch_flag = conf['ARCH_FLAG']) and !arch_flag.empty?
+    conf['ARCH_FLAG'] = arch_flag.gsub(/(?:\G|\s)-arch\s+\S+/, '')
+  end
+
+  checks = %W(bugprone-*
+              cert-*
+              cppcoreguidelines-*
+              clang-analyzer-*
+              performance-*
+              portability-*
+              readability-*).join(',')
+
+  sh RbConfig::expand("clang-tidy -checks='#{checks}' ext/mini_racer_extension/mini_racer_extension.cc -- #$INCFLAGS #$CPPFLAGS", conf)
+end

data/ext/mini_racer_extension/extconf.rb

@@ -1,24 +1,191 @@
 require 'mkmf'
+
 require 'fileutils'
+require 'net/http'
+require 'json'
+require 'rubygems'
+require 'rubygems/package'
 
-IS_DARWIN = RUBY_PLATFORM =~ /darwin/
 IS_SOLARIS = RUBY_PLATFORM =~ /solaris/
+IS_LINUX_MUSL = RUBY_PLATFORM =~ /linux-musl/
+
+def cppflags_clear_std!
+  $CPPFLAGS.gsub! /-std=[^\s]+/, ''
+end
+
+def cppflags_add_frame_pointer!
+  $CPPFLAGS += " -fno-omit-frame-pointer"
+end
+
+def cppflags_add_cpu_extension!
+  if enable_config('avx2')
+    $CPPFLAGS += " -mavx2"
+  else
+    $CPPFLAGS += " -mssse3"
+  end
+end
+
+def libv8_gem_name
+  return "libv8-solaris" if IS_SOLARIS
+  return "libv8-alpine" if IS_LINUX_MUSL
+
+  'libv8'
+end
+
+def libv8_version
+  '7.3.492.27.1'
+end
+
+def libv8_basename
+  "#{libv8_gem_name}-#{libv8_version}-#{ruby_platform}"
+end
+
+def libv8_gemspec
+  "#{libv8_basename}.gemspec"
+end
+
+def libv8_local_path
+  puts "looking for #{libv8_gemspec} in installed gems"
+  candidates = Gem.path.map { |p| File.join(p, 'specifications', libv8_gemspec) }
+  found = candidates.select { |f| File.exist?(f) }.first
+
+  unless found
+    puts "#{libv8_gemspec} not found in installed gems"
+    return
+  end
+
+  puts "found in installed specs: #{found}"
+
+  dir = File.expand_path(File.join(found, '..', '..', 'gems', libv8_basename))
+
+  unless Dir.exist?(dir)
+    puts "not found in installed gems: #{dir}"
+    return
+  end
+
+  puts "found in installed gems: #{dir}"
+
+  dir
+end
+
+def vendor_path
+  File.join(Dir.pwd, 'vendor')
+end
+
+def libv8_vendor_path
+  puts "looking for #{libv8_basename} in #{vendor_path}"
+  path = Dir.glob("#{vendor_path}/#{libv8_basename}").first
+
+  unless path
+    puts "#{libv8_basename} not found in #{vendor_path}"
+    return
+  end
+
+  puts "looking for #{libv8_basename}/lib/libv8.rb in #{vendor_path}"
+  unless Dir.glob(File.join(vendor_path, libv8_basename, 'lib', 'libv8.rb')).first
+    puts "#{libv8_basename}/lib/libv8.rb not found in #{vendor_path}"
+    return
+  end
+
+  path
+end
+
+def parse_platform(str)
+  Gem::Platform.new(str).tap { |p| p.instance_eval { @os = 'linux-musl' } if str =~ /musl/ }
+end
+
+def ruby_platform
+  parse_platform(RUBY_PLATFORM)
+end
+
+def http_get(uri)
+  Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == 'https') do |http|
+    res = http.get(uri.path)
+
+    abort("HTTP error #{res.code}: #{uri}") unless res.code == '200'
+
+    return res.body
+  end
+end
+
+def libv8_remote_search
+  body = http_get(URI("https://rubygems.org/api/v1/versions/#{libv8_gem_name}.json"))
+  json = JSON.parse(body)
+
+  versions = json.select do |v|
+    Gem::Version.new(v['number']) == Gem::Version.new(libv8_version)
+  end
+  abort(<<-ERROR) if versions.empty?
+  ERROR: could not find #{libv8_version}
+  ERROR
+
+  platform_versions = versions.select do |v|
+    parse_platform(v['platform']) == ruby_platform
+  end
+  abort(<<-ERROR) if platform_versions.empty?
+  ERROR: found #{libv8_gem_name}-#{libv8_version}, but no binary for #{ruby_platform}
+         try "gem install #{libv8_gem_name} -v '#{libv8_version}'" to attempt to build libv8 from source
+  ERROR
+
+  platform_versions.first
+end
+
+def libv8_download_uri(name, version, platform)
+  URI("https://rubygems.org/downloads/#{name}-#{version}-#{platform}.gem")
+end
+
+def libv8_downloaded_gem(name, version, platform)
+  "#{name}-#{version}-#{platform}.gem"
+end
+
+def libv8_download(name, version, platform)
+  FileUtils.mkdir_p(vendor_path)
+  body = http_get(libv8_download_uri(name, version, platform))
+  File.open(File.join(vendor_path, libv8_downloaded_gem(name, version, platform)), 'wb') { |f| f.write(body) }
+end
+
+def libv8_vendor!
+  version = libv8_remote_search
+
+  puts "downloading #{libv8_downloaded_gem(libv8_gem_name, version['number'], version['platform'])} to #{vendor_path}"
+  libv8_download(libv8_gem_name, version['number'], version['platform'])
+
+  package = Gem::Package.new(File.join(vendor_path, libv8_downloaded_gem(libv8_gem_name, version['number'], version['platform'])))
+  package.extract_files(File.join(vendor_path, File.basename(libv8_downloaded_gem(libv8_gem_name, version['number'], version['platform']), '.gem')))
+
+  libv8_vendor_path
+end
+
+def ensure_libv8_load_path
+  puts "detected platform #{RUBY_PLATFORM} => #{ruby_platform}"
+
+  libv8_path = libv8_local_path || libv8_vendor_path || libv8_vendor!
+
+  abort(<<-ERROR) unless libv8_path
+  ERROR: could not find #{libv8_gem_name}
+  ERROR
+
+  $LOAD_PATH.unshift(File.join(libv8_path, 'ext'))
+  $LOAD_PATH.unshift(File.join(libv8_path, 'lib'))
+end
+
+ensure_libv8_load_path
+
+require 'libv8'
+
+IS_DARWIN = RUBY_PLATFORM =~ /darwin/
 
 have_library('pthread')
 have_library('objc') if IS_DARWIN
-$CPPFLAGS.gsub! /-std=[^\s]+/, ''
+cppflags_clear_std!
 $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++0x"
 $CPPFLAGS += " -fpermissive"
-$CPPFLAGS += " -fno-omit-frame-pointer"
-if enable_config('avx2')
-  $CPPFLAGS += " -mavx2"
-else
-  $CPPFLAGS += " -mssse3"
-end
+cppflags_add_frame_pointer!
+cppflags_add_cpu_extension!
 
 $CPPFLAGS += " -Wno-reserved-user-defined-literal" if IS_DARWIN
 
@@ -57,103 +224,15 @@ if CONFIG['warnflags']
   CONFIG['warnflags'].gsub!('-Wimplicit-function-declaration', '')
 end
 
-if enable_config('debug')
+if enable_config('debug') || enable_config('asan')
   CONFIG['debugflags'] << ' -ggdb3 -O0'
 end
 
-def fixup_libtinfo
-  dirs = %w[/lib64 /usr/lib64 /lib /usr/lib]
-  found_v5 = dirs.map { |d| "#{d}/libtinfo.so.5" }.find &File.method(:file?)
-  return '' if found_v5
-  found_v6 = dirs.map { |d| "#{d}/libtinfo.so.6" }.find &File.method(:file?)
-  return '' unless found_v6
-  FileUtils.ln_s found_v6, 'gemdir/libtinfo.so.5', :force => true
-  "LD_LIBRARY_PATH='#{File.expand_path('gemdir')}:#{ENV['LD_LIBRARY_PATH']}'"
-end
-
-def libv8_gem_name
-  return "libv8-solaris" if IS_SOLARIS
-
-  is_musl = false
-  begin
-    is_musl = !!(File.read('/proc/self/maps') =~ /ld-musl-x86_64/)
-  rescue; end
-
-  is_musl ? 'libv8-alpine' : 'libv8'
-end
-
-# 1) old rubygem versions prefer source gems to binary ones
-# ... and their --platform switch is broken too, as it leaves the 'ruby'
-# platform in Gem.platforms.
-# 2) the ruby binaries distributed with alpine (platform ending in -musl)
-# refuse to load binary gems by default
-def force_platform_gem
-  gem_version = `gem --version`
-  return 'gem' unless $?.success?
-
-  if RUBY_PLATFORM != 'x86_64-linux-musl'
-    return 'gem' if gem_version.to_f.zero? || gem_version.to_f >= 2.3
-    return 'gem' if RUBY_PLATFORM != 'x86_64-linux'
-  end
-
-  gem_binary = `which gem`
-  return 'gem' unless $?.success?
-
-  ruby = File.foreach(gem_binary.strip).first.sub(/^#!/, '').strip
-  unless File.file? ruby
-    warn "No valid ruby: #{ruby}"
-    return 'gem'
-  end
-
-  require 'tempfile'
-  file = Tempfile.new('sq_mini_racer')
-  file << <<EOS
-require 'rubygems'
-platforms = Gem.platforms
-platforms.reject! { |it| it == 'ruby' }
-if platforms.empty?
-  platforms << Gem::Platform.new('x86_64-linux')
-end
-Gem.send(:define_method, :platforms) { platforms }
-#{IO.read(gem_binary.strip)}
-EOS
-  file.close
-  "#{ruby} '#{file.path}'"
-end
-
-LIBV8_VERSION = '6.7.288.46.1'
-libv8_rb = Dir.glob('**/libv8.rb').first
-FileUtils.mkdir_p('gemdir')
-unless libv8_rb
-  gem_name = libv8_gem_name
-  cmd = "#{fixup_libtinfo} #{force_platform_gem} install --version '= #{LIBV8_VERSION}' --install-dir gemdir #{gem_name}"
-  puts "Will try downloading #{gem_name} gem: #{cmd}"
-  `#{cmd}`
-  unless $?.success?
-    warn <<EOS
-
-WARNING: Could not download a private copy of the libv8 gem. Please make
-sure that you have internet access and that the `gem` binary is available.
-
-EOS
-  end
-
-  libv8_rb = Dir.glob('**/libv8.rb').first
-  unless libv8_rb
-    warn <<EOS
-
-WARNING: Could not find libv8 after the local copy of libv8 having supposedly
-been installed.
-
-EOS
-  end
-end
+Libv8.configure_makefile
 
-if libv8_rb
-  $:.unshift(File.dirname(libv8_rb) + '/../ext')
-  $:.unshift File.dirname(libv8_rb)
+if enable_config('asan')
+  $CPPFLAGS.insert(0, " -fsanitize=address ")
+  $LDFLAGS.insert(0, " -fsanitize=address ")
 end
 
-require 'libv8'
-Libv8.configure_makefile
 create_makefile 'sq_mini_racer_extension'

data/ext/mini_racer_extension/mini_racer_extension.cc

@@ -23,7 +23,9 @@
 #if RUBY_API_VERSION_MAJOR > 1
 #include <ruby/thread.h>
 #endif
+#include <ruby/io.h>
 #include <v8.h>
+#include <v8-profiler.h>
 #include <libplatform/libplatform.h>
 #include <ruby/encoding.h>
 #include <pthread.h>
@@ -174,7 +176,7 @@ static VALUE rb_mJSON;
 static VALUE rb_cFailedV8Conversion;
 static VALUE rb_cDateTime = Qnil;
 
-static Platform* current_platform = NULL;
+static std::unique_ptr<Platform> current_platform = NULL;
 static std::mutex platform_lock;
 
 static VALUE rb_platform_set_flag_as_str(VALUE _klass, VALUE flag_as_str) {
@@ -211,8 +213,8 @@ static void init_v8() {
 
     if (current_platform == NULL) {
         V8::InitializeICU();
-        current_platform = platform::CreateDefaultPlatform();
-        V8::InitializePlatform(current_platform);
+        current_platform = platform::NewDefaultPlatform();
+        V8::InitializePlatform(current_platform.get());
         V8::Initialize();
     }
 
@@ -254,16 +256,16 @@ 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(
-                        String::NewFromUtf8(isolate, "JSON"))->ToObject();
+            Local<Object> JSON = context->Global()->Get(String::NewFromUtf8(isolate, "JSON"))
+              ->ToObject(context).ToLocalChecked();
 
             Local<Function> stringify = JSON->Get(v8::String::NewFromUtf8(isolate, "stringify"))
                     .As<Function>();
 
-            Local<Object> object = local_value->ToObject();
+            Local<Object> object = local_value->ToObject(context).ToLocalChecked();
             const unsigned argc = 1;
             Local<Value> argv[argc] = { object };
-            MaybeLocal<Value> json = stringify->Call(JSON, argc, argv);
+            MaybeLocal<Value> json = stringify->Call(context, JSON, argc, argv);
 
             if (json.IsEmpty()) {
                 evalRes.executed = false;
@@ -287,11 +289,21 @@ static void prepare_result(MaybeLocal<Value> v8res,
                 evalRes.message = new Persistent<Value>();
                 Local<Message> message = trycatch.Message();
                 char buf[1000];
-                int len;
+                int len, line, column;
+
+                if (!message->GetLineNumber(context).To(&line)) {
+                  line = 0;
+                }
+
+                if (!message->GetStartColumn(context).To(&column)) {
+                  column = 0;
+                }
+
                 len = snprintf(buf, sizeof(buf), "%s at %s:%i:%i", *String::Utf8Value(isolate, message->Get()),
-                               *String::Utf8Value(isolate, message->GetScriptResourceName()->ToString()),
-                               message->GetLineNumber(),
-                               message->GetStartColumn());
+                               *String::Utf8Value(isolate, message->GetScriptResourceName()->ToString(context).ToLocalChecked()),
+                               line,
+                               column);
+
                 if ((size_t) len >= sizeof(buf)) {
                     len = sizeof(buf) - 1;
                     buf[len] = '\0';
@@ -307,7 +319,8 @@ static void prepare_result(MaybeLocal<Value> v8res,
             }
             if (!trycatch.StackTrace(context).IsEmpty()) {
                 evalRes.backtrace = new Persistent<Value>();
-                evalRes.backtrace->Reset(isolate, trycatch.StackTrace(context).ToLocalChecked()->ToString());
+                evalRes.backtrace->Reset(isolate,
+                                         trycatch.StackTrace(context).ToLocalChecked()->ToString(context).ToLocalChecked());
             }
         }
     }
@@ -391,11 +404,11 @@ static VALUE convert_v8_to_ruby(Isolate* isolate, Local<Context> context,
     }
 
     if (value->IsInt32()) {
-        return INT2FIX(value->Int32Value());
+        return INT2FIX(value->Int32Value(context).ToChecked());
     }
 
     if (value->IsNumber()) {
-        return rb_float_new(value->NumberValue());
+        return rb_float_new(value->NumberValue(context).ToChecked());
     }
 
     if (value->IsTrue()) {
@@ -436,7 +449,7 @@ static VALUE convert_v8_to_ruby(Isolate* isolate, Local<Context> context,
         VALUE rb_hash = rb_hash_new();
         TryCatch trycatch(isolate);
 
-        Local<Object> object = value->ToObject();
+        Local<Object> object = value->ToObject(context).ToLocalChecked();
         auto maybe_props = object->GetOwnPropertyNames(context);
         if (!maybe_props.IsEmpty()) {
             Local<Array> props = maybe_props.ToLocalChecked();
@@ -459,8 +472,8 @@ static VALUE convert_v8_to_ruby(Isolate* isolate, Local<Context> context,
         return rb_hash;
     }
 
-    Local<String> rstr = value->ToString();
-    return rb_enc_str_new(*String::Utf8Value(isolate, rstr), rstr->Utf8Length(), rb_enc_find("utf-8"));
+    Local<String> rstr = value->ToString(context).ToLocalChecked();
+    return rb_enc_str_new(*String::Utf8Value(isolate, rstr), rstr->Utf8Length(isolate), rb_enc_find("utf-8"));
 }
 
 static VALUE convert_v8_to_ruby(Isolate* isolate,
@@ -557,7 +570,7 @@ treat_as_latin1:
     return v8str.ToLocalChecked();
 }
 
-static Local<Value> convert_ruby_to_v8(Isolate* isolate, VALUE value)
+static Local<Value> convert_ruby_to_v8(Isolate* isolate, Local<Context> context, VALUE value)
 {
     EscapableHandleScope scope(isolate);
 
@@ -571,87 +584,86 @@ static Local<Value> convert_ruby_to_v8(Isolate* isolate, VALUE value)
     VALUE klass;
 
     switch (TYPE(value)) {
-        case T_FIXNUM:
+    case T_FIXNUM:
         {
-            fixnum = NUM2LONG(value);
-            if (fixnum > INT_MAX)
-            {
-                return scope.Escape(Number::New(isolate, (double)fixnum));
-            }
-            return scope.Escape(Integer::New(isolate, (int)fixnum));
+        fixnum = NUM2LONG(value);
+        if (fixnum > INT_MAX)
+        {
+            return scope.Escape(Number::New(isolate, (double)fixnum));
+        }
+        return scope.Escape(Integer::New(isolate, (int)fixnum));
         }
-        case T_FLOAT:
-            return scope.Escape(Number::New(isolate, NUM2DBL(value)));
-        case T_STRING:
+    case T_FLOAT:
+	return scope.Escape(Number::New(isolate, NUM2DBL(value)));
+    case T_STRING:
             return scope.Escape(convert_ruby_str_to_v8(scope, isolate, value));
-        case T_NIL:
-            return scope.Escape(Null(isolate));
-        case T_TRUE:
-            return scope.Escape(True(isolate));
-        case T_FALSE:
-            return scope.Escape(False(isolate));
-        case T_ARRAY:
+    case T_NIL:
+	return scope.Escape(Null(isolate));
+    case T_TRUE:
+	return scope.Escape(True(isolate));
+    case T_FALSE:
+	return scope.Escape(False(isolate));
+    case T_ARRAY:
         {
-            length = RARRAY_LEN(value);
-            array = Array::New(isolate, (int)length);
-            for(i=0; i<length; i++) {
-                array->Set(i, convert_ruby_to_v8(isolate, rb_ary_entry(value, i)));
-            }
-            return scope.Escape(array);
+	length = RARRAY_LEN(value);
+	array = Array::New(isolate, (int)length);
+	for(i=0; i<length; i++) {
+      array->Set(i, convert_ruby_to_v8(isolate, context, rb_ary_entry(value, i)));
+	}
+	return scope.Escape(array);
         }
-        case T_HASH:
+    case T_HASH:
         {
-            object = Object::New(isolate);
-            hash_as_array = rb_funcall(value, rb_intern("to_a"), 0);
-            length = RARRAY_LEN(hash_as_array);
-            for(i=0; i<length; i++) {
-                pair = rb_ary_entry(hash_as_array, i);
-                object->Set(convert_ruby_to_v8(isolate, rb_ary_entry(pair, 0)),
-                            convert_ruby_to_v8(isolate, rb_ary_entry(pair, 1)));
-            }
-            return scope.Escape(object);
+	object = Object::New(isolate);
+	hash_as_array = rb_funcall(value, rb_intern("to_a"), 0);
+	length = RARRAY_LEN(hash_as_array);
+	for(i=0; i<length; i++) {
+	    pair = rb_ary_entry(hash_as_array, i);
+	    object->Set(convert_ruby_to_v8(isolate, context, rb_ary_entry(pair, 0)),
+                  convert_ruby_to_v8(isolate, context, rb_ary_entry(pair, 1)));
+	}
+	return scope.Escape(object);
         }
-        case T_SYMBOL:
+    case T_SYMBOL:
         {
-            value = rb_funcall(value, rb_intern("to_s"), 0);
+	value = rb_funcall(value, rb_intern("to_s"), 0);
             return scope.Escape(convert_ruby_str_to_v8(scope, isolate, value));
         }
-        case T_DATA:
+    case T_DATA:
+        {
+        klass = rb_funcall(value, rb_intern("class"), 0);
+        if (klass == rb_cTime || klass == rb_cDateTime)
         {
-            klass = rb_funcall(value, rb_intern("class"), 0);
-            if (klass == rb_cTime || klass == rb_cDateTime)
+            if (klass == rb_cDateTime)
             {
-                if (klass == rb_cDateTime)
-                {
-                    value = rb_funcall(value, rb_intern("to_time"), 0);
-                }
-                value = rb_funcall(value, rb_intern("to_f"), 0);
-                return scope.Escape(Date::New(isolate, NUM2DBL(value) * 1000));
+                value = rb_funcall(value, rb_intern("to_time"), 0);
             }
+            value = rb_funcall(value, rb_intern("to_f"), 0);
+            return scope.Escape(Date::New(context, NUM2DBL(value) * 1000).ToLocalChecked());
+        }
             // break intentionally missing
         }
-        case T_OBJECT:
-        case T_CLASS:
-        case T_ICLASS:
-        case T_MODULE:
-        case T_REGEXP:
-        case T_MATCH:
-        case T_STRUCT:
-        case T_BIGNUM:
-        case T_FILE:
-        case T_UNDEF:
-        case T_NODE:
-        default:
+    case T_OBJECT:
+    case T_CLASS:
+    case T_ICLASS:
+    case T_MODULE:
+    case T_REGEXP:
+    case T_MATCH:
+    case T_STRUCT:
+    case T_BIGNUM:
+    case T_FILE:
+    case T_UNDEF:
+    case T_NODE:
+    default:
         {
             if (rb_respond_to(value, rb_intern("to_s"))) {
                 // TODO: if this throws we're screwed
                 value = rb_funcall(value, rb_intern("to_s"), 0);
                 return scope.Escape(convert_ruby_str_to_v8(scope, isolate, value));
             }
-            return scope.Escape(String::NewFromUtf8(isolate, "Undefined Conversion"));
-        }
+      return scope.Escape(String::NewFromUtf8(isolate, "Undefined Conversion"));
+    }
     }
-
 }
 
 static void unblock_eval(void *ptr) {
@@ -659,6 +671,91 @@ static void unblock_eval(void *ptr) {
     eval->context_info->isolate_info->interrupted = true;
 }
 
+/*
+ * The implementations of the run_extra_code(), create_snapshot_data_blob() and
+ * warm_up_snapshot_data_blob() functions have been derived from V8's test suite.
+ */
+bool run_extra_code(Isolate *isolate, Local<v8::Context> context,
+                    const char *utf8_source, const char *name) {
+    Context::Scope context_scope(context);
+    TryCatch try_catch(isolate);
+    Local<String> source_string;
+    if (!String::NewFromUtf8(isolate, utf8_source,
+                             NewStringType::kNormal)
+             .ToLocal(&source_string)) {
+        return false;
+    }
+    Local<v8::String> resource_name =
+        String::NewFromUtf8(isolate, name, NewStringType::kNormal)
+            .ToLocalChecked();
+    ScriptOrigin origin(resource_name);
+    ScriptCompiler::Source source(source_string, origin);
+    Local<Script> script;
+    if (!ScriptCompiler::Compile(context, &source).ToLocal(&script))
+        return false;
+    if (script->Run(context).IsEmpty())
+        return false;
+    // CHECK(!try_catch.HasCaught());
+    return true;
+}
+
+StartupData
+create_snapshot_data_blob(const char *embedded_source = nullptr) {
+    // Create a new isolate and a new context from scratch, optionally run
+    // a script to embed, and serialize to create a snapshot blob.
+    StartupData result = {nullptr, 0};
+    {
+        SnapshotCreator snapshot_creator;
+        Isolate *isolate = snapshot_creator.GetIsolate();
+        {
+            HandleScope scope(isolate);
+            Local<Context> context = Context::New(isolate);
+            if (embedded_source != nullptr &&
+                !run_extra_code(isolate, context, embedded_source,
+                                "<embedded>")) {
+                return result;
+            }
+            snapshot_creator.SetDefaultContext(context);
+        }
+        result = snapshot_creator.CreateBlob(
+            SnapshotCreator::FunctionCodeHandling::kClear);
+    }
+    return result;
+}
+
+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:
+    //  - Create a new isolate from the cold snapshot.
+    //  - Create a new context to run the warmup script. This will trigger
+    //    compilation of executed functions.
+    //  - Create a new context. This context will be unpolluted.
+    //  - Serialize the isolate and the second context into a new snapshot blob.
+    StartupData result = {nullptr, 0};
+
+    if (cold_snapshot_blob.raw_size > 0 && cold_snapshot_blob.data != nullptr &&
+        warmup_source != NULL) {
+        SnapshotCreator snapshot_creator(nullptr, &cold_snapshot_blob);
+        Isolate *isolate = snapshot_creator.GetIsolate();
+        {
+            HandleScope scope(isolate);
+            Local<Context> context = Context::New(isolate);
+            if (!run_extra_code(isolate, context, warmup_source, "<warm-up>")) {
+                return result;
+            }
+        }
+        {
+            HandleScope handle_scope(isolate);
+            isolate->ContextDisposedNotification(false);
+            Local<Context> context = Context::New(isolate);
+            snapshot_creator.SetDefaultContext(context);
+        }
+        result = snapshot_creator.CreateBlob(
+            SnapshotCreator::FunctionCodeHandling::kKeep);
+    }
+    return result;
+}
+
 static VALUE rb_snapshot_size(VALUE self, VALUE str) {
     SnapshotInfo* snapshot_info;
     Data_Get_Struct(self, SnapshotInfo, snapshot_info);
@@ -677,7 +774,7 @@ static VALUE rb_snapshot_load(VALUE self, VALUE str) {
 
     init_v8();
 
-    StartupData startup_data = V8::CreateSnapshotDataBlob(RSTRING_PTR(str));
+    StartupData startup_data = create_snapshot_data_blob(RSTRING_PTR(str));
 
     if (startup_data.data == NULL && startup_data.raw_size == 0) {
         rb_raise(rb_eSnapshotError, "Could not create snapshot, most likely the source is incorrect");
@@ -708,7 +805,7 @@ static VALUE rb_snapshot_warmup_unsafe(VALUE self, VALUE str) {
     init_v8();
 
     StartupData cold_startup_data = {snapshot_info->data, snapshot_info->raw_size};
-    StartupData warm_startup_data = V8::WarmUpSnapshotDataBlob(cold_startup_data, RSTRING_PTR(str));
+    StartupData warm_startup_data = warm_up_snapshot_data_blob(cold_startup_data, RSTRING_PTR(str));
 
     if (warm_startup_data.data == NULL && warm_startup_data.raw_size == 0) {
         rb_raise(rb_eSnapshotError, "Could not warm up snapshot, most likely the source is incorrect");
@@ -887,8 +984,8 @@ static VALUE convert_result_to_ruby(VALUE self /* context */,
         Local<Value> tmp = Local<Value>::New(isolate, *result.value);
 
         if (result.json) {
-            Local<String> rstr = tmp->ToString();
-            VALUE json_string = rb_enc_str_new(*String::Utf8Value(isolate, rstr), rstr->Utf8Length(), rb_enc_find("utf-8"));
+            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"));
             ret = rb_funcall(rb_mJSON, rb_intern("parse"), 1, json_string);
         } else {
             ret = convert_v8_to_ruby(isolate, *p_ctx, tmp);
@@ -1009,6 +1106,8 @@ gvl_ruby_callback(void* data) {
     VALUE result;
     VALUE self;
     VALUE parent;
+    ContextInfo* context_info;
+
     {
         HandleScope scope(args->GetIsolate());
         Local<External> external = Local<External>::Cast(args->Data());
@@ -1021,7 +1120,6 @@ gvl_ruby_callback(void* data) {
             return NULL;
         }
 
-        ContextInfo* context_info;
         Data_Get_Struct(parent, ContextInfo, context_info);
 
         if (length > 0) {
@@ -1031,7 +1129,7 @@ gvl_ruby_callback(void* data) {
         for (int i = 0; i < length; i++) {
             Local<Value> value = ((*args)[i]).As<Value>();
             VALUE tmp = convert_v8_to_ruby(args->GetIsolate(),
-                              *context_info->context, value);
+                                           *context_info->context, value);
             rb_ary_push(ruby_args, tmp);
         }
     }
@@ -1062,7 +1160,7 @@ gvl_ruby_callback(void* data) {
     }
     else {
         HandleScope scope(args->GetIsolate());
-        Handle<Value> v8_result = convert_ruby_to_v8(args->GetIsolate(), result);
+        Handle<Value> v8_result = convert_ruby_to_v8(args->GetIsolate(), context_info->context->Get(args->GetIsolate()), result);
         args->GetReturnValue().Set(v8_result);
     }
 
@@ -1119,8 +1217,10 @@ static VALUE rb_external_function_notify_v8(VALUE self) {
         Local<Context> context = context_info->context->Get(isolate);
         Context::Scope context_scope(context);
 
-        Local<String> v8_str = String::NewFromUtf8(isolate, RSTRING_PTR(name),
-                              NewStringType::kNormal, (int)RSTRING_LEN(name)).ToLocalChecked();
+        Local<String> v8_str =
+            String::NewFromUtf8(isolate, RSTRING_PTR(name),
+                                NewStringType::kNormal, (int)RSTRING_LEN(name))
+                .ToLocalChecked();
 
         // copy self so we can access from v8 external
         VALUE* self_copy;
@@ -1130,23 +1230,34 @@ static VALUE rb_external_function_notify_v8(VALUE self) {
         Local<Value> external = External::New(isolate, self_copy);
 
         if (parent_object == Qnil) {
-            context->Global()->Set(v8_str, FunctionTemplate::New(isolate, ruby_callback, external)->GetFunction());
-        } else {
+            context->Global()->Set(
+                v8_str, FunctionTemplate::New(isolate, ruby_callback, external)
+                            ->GetFunction(context)
+                            .ToLocalChecked());
 
-            Local<String> eval = String::NewFromUtf8(isolate, RSTRING_PTR(parent_object_eval),
-                                  NewStringType::kNormal, (int)RSTRING_LEN(parent_object_eval)).ToLocalChecked();
+        } else {
+            Local<String> eval =
+                String::NewFromUtf8(isolate, RSTRING_PTR(parent_object_eval),
+                                    NewStringType::kNormal,
+                                    (int)RSTRING_LEN(parent_object_eval))
+                    .ToLocalChecked();
 
             MaybeLocal<Script> parsed_script = Script::Compile(context, eval);
             if (parsed_script.IsEmpty()) {
             parse_error = true;
             } else {
-                MaybeLocal<Value> maybe_value = parsed_script.ToLocalChecked()->Run(context);
+                MaybeLocal<Value> maybe_value =
+                    parsed_script.ToLocalChecked()->Run(context);
                 attach_error = true;
 
                 if (!maybe_value.IsEmpty()) {
                     Local<Value> value = maybe_value.ToLocalChecked();
-                    if (value->IsObject()){
-                    value.As<Object>()->Set(v8_str, FunctionTemplate::New(isolate, ruby_callback, external)->GetFunction());
+                    if (value->IsObject()) {
+                        value.As<Object>()->Set(
+                            v8_str, FunctionTemplate::New(
+                                        isolate, ruby_callback, external)
+                                        ->GetFunction(context)
+                                        .ToLocalChecked());
                     attach_error = false;
                     }
                 }
@@ -1350,6 +1461,69 @@ rb_heap_stats(VALUE self) {
     return rval;
 }
 
+// https://github.com/bnoordhuis/node-heapdump/blob/master/src/heapdump.cc
+class FileOutputStream : public OutputStream {
+ public:
+  FileOutputStream(FILE* stream) : stream_(stream) {}
+
+  virtual int GetChunkSize() {
+    return 65536;
+  }
+
+  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;
+  }
+
+ private:
+  FILE* stream_;
+};
+
+
+static VALUE
+rb_heap_snapshot(VALUE self, VALUE file) {
+
+    rb_io_t *fptr;
+
+    fptr = RFILE(file)->fptr;
+
+    if (!fptr) return Qfalse;
+
+    FILE* fp;
+    fp = fdopen(fptr->fd, "w");
+    if (fp == NULL) return Qfalse;
+
+
+    ContextInfo* context_info;
+    Data_Get_Struct(self, ContextInfo, context_info);
+    Isolate* isolate;
+    isolate = context_info->isolate_info ? context_info->isolate_info->isolate : NULL;
+
+    if (!isolate) return Qfalse;
+
+    Locker lock(isolate);
+    Isolate::Scope isolate_scope(isolate);
+    HandleScope handle_scope(isolate);
+
+    HeapProfiler* heap_profiler = isolate->GetHeapProfiler();
+
+    const HeapSnapshot* const snap = heap_profiler->TakeHeapSnapshot();
+
+    FileOutputStream stream(fp);
+    snap->Serialize(&stream, HeapSnapshot::kJSON);
+
+    const_cast<HeapSnapshot*>(snap)->Delete();
+
+    return Qtrue;
+}
+
 static VALUE
 rb_context_stop(VALUE self) {
 
@@ -1494,7 +1668,7 @@ static VALUE rb_context_call_unsafe(int argc, VALUE *argv, VALUE self) {
                     return Qnil;
                 }
                 for(int i=0; i < fun_argc; i++) {
-                    call.argv[i] = convert_ruby_to_v8(isolate, call_argv[i]);
+                    call.argv[i] = convert_ruby_to_v8(isolate, context, call_argv[i]);
                 }
             }
     #if RUBY_API_VERSION_MAJOR > 1
@@ -1558,6 +1732,8 @@ extern "C" {
         rb_define_method(rb_cContext, "dispose_unsafe", (VALUE(*)(...))&rb_context_dispose, 0);
         rb_define_method(rb_cContext, "low_memory_notification", (VALUE(*)(...))&rb_context_low_memory_notification, 0);
         rb_define_method(rb_cContext, "heap_stats", (VALUE(*)(...))&rb_heap_stats, 0);
+	rb_define_method(rb_cContext, "write_heap_snapshot_unsafe", (VALUE(*)(...))&rb_heap_snapshot, 1);
+
         rb_define_private_method(rb_cContext, "create_isolate_value",(VALUE(*)(...))&rb_context_create_isolate_value, 0);
         rb_define_private_method(rb_cContext, "eval_unsafe",(VALUE(*)(...))&rb_context_eval_unsafe, 2);
         rb_define_private_method(rb_cContext, "call_unsafe", (VALUE(*)(...))&rb_context_call_unsafe, -1);

data/lib/sqreen/mini_racer.rb

@@ -178,6 +178,28 @@ module MiniRacer
       eval(File.read(filename))
     end
 
+    def write_heap_snapshot(file_or_io)
+      f = nil
+      implicit = false
+
+
+      if String === file_or_io
+        f = File.open(file_or_io, "w")
+        implicit = true
+      else
+        f = file_or_io
+      end
+
+      if !(File === f)
+        raise ArgumentError("file_or_io")
+      end
+
+      write_heap_snapshot_unsafe(f)
+
+    ensure
+      f.close if implicit
+    end
+
     def eval(str, options=nil)
       raise(ContextDisposedError, 'attempted to call eval on a disposed context!') if @disposed
 

data/lib/sqreen/mini_racer/version.rb

@@ -2,6 +2,6 @@ module Sqreen
 module MiniRacer
   # part before qualifier is the number of the last upstream release
   # since we synced with it
-  VERSION = "0.2.4.sqreen3"
+  VERSION = "0.2.5.0.1.beta1"
 end
 end

data/mini_racer.gemspec

@@ -15,7 +15,7 @@ Gem::Specification.new do |spec|
   spec.license       = "MIT"
 
 
-  REJECTS            = %r{\A((benchmark|test|spec|features)/|bench\.rb|.+\.sh|Jenkinsfile)}
+  REJECTS            = %r{\A((benchmark|test|spec|features|examples)/|bench\.rb|.+\.sh|Jenkinsfile)}
   spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(REJECTS) }
   spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sq_mini_racer
 version: !ruby/object:Gem::Version
-  version: 0.2.4.sqreen3
+  version: 0.2.5.0.1.beta1
 platform: ruby
 authors:
 - Sam Saffron
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-04-19 00:00:00.000000000 Z
+date: 2019-08-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler