sq_mini_racer 0.2.4.0.2 → 0.2.5.0.1.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eb7be23e127c27a87be5d25075c26ec77ba06f19878e69088827077b6fc5844b
-  data.tar.gz: cc1a09e6683d40813f8702cd683b0237aa9717e79f3a93c95870367934a06a5f
+  metadata.gz: a4deece72e6d02478b4381a59ab9b1988a2fbff6a30e811596183240699fd018
+  data.tar.gz: ac83f077c9b56423cd8b8e716d8102bec73050c8a4ae0e525fda931f43ec6762
 SHA512:
-  metadata.gz: f854ba80b5702b0620feb0c16126e1b9f4b864a332a1e7b50df15fd4f8af16d49b330cdd296e3fa2b795d7c17857ae66d1705fdf4fd68784288317571120a651
-  data.tar.gz: 457b7ac2ef3b81a9f5f8d6353cf73c588c12af06af085fcfe456afa29b48ba96f324dc7cae173362a410c3009ae2394d30ea130e5785bcb24741378b79a0f851
+  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

@@ -26,58 +26,46 @@ def cppflags_add_cpu_extension!
 end
 
 def libv8_gem_name
-  #return "libv8-solaris" if IS_SOLARIS
-  #return "libv8-alpine" if IS_LINUX_MUSL
+  return "libv8-solaris" if IS_SOLARIS
+  return "libv8-alpine" if IS_LINUX_MUSL
 
-  'libv8-node'
+  'libv8'
 end
 
-def libv8_requirement
-  '~> 10.22.1.0.beta1'
+def libv8_version
+  '7.3.492.27.1'
 end
 
-def libv8_basename(version)
-  "#{libv8_gem_name}-#{version}-#{ruby_platform}"
+def libv8_basename
+  "#{libv8_gem_name}-#{libv8_version}-#{ruby_platform}"
 end
 
-def libv8_gemspec(version)
-  "#{libv8_basename(version)}.gemspec"
+def libv8_gemspec
+  "#{libv8_basename}.gemspec"
 end
 
-def libv8_local_path(path=Gem.path)
-  name_glob = "#{libv8_gem_name}-*-#{ruby_platform}"
+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
 
-  puts "looking for #{name_glob} in #{path.inspect}"
-
-  paths = path.map { |p| Dir.glob(File.join(p, 'specifications', name_glob + '.gemspec')) }.flatten
-
-  if paths.empty?
-    puts "#{name_glob} not found in #{path.inspect}"
-    return
-  end
-
-  specs = paths.map { |p| [p, eval(File.read(p))] }
-               .select { |_, spec| Gem::Requirement.new(libv8_requirement).satisfied_by?(spec.version) }
-  found_path, found_spec = specs.sort_by { |_, spec| spec.version }.last
-
-  unless found_path && found_spec
-    puts "not found in specs: no '#{libv8_requirement}' in #{paths.inspect}"
+  unless found
+    puts "#{libv8_gemspec} not found in installed gems"
     return
   end
 
-  puts "found in specs: #{found_path}"
+  puts "found in installed specs: #{found}"
 
-  gemdir = File.basename(found_path, '.gemspec')
-  dir = File.expand_path(File.join(found_path, '..', '..', 'gems', gemdir))
+  dir = File.expand_path(File.join(found, '..', '..', 'gems', libv8_basename))
 
   unless Dir.exist?(dir)
-    puts "not found in gems: #{dir}"
+    puts "not found in installed gems: #{dir}"
     return
   end
 
-  puts "found in gems: #{dir}"
+  puts "found in installed gems: #{dir}"
 
-  [dir, found_spec]
+  dir
 end
 
 def vendor_path
@@ -85,14 +73,25 @@ def vendor_path
 end
 
 def libv8_vendor_path
-  libv8_local_path([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 do |p|
-    p.instance_eval { @version = 'musl' } if str =~ /-musl/ && p.version.nil?
-    p.instance_eval { @cpu = 'x86_64' } if str =~ /universal.*darwin/
-  end
+  Gem::Platform.new(str).tap { |p| p.instance_eval { @os = 'linux-musl' } if str =~ /musl/ }
 end
 
 def ruby_platform
@@ -114,23 +113,21 @@ def libv8_remote_search
   json = JSON.parse(body)
 
   versions = json.select do |v|
-    Gem::Requirement.new(libv8_requirement).satisfied_by?(Gem::Version.new(v['number']))
+    Gem::Version.new(v['number']) == Gem::Version.new(libv8_version)
   end
   abort(<<-ERROR) if versions.empty?
-  ERROR: could not find #{libv8_gem_name} (requirement #{libv8_requirement}) in rubygems.org
+  ERROR: could not find #{libv8_version}
   ERROR
 
   platform_versions = versions.select do |v|
-    parse_platform(v['platform']) == ruby_platform unless v['platform'] =~ /universal.*darwin/
+    parse_platform(v['platform']) == ruby_platform
   end
   abort(<<-ERROR) if platform_versions.empty?
-  ERROR: found gems matching #{libv8_gem_name}:'#{libv8_requirement}', but no binary for #{ruby_platform}
-         try "gem install #{libv8_gem_name}:'#{libv8_requirement}'" to attempt to build #{libv8_gem_name} from source
+  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
 
-  puts "found #{libv8_gem_name} for #{ruby_platform} on rubygems: #{platform_versions.map { |v| v['number'] }.join(', ')}"
-
-  platform_versions.sort_by { |v| Gem::Version.new(v['number']) }.last
+  platform_versions.first
 end
 
 def libv8_download_uri(name, version, platform)
@@ -142,47 +139,27 @@ def libv8_downloaded_gem(name, version, platform)
 end
 
 def libv8_download(name, version, platform)
-  FileUtils.mkdir_p(File.join(vendor_path, 'cache'))
+  FileUtils.mkdir_p(vendor_path)
   body = http_get(libv8_download_uri(name, version, platform))
-  File.open(File.join(vendor_path, 'cache', libv8_downloaded_gem(name, version, platform)), 'wb') { |f| f.write(body) }
-end
-
-def libv8_install!
-  cmd = "gem install #{libv8_gem_name} --version '#{libv8_requirement}' --install-dir '#{vendor_path}'"
-  puts "installing #{libv8_gem_name} using `#{cmd}`"
-  rc = system(cmd)
-
-  abort(<<-ERROR) unless rc
-  ERROR: could not install #{libv8_gem_name}:#{libv8_requirement}
-          try "gem install #{libv8_gem_name} -v '#{libv8_requirement}'" to attempt to build libv8 from source
-  ERROR
-
-  libv8_local_path([vendor_path])
+  File.open(File.join(vendor_path, libv8_downloaded_gem(name, version, platform)), 'wb') { |f| f.write(body) }
 end
 
 def libv8_vendor!
-  return libv8_install! if Gem::VERSION < '2.0'
-
   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, 'cache', libv8_downloaded_gem(libv8_gem_name, version['number'], version['platform'])))
-  package.extract_files(File.join(vendor_path, 'gems', File.basename(libv8_downloaded_gem(libv8_gem_name, version['number'], version['platform']), '.gem')))
-  FileUtils.mkdir_p(File.join(vendor_path, 'specifications'))
-  File.open(File.join(vendor_path, 'specifications', File.basename(libv8_downloaded_gem(libv8_gem_name, version['number'], version['platform']), '.gem') + '.gemspec'), 'wb') { |f| f.write(package.spec.to_ruby) }
+  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 "platform ruby:#{RUBY_PLATFORM} rubygems:#{Gem::Platform.new(RUBY_PLATFORM)} detected:#{ruby_platform}"
+  puts "detected platform #{RUBY_PLATFORM} => #{ruby_platform}"
 
-  libv8_path, spec = libv8_local_path
-  if !ENV['ONLY_INSTALLED_LIBV8_GEM'] && !libv8_path
-    libv8_path, spec = libv8_vendor_path || libv8_vendor!
-  end
+  libv8_path = libv8_local_path || libv8_vendor_path || libv8_vendor!
 
   abort(<<-ERROR) unless libv8_path
   ERROR: could not find #{libv8_gem_name}
@@ -194,7 +171,7 @@ end
 
 ensure_libv8_load_path
 
-require 'libv8-node'
+require 'libv8'
 
 IS_DARWIN = RUBY_PLATFORM =~ /darwin/
 
@@ -213,8 +190,6 @@ cppflags_add_cpu_extension!
 $CPPFLAGS += " -Wno-reserved-user-defined-literal" if IS_DARWIN
 
 $LDFLAGS.insert(0, " -stdlib=libc++ ") if IS_DARWIN
-$LDFLAGS += " -Wl,--no-undefined " unless IS_DARWIN
-$LDFLAGS += " -Wl,-undefined,error " if IS_DARWIN
 
 if ENV['CXX']
   puts "SETTING CXX"
@@ -253,7 +228,7 @@ if enable_config('debug') || enable_config('asan')
   CONFIG['debugflags'] << ' -ggdb3 -O0'
 end
 
-Libv8::Node.configure_makefile
+Libv8.configure_makefile
 
 if enable_config('asan')
   $CPPFLAGS.insert(0, " -fsanitize=address ")

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.0.2"
+  VERSION = "0.2.5.0.1.beta1"
 end
 end

data/mini_racer.gemspec

@@ -15,12 +15,13 @@ 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) }
   spec.require_paths = ["lib"]
 
+  spec.add_development_dependency "bundler", "~> 1.12"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "minitest", "~> 5.0"
   spec.add_development_dependency "rake-compiler"

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: sq_mini_racer
 version: !ruby/object:Gem::Version
-  version: 0.2.4.0.2
+  version: 0.2.5.0.1.beta1
 platform: ruby
 authors:
 - Sam Saffron
-autorequire:
+autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-12-16 00:00:00.000000000 Z
+date: 2019-08-26 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -61,18 +75,14 @@ extensions:
 - ext/prv_ext_loader/extconf.rb
 extra_rdoc_files: []
 files:
-- ".dockerignore"
 - ".gitignore"
 - ".travis.yml"
 - CHANGELOG
 - CODE_OF_CONDUCT.md
-- Dockerfile
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
-- azure-pipelines.yml
-- azure-template.yml
 - bin/console
 - bin/setup
 - ext/mini_racer_extension/compat.hpp
@@ -88,7 +98,7 @@ homepage: https://github.com/sqreen/mini_racer
 licenses:
 - MIT
 metadata: {}
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -100,12 +110,13 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 1.9.3
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
-rubygems_version: 3.1.3
-signing_key:
+rubyforge_project: 
+rubygems_version: 2.7.7
+signing_key: 
 specification_version: 4
 summary: Minimal embedded v8 for Ruby
 test_files: []

data/.dockerignore

@@ -1,12 +0,0 @@
-/.bundle/
-/.yardoc
-Gemfile.lock
-/_yardoc/
-/coverage/
-/doc/
-/pkg/
-/spec/reports/
-/tmp/
-lib/sq_mini_racer_extension.so
-lib/sq_mini_racer_loader.so
-*.bundle

data/Dockerfile

@@ -1,22 +0,0 @@
-ARG RUBY_VERSION=2.7
-FROM ruby:${RUBY_VERSION}
-
-RUN test ! -f /etc/alpine-release || apk add --no-cache build-base git
-
-# without this `COPY .git`, we get the following error:
-#   fatal: not a git repository (or any of the parent directories): .git
-# but with it we need the full gem just to compile the extension because
-# of gemspec's `git --ls-files`
-# COPY .git /code/.git
-
-COPY Gemfile mini_racer.gemspec /code/
-COPY lib/sqreen/mini_racer/version.rb /code/lib/sqreen/mini_racer/version.rb
-WORKDIR /code
-RUN bundle install
-
-COPY Rakefile /code/
-COPY ext /code/ext/
-RUN bundle exec rake compile
-
-COPY . /code/
-CMD bundle exec irb -rmini_racer

data/azure-pipelines.yml

@@ -1,69 +0,0 @@
-jobs:
-  - template: azure-template.yml
-    parameters:
-      name: linux_2_0
-      displayName: Linux Ruby 2.0
-      rubyVersion: '2.0'
-      publishCoverage: true
-
-  - template: azure-template.yml
-    parameters:
-      name: linux_2_1
-      displayName: Linux Ruby 2.1
-      rubyVersion: '2.1'
-
-  - template: azure-template.yml
-    parameters:
-      name: linux_2_2
-      displayName: Linux Ruby 2.2
-      rubyVersion: '2.2'
-
-  - template: azure-template.yml
-    parameters:
-      name: linux_2_3
-      displayName: Linux Ruby 2.3
-      rubyVersion: '2.3'
-
-  - template: azure-template.yml
-    parameters:
-      name: linux_2_4
-      displayName: Linux Ruby 2.4
-      rubyVersion: '2.4'
-
-  - template: azure-template.yml
-    parameters:
-      name: linux_2_5
-      displayName: Linux Ruby 2.5
-      rubyVersion: '2.5'
-
-  - template: azure-template.yml
-    parameters:
-      name: linux_2_6
-      displayName: Linux Ruby 2.6
-      rubyVersion: '2.6'
-
-  - template: azure-template.yml
-    parameters:
-      name: linux_2_7
-      displayName: Linux Ruby 2.7
-      rubyVersion: '2.7'
-
-  - template: azure-template.yml
-    parameters:
-      name: linux_2_7_mini_racer
-      displayName: Linux Ruby 2.7 (with mini_racer)
-      rubyVersion: '2.7'
-      with_mini_racer: true
-
-  - template: azure-template.yml
-    parameters:
-      name: linux_2_7_therubyracer
-      displayName: Linux Ruby 2.7 (with therubyracer)
-      rubyVersion: '2.7'
-      with_therubyracer: true
-
-  - template: azure-template.yml
-    parameters:
-      name: macos_10_15
-      displayName: MacOS 10.15
-      imageName: 'macos-10.15'

data/azure-template.yml

@@ -1,92 +0,0 @@
-parameters:
-  name: ~
-  displayName: ~
-  rubyVersion: bundled
-  imageName: ubuntu-18.04
-  publishCoverage: false
-  with_mini_racer: false
-  with_therubyracer: false
-
-jobs:
-  - job: ${{ parameters.name }}
-    displayName: ${{ parameters.displayName }}
-    pool:
-      vmImage: ${{ parameters.imageName }}
-
-    variables:
-      TESTOPTS: -v
-      ${{ if eq(parameters.publishCoverage, true) }}:
-        CPPFLAGS: --coverage
-        LDFLAGS: --coverage
-      ${{ if eq(parameters.rubyVersion, 'bundled') }}:
-        gem: gem
-        bundle: bundle
-      ${{ if ne(parameters.rubyVersion, 'bundled') }}:
-        gem: /opt/ruby/${{ parameters.rubyVersion }}/bin/gem
-        bundle: /opt/ruby/${{ parameters.rubyVersion }}/bin/bundle
-        GEM_HOME: /opt/ruby/${{ parameters.rubyVersion }}/lib/ruby/gems/${{ parameters.rubyVersion }}.0
-
-    steps:
-      - checkout: self
-        displayName: Checkout
-        clean: true
-        submodules: recursive
-
-      - ${{ if ne(parameters.rubyVersion, 'bundled') }}:
-        - script: |
-            sudo apt-get install -y gnupg
-            sudo apt-key adv --keyserver keyserver.ubuntu.com --recv 5D98E7264E3F3D89463B314B12229434A9F003C9
-            echo deb [arch=amd64] http://sqreen-download-private.s3.amazonaws.com/deb bionic main | sudo tee -a /etc/apt/sources.list
-            sudo apt-get update
-            sudo apt-get install -y sq-ruby${{ parameters.rubyVersion }} ruby-
-          displayName: Install Ruby
-
-      - ${{ if eq(parameters.rubyVersion, 'bundled') }}:
-        - script: sudo $(gem) install bundler --version '< 2.0' --no-document
-          displayName: Install bundler
-
-      - ${{ if eq(parameters.imageName, 'ubuntu-18.04') }}:
-        - script: |
-            sudo apt-get install -y build-essential git curl valgrind g++ make
-          displayName: Install Linux packages
-
-      - script: $(bundle) install --path vendor/bundle
-        displayName: Install gem dependencies
-        env:
-          ${{ if eq(parameters.with_mini_racer, true) }}:
-            LOAD_MINI_RACER: 1
-          ${{ if eq(parameters.with_therubyracer, true) }}:
-            LOAD_THERUBYRACER: 1
-
-      - script: PATH=`dirname $(bundle)`:$PATH CPPFLAGS=$(CPPFLAGS) LDFLAGS=$(LDFLAGS) $(bundle) exec rake compile
-        displayName: Compile extension
-
-      - script: |
-          find . -name '*.log' -exec cat '{}' \;
-        displayName: Print logs
-        condition: failed()
-
-      - script: $(bundle) exec rake test
-        displayName: Run tests
-        env:
-          ${{ if eq(parameters.with_mini_racer, true) }}:
-            LOAD_MINI_RACER: 1
-          ${{ if eq(parameters.with_therubyracer, true) }}:
-            LOAD_THERUBYRACER: 1
-
-      - ${{ if and(eq(parameters.imageName, 'ubuntu-18.04'), eq(parameters.with_mini_racer, false), eq(parameters.with_therubyracer, false)) }}:
-        - script: $(bundle) exec rake test:valgrind
-          displayName: Run tests w/ valgrind
-
-      - script: |
-          PATH=$PATH:$(dirname $(which $(gem)))
-          $(bundle) exec rake build
-          sudo PATH=$PATH $(gem) install pkg/*.gem
-        displayName: Check that the gem is installable
-
-      - ${{ if eq(parameters.publishCoverage, true) }}:
-          - bash: >
-              test -z "$CODECOV_TOKEN" || bash <(curl -s https://codecov.io/bash)
-            displayName: "Publish coverage (Codecov)"
-            env:
-              CODECOV_TOKEN: $(CODECOV_TOKEN)