ruby_box 0.0.0.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 24712c9c81020b44d9311a1cb883279c29d2cbd2
-  data.tar.gz: a5bdfa62602acb7c577cd4c8f4248ac010fd6f1d
+  metadata.gz: ad18cf425468583ca9d68b028decf40c0cab4c8d
+  data.tar.gz: a396ac061daca869cc7614703ab9446a2fd2ab6e
 SHA512:
-  metadata.gz: 2c08690552b840b62dc8566d827b2cc218fbb7e4c38803fc3eade15fae4b5d37f08d2eba6bdf421c0ca6f2a4ea57c80ec67091ffcfe2e4d61974817087b479d6
-  data.tar.gz: 743bf09d576224b268caebdd9dc95dd2d54acf2df7fa35c247d746cc1d46cc7960a591ef56351b43af41946b1d2e11e12b7c2357b89fc77409301f8eed76d120
+  metadata.gz: 276d89862d95255ef094c8f906c154be97ff20e1d31d7139ea3f183f5a79eca6bec87a05ca06daa5321996c5a9ae5493347b5106cc13870373520088987fa02d
+  data.tar.gz: e8959d5af99de60849293ec31e7ecfee684006f22a6856f849f06f89b4cd0a90ca52fb5bc9e975372e01f22ce2bc317ed4b74f5b96fd54136510f3c0a23057cc

data/lib/ruby_box/bridging.rb

@@ -42,7 +42,7 @@ module RubyBox
           handle = "Opal.RubyBox.CurrentBoxProxy.__exposed_method_#{method_name}"
 
           wrapper = ->(serialized_args) do
-            args = JSON.parse(serialized_args)
+            args = JSON.parse(serialized_args, quirks_mode: true)
             value = send(method_name, *args)
             value.to_json
           end

data/lib/ruby_box/version.rb

@@ -1,3 +1,3 @@
 module RubyBox
-  VERSION = '0.0.0.1'
+  VERSION = '1.0.0'
 end

metadata

@@ -1,43 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: ruby_box
 version: !ruby/object:Gem::Version
-  version: 0.0.0.1
+  version: 1.0.0
 platform: ruby
 authors:
 - Alec Larsen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-09-26 00:00:00.000000000 Z
+date: 2017-03-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: libv8
+  name: mini_racer
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.1'
+        version: '0.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.1'
-- !ruby/object:Gem::Dependency
-  name: rake-compiler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.1'
 - !ruby/object:Gem::Dependency
   name: opal
   requirement: !ruby/object:Gem::Requirement
@@ -70,16 +56,16 @@ dependencies:
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.10'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.10'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -154,8 +140,7 @@ description:
 email:
 - aleclarsen42@gmail.com
 executables: []
-extensions:
-- vendor/gems/mini_racer/ext/mini_racer_extension/extconf.rb
+extensions: []
 extra_rdoc_files: []
 files:
 - lib/ruby_box.rb
@@ -171,11 +156,6 @@ files:
 - lib/ruby_box/thread_safety.rb
 - lib/ruby_box/timeout_error.rb
 - lib/ruby_box/version.rb
-- vendor/gems/mini_racer/ext/mini_racer_extension/extconf.rb
-- vendor/gems/mini_racer/ext/mini_racer_extension/mini_racer_extension.cc
-- vendor/gems/mini_racer/lib/mini_racer.rb
-- vendor/gems/mini_racer/lib/mini_racer/version.rb
-- vendor/gems/mini_racer/lib/mini_racer_extension.bundle
 homepage: https://github.com/anarchocurious/ruby_box
 licenses:
 - MIT
@@ -184,8 +164,6 @@ post_install_message:
 rdoc_options: []
 require_paths:
 - lib
-- vendor/gems/mini_racer/lib
-- vendor/gems/mini_racer/ext
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -198,9 +176,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.6
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: RubyBox allows the execution of untrusted Ruby code safely in a sandbox.
 test_files: []
-has_rdoc: 

data/vendor/gems/mini_racer/ext/mini_racer_extension/extconf.rb

@@ -1,54 +0,0 @@
-require 'mkmf'
-require 'libv8'
-
-have_library('pthread')
-have_library('objc') if RUBY_PLATFORM =~ /darwin/
-$CPPFLAGS += " -Wall" unless $CPPFLAGS.split.include? "-Wall"
-$CPPFLAGS += " -g" unless $CPPFLAGS.split.include? "-g"
-$CPPFLAGS += " -rdynamic" unless $CPPFLAGS.split.include? "-rdynamic"
-$CPPFLAGS += " -fPIC" unless $CPPFLAGS.split.include? "-rdynamic" or RUBY_PLATFORM =~ /darwin/
-$CPPFLAGS += " -std=c++0x"
-$CPPFLAGS += " -fpermissive"
-
-$LDFLAGS.insert 0, " -stdlib=libstdc++ " if RUBY_PLATFORM =~ /darwin/
-
-if ENV['CXX']
-  puts "SETTING CXX"
-  CONFIG['CXX'] = ENV['CXX']
-end
-
-CXX11_TEST = <<EOS
-#if __cplusplus <= 199711L
-#   error A compiler that supports at least C++11 is required in order to compile this project.
-#endif
-EOS
-
-`echo "#{CXX11_TEST}" | #{CONFIG['CXX']} -std=c++0x -x c++ -E -`
-unless $?.success?
-  warn <<EOS
-
-
-WARNING: C++11 support is required for compiling mini_racer. Please make sure
-you are using a compiler that supports at least C++11. Examples of such
-compilers are GCC 4.7+ and Clang 3.2+.
-
-If you are using Travis, consider either migrating your bulid to Ubuntu Trusty or
-installing GCC 4.8. See mini_racer's README.md for more information.
-
-
-EOS
-end
-
-CONFIG['LDSHARED'] = '$(CXX) -shared' unless RUBY_PLATFORM =~ /darwin/
-if CONFIG['warnflags']
-  CONFIG['warnflags'].gsub!('-Wdeclaration-after-statement', '')
-  CONFIG['warnflags'].gsub!('-Wimplicit-function-declaration', '')
-end
-
-if enable_config('debug')
-  CONFIG['debugflags'] << ' -ggdb3 -O0'
-end
-
-Libv8.configure_makefile
-
-create_makefile 'mini_racer_extension'

data/vendor/gems/mini_racer/ext/mini_racer_extension/mini_racer_extension.cc

@@ -1,910 +0,0 @@
-#include <stdio.h>
-#include <ruby.h>
-#include <ruby/thread.h>
-#include <v8.h>
-#include <libplatform/libplatform.h>
-#include <ruby/encoding.h>
-#include <pthread.h>
-#include <unistd.h>
-#include <mutex>
-
-using namespace v8;
-
-class ArrayBufferAllocator : public v8::ArrayBuffer::Allocator {
- public:
-  virtual void* Allocate(size_t length) {
-    void* data = AllocateUninitialized(length);
-    return data == NULL ? data : memset(data, 0, length);
-  }
-  virtual void* AllocateUninitialized(size_t length) { return malloc(length); }
-  virtual void Free(void* data, size_t) { free(data); }
-};
-
-typedef struct {
-    const char* data;
-    int raw_size;
-} SnapshotInfo;
-
-typedef struct {
-    Isolate* isolate;
-    ArrayBufferAllocator* allocator;
-    StartupData* startup_data;
-    bool interrupted;
-
-    // how many references to this isolate exist
-    // we can't rely on Ruby's GC for this, because when destroying
-    // objects, Ruby will destroy ruby objects first, then call the
-    // extenstion's deallocators. In this case, that means it would
-    // call `deallocate_isolate` _before_ `deallocate`, causing a segfault
-    int refs_count;
-} IsolateInfo;
-
-typedef struct {
-    IsolateInfo* isolate_info;
-    Persistent<Context>* context;
-} ContextInfo;
-
-typedef struct {
-    bool parsed;
-    bool executed;
-    bool terminated;
-    Persistent<Value>* value;
-    Persistent<Value>* message;
-    Persistent<Value>* backtrace;
-} EvalResult;
-
-typedef struct {
-    ContextInfo* context_info;
-    Local<String>* eval;
-    useconds_t timeout;
-    EvalResult* result;
-} EvalParams;
-
-static VALUE rb_eScriptTerminatedError;
-static VALUE rb_eParseError;
-static VALUE rb_eScriptRuntimeError;
-static VALUE rb_cJavaScriptFunction;
-static VALUE rb_eSnapshotError;
-static VALUE rb_ePlatformAlreadyInitializedError;
-
-static VALUE rb_cFailedV8Conversion;
-static VALUE rb_cDateTime = Qnil;
-
-static Platform* current_platform = NULL;
-static std::mutex platform_lock;
-
-static VALUE rb_platform_set_flag_as_str(VALUE _klass, VALUE flag_as_str) {
-    bool platform_already_initialized = false;
-
-    platform_lock.lock();
-
-    if (current_platform == NULL) {
-        V8::SetFlagsFromString(RSTRING_PTR(flag_as_str), (int)RSTRING_LEN(flag_as_str));
-    } else {
-        platform_already_initialized = true;
-    }
-
-    platform_lock.unlock();
-
-    // important to raise outside of the lock
-    if (platform_already_initialized) {
-        rb_raise(rb_ePlatformAlreadyInitializedError, "The V8 platform is already initialized");
-    }
-
-    return Qnil;
-}
-
-static void init_v8() {
-    // no need to wait for the lock if already initialized
-    if (current_platform != NULL) return;
-
-    platform_lock.lock();
-
-    if (current_platform == NULL) {
-        V8::InitializeICU();
-        current_platform = platform::CreateDefaultPlatform();
-        V8::InitializePlatform(current_platform);
-        V8::Initialize();
-    }
-
-    platform_lock.unlock();
-}
-
-void*
-nogvl_context_eval(void* arg) {
-
-    EvalParams* eval_params = (EvalParams*)arg;
-    EvalResult* result = eval_params->result;
-    Isolate* isolate = eval_params->context_info->isolate_info->isolate;
-    Isolate::Scope isolate_scope(isolate);
-    HandleScope handle_scope(isolate);
-
-    TryCatch trycatch(isolate);
-
-    Local<Context> context = eval_params->context_info->context->Get(isolate);
-    Context::Scope context_scope(context);
-
-    // in gvl flag
-    isolate->SetData(0, (void*)false);
-    // terminate ASAP
-    isolate->SetData(1, (void*)false);
-
-    MaybeLocal<Script> parsed_script = Script::Compile(context, *eval_params->eval);
-    result->parsed = !parsed_script.IsEmpty();
-    result->executed = false;
-    result->terminated = false;
-    result->value = NULL;
-
-    if (!result->parsed) {
-	result->message = new Persistent<Value>();
-	result->message->Reset(isolate, trycatch.Exception());
-    } else {
-
-	MaybeLocal<Value> maybe_value = parsed_script.ToLocalChecked()->Run(context);
-
-	result->executed = !maybe_value.IsEmpty();
-
-	if (result->executed) {
-	    Persistent<Value>* persistent = new Persistent<Value>();
-	    persistent->Reset(isolate, maybe_value.ToLocalChecked());
-	    result->value = persistent;
-	}
-    }
-
-    if (!result->executed || !result->parsed) {
-	if (trycatch.HasCaught()) {
-	    if (!trycatch.Exception()->IsNull()) {
-		result->message = new Persistent<Value>();
-		Local<Message> message = trycatch.Message();
-		char buf[1000];
-		int len;
-		len = snprintf(buf, sizeof(buf), "%s at %s:%i:%i", *String::Utf8Value(message->Get()),
-			           *String::Utf8Value(message->GetScriptResourceName()->ToString()),
-				    message->GetLineNumber(),
-				    message->GetStartColumn());
-
-		Local<String> v8_message = String::NewFromUtf8(isolate, buf, NewStringType::kNormal, (int)len).ToLocalChecked();
-		result->message->Reset(isolate, v8_message);
-	    } else if(trycatch.HasTerminated()) {
-
-
-		result->terminated = true;
-		result->message = new Persistent<Value>();
-		Local<String> tmp = String::NewFromUtf8(isolate, "JavaScript was terminated (either by timeout or explicitly)");
-		result->message->Reset(isolate, tmp);
-	    }
-	    if (!trycatch.StackTrace().IsEmpty()) {
-		result->backtrace = new Persistent<Value>();
-		result->backtrace->Reset(isolate, trycatch.StackTrace()->ToString());
-	    }
-	}
-    }
-
-    isolate->SetData(0, (void*)true);
-
-
-    return NULL;
-}
-
-static VALUE convert_v8_to_ruby(Isolate* isolate, Handle<Value> &value) {
-
-    HandleScope scope(isolate);
-
-    if (value->IsNull() || value->IsUndefined()){
-	return Qnil;
-    }
-
-    if (value->IsInt32()) {
-     return INT2FIX(value->Int32Value());
-    }
-
-    if (value->IsNumber()) {
-      return rb_float_new(value->NumberValue());
-    }
-
-    if (value->IsTrue()) {
-      return Qtrue;
-    }
-
-    if (value->IsFalse()) {
-      return Qfalse;
-    }
-
-    if (value->IsArray()) {
-      VALUE rb_array = rb_ary_new();
-      Local<Array> arr = Local<Array>::Cast(value);
-      for(uint32_t i=0; i < arr->Length(); i++) {
-	  Local<Value> element = arr->Get(i);
-	  VALUE rb_elem = convert_v8_to_ruby(isolate, element);
-	  if (rb_funcall(rb_elem, rb_intern("class"), 0) == rb_cFailedV8Conversion) {
-	    return rb_elem;
-	  }
-          rb_ary_push(rb_array, rb_elem);
-      }
-      return rb_array;
-    }
-
-    if (value->IsFunction()){
-	return rb_funcall(rb_cJavaScriptFunction, rb_intern("new"), 0);
-    }
-
-    if (value->IsDate()){
-        double ts = Local<Date>::Cast(value)->ValueOf();
-        double secs = ts/1000;
-        long nanos = round((secs - floor(secs)) * 1000000);
-
-        return rb_time_new(secs, nanos);
-    }
-
-    if (value->IsObject()) {
-
-	TryCatch trycatch(isolate);
-
-	VALUE rb_hash = rb_hash_new();
-	Local<Context> context = Context::New(isolate);
-	Local<Object> object = value->ToObject();
-	MaybeLocal<Array> maybe_props = object->GetOwnPropertyNames(context);
-	if (!maybe_props.IsEmpty()) {
-	    Local<Array> props = maybe_props.ToLocalChecked();
-	    for(uint32_t i=0; i < props->Length(); i++) {
-	     Local<Value> key = props->Get(i);
-	     VALUE rb_key = convert_v8_to_ruby(isolate, key);
-	     Local<Value> value = object->Get(key);
-	     // this may have failed due to Get raising
-
-	     if (trycatch.HasCaught()) {
-		 // TODO isolate code that translates execption to ruby
-		 // exception so we can properly return it
-		 return rb_funcall(rb_cFailedV8Conversion, rb_intern("new"), 1, rb_str_new2(""));
-	     }
-
-	     VALUE rb_value = convert_v8_to_ruby(isolate, value);
-	     rb_hash_aset(rb_hash, rb_key, rb_value);
-	    }
-	}
-	return rb_hash;
-    }
-
-    Local<String> rstr = value->ToString();
-    return rb_enc_str_new(*String::Utf8Value(rstr), rstr->Utf8Length(), rb_enc_find("utf-8"));
-}
-
-static Handle<Value> convert_ruby_to_v8(Isolate* isolate, VALUE value) {
-    EscapableHandleScope scope(isolate);
-
-    Local<Array> array;
-    Local<Object> object;
-    VALUE hash_as_array;
-    VALUE pair;
-    int i;
-    long length;
-    long fixnum;
-    VALUE klass;
-
-    switch (TYPE(value)) {
-    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));
-    case T_FLOAT:
-	return scope.Escape(Number::New(isolate, NUM2DBL(value)));
-    case T_STRING:
-	return scope.Escape(String::NewFromUtf8(isolate, RSTRING_PTR(value), NewStringType::kNormal, (int)RSTRING_LEN(value)).ToLocalChecked());
-    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);
-    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);
-    case T_SYMBOL:
-	value = rb_funcall(value, rb_intern("to_s"), 0);
-	return scope.Escape(String::NewFromUtf8(isolate, RSTRING_PTR(value), NewStringType::kNormal, (int)RSTRING_LEN(value)).ToLocalChecked());
-    case T_DATA:
-        klass = rb_funcall(value, rb_intern("class"), 0);
-        if (klass == rb_cTime || 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));
-        }
-    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:
-      return scope.Escape(String::NewFromUtf8(isolate, "Undefined Conversion"));
-    }
-
-}
-
-static void unblock_eval(void *ptr) {
-    EvalParams* eval = (EvalParams*)ptr;
-    eval->context_info->isolate_info->interrupted = true;
-}
-
-static VALUE rb_snapshot_size(VALUE self, VALUE str) {
-    SnapshotInfo* snapshot_info;
-    Data_Get_Struct(self, SnapshotInfo, snapshot_info);
-
-    return INT2NUM(snapshot_info->raw_size);
-}
-
-static VALUE rb_snapshot_load(VALUE self, VALUE str) {
-    SnapshotInfo* snapshot_info;
-    Data_Get_Struct(self, SnapshotInfo, snapshot_info);
-
-    init_v8();
-
-    StartupData startup_data = V8::CreateSnapshotDataBlob(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");
-    }
-
-    snapshot_info->data = startup_data.data;
-    snapshot_info->raw_size = startup_data.raw_size;
-
-    return Qnil;
-}
-
-static VALUE rb_snapshot_warmup(VALUE self, VALUE str) {
-    SnapshotInfo* snapshot_info;
-    Data_Get_Struct(self, SnapshotInfo, snapshot_info);
-
-    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));
-
-    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");
-    } else {
-        delete[] snapshot_info->data;
-
-        snapshot_info->data = warm_startup_data.data;
-        snapshot_info->raw_size = warm_startup_data.raw_size;
-    }
-
-    return self;
-}
-
-static VALUE rb_isolate_init_with_snapshot(VALUE self, VALUE snapshot) {
-    IsolateInfo* isolate_info;
-    Data_Get_Struct(self, IsolateInfo, isolate_info);
-
-    init_v8();
-
-    isolate_info->allocator = new ArrayBufferAllocator();
-    isolate_info->interrupted = false;
-    isolate_info->refs_count = 1;
-
-    Isolate::CreateParams create_params;
-    create_params.array_buffer_allocator = isolate_info->allocator;
-
-    StartupData* startup_data = NULL;
-    if (!NIL_P(snapshot)) {
-        SnapshotInfo* snapshot_info;
-        Data_Get_Struct(snapshot, SnapshotInfo, snapshot_info);
-
-        int raw_size = snapshot_info->raw_size;
-        char* data = new char[raw_size];
-        memcpy(data, snapshot_info->data, sizeof(char) * raw_size);
-
-        startup_data = new StartupData;
-        startup_data->data = data;
-        startup_data->raw_size = raw_size;
-
-        create_params.snapshot_blob = startup_data;
-    }
-
-    isolate_info->startup_data = startup_data;
-    isolate_info->isolate = Isolate::New(create_params);
-
-    return Qnil;
-}
-
-static VALUE rb_isolate_idle_notification(VALUE self, VALUE idle_time_in_ms) {
-    IsolateInfo* isolate_info;
-    Data_Get_Struct(self, IsolateInfo, isolate_info);
-
-    return isolate_info->isolate->IdleNotification(NUM2INT(idle_time_in_ms)) ? Qtrue : Qfalse;
-}
-
-static VALUE rb_context_init_with_isolate(VALUE self, VALUE isolate) {
-    ContextInfo* context_info;
-    Data_Get_Struct(self, ContextInfo, context_info);
-
-    init_v8();
-
-    IsolateInfo* isolate_info;
-    Data_Get_Struct(isolate, IsolateInfo, isolate_info);
-
-    context_info->isolate_info = isolate_info;
-    isolate_info->refs_count++;
-
-    {
-    Locker lock(isolate_info->isolate);
-    Isolate::Scope isolate_scope(isolate_info->isolate);
-    HandleScope handle_scope(isolate_info->isolate);
-
-    Local<Context> context = Context::New(isolate_info->isolate);
-
-    context_info->context = new Persistent<Context>();
-    context_info->context->Reset(isolate_info->isolate, context);
-    }
-
-    if (Qnil == rb_cDateTime && rb_funcall(rb_cObject, rb_intern("const_defined?"), 1, rb_str_new2("DateTime")) == Qtrue)
-    {
-        rb_cDateTime = rb_const_get(rb_cObject, rb_intern("DateTime"));
-    }
-
-    return Qnil;
-}
-
-static VALUE rb_context_eval_unsafe(VALUE self, VALUE str) {
-
-    EvalParams eval_params;
-    EvalResult eval_result;
-    ContextInfo* context_info;
-    VALUE result;
-
-    VALUE message = Qnil;
-    VALUE backtrace = Qnil;
-
-    Data_Get_Struct(self, ContextInfo, context_info);
-    Isolate* isolate = context_info->isolate_info->isolate;
-
-
-
-    {
-	Locker lock(isolate);
-	Isolate::Scope isolate_scope(isolate);
-	HandleScope handle_scope(isolate);
-
-	Local<String> eval = String::NewFromUtf8(isolate, RSTRING_PTR(str),
-						  NewStringType::kNormal, (int)RSTRING_LEN(str)).ToLocalChecked();
-
-	eval_params.context_info = context_info;
-	eval_params.eval = &eval;
-	eval_params.result = &eval_result;
-	eval_params.timeout = 0;
-	VALUE timeout = rb_iv_get(self, "@timeout");
-	if (timeout != Qnil) {
-	    eval_params.timeout = (useconds_t)NUM2LONG(timeout);
-	}
-
-	eval_result.message = NULL;
-	eval_result.backtrace = NULL;
-
-	rb_thread_call_without_gvl(nogvl_context_eval, &eval_params, unblock_eval, &eval_params);
-
-	if (eval_result.message != NULL) {
-	    Local<Value> tmp = Local<Value>::New(isolate, *eval_result.message);
-	    message = convert_v8_to_ruby(isolate, tmp);
-	    eval_result.message->Reset();
-	    delete eval_result.message;
-	}
-
-	if (eval_result.backtrace != NULL) {
-	    Local<Value> tmp = Local<Value>::New(isolate, *eval_result.backtrace);
-	    backtrace = convert_v8_to_ruby(isolate, tmp);
-	    eval_result.backtrace->Reset();
-	    delete eval_result.backtrace;
-	}
-    }
-
-    // NOTE: this is very important, we can not do an rb_raise from within
-    // a v8 scope, if we do the scope is never cleaned up properly and we leak
-    if (!eval_result.parsed) {
-	if(TYPE(message) == T_STRING) {
-	    rb_raise(rb_eParseError, "%s", RSTRING_PTR(message));
-	} else {
-	    rb_raise(rb_eParseError, "Unknown JavaScript Error during parse");
-	}
-    }
-
-    if (!eval_result.executed) {
-	VALUE ruby_exception = rb_iv_get(self, "@current_exception");
-	if (ruby_exception == Qnil) {
-	    ruby_exception = eval_result.terminated ? rb_eScriptTerminatedError : rb_eScriptRuntimeError;
-	    // exception report about what happened
-	    if(TYPE(backtrace) == T_STRING) {
-		rb_raise(ruby_exception, "%s", RSTRING_PTR(backtrace));
-	    } else if(TYPE(message) == T_STRING) {
-		rb_raise(ruby_exception, "%s", RSTRING_PTR(message));
-	    } else {
-		rb_raise(ruby_exception, "Unknown JavaScript Error during execution");
-	    }
-	} else {
-            VALUE rb_str = rb_funcall(ruby_exception, rb_intern("to_s"), 0);
-	    rb_raise(CLASS_OF(ruby_exception), "%s", RSTRING_PTR(rb_str));
-	}
-    }
-
-    // New scope for return value, must release GVL which
-    {
-	Locker lock(isolate);
-	Isolate::Scope isolate_scope(isolate);
-	HandleScope handle_scope(isolate);
-
-	Local<Value> tmp = Local<Value>::New(isolate, *eval_result.value);
-	result = convert_v8_to_ruby(isolate, tmp);
-
-	eval_result.value->Reset();
-	delete eval_result.value;
-    }
-
-    if (rb_funcall(result, rb_intern("class"), 0) == rb_cFailedV8Conversion) {
-	// TODO try to recover stack trace from the conversion error
-	rb_raise(rb_eScriptRuntimeError, "Error converting JS object to Ruby object");
-    }
-
-
-    return result;
-}
-
-typedef struct {
-    VALUE callback;
-    int length;
-    VALUE* args;
-    bool failed;
-} protected_callback_data;
-
-static
-VALUE protected_callback(VALUE rdata) {
-    protected_callback_data* data = (protected_callback_data*)rdata;
-    VALUE result;
-
-    if (data->length > 0) {
-	result = rb_funcall2(data->callback, rb_intern("call"), data->length, data->args);
-    } else {
-	result = rb_funcall(data->callback, rb_intern("call"), 0);
-    }
-    return result;
-}
-
-static
-VALUE rescue_callback(VALUE rdata, VALUE exception) {
-    protected_callback_data* data = (protected_callback_data*)rdata;
-    data->failed = true;
-    return exception;
-}
-
-void*
-gvl_ruby_callback(void* data) {
-
-    FunctionCallbackInfo<Value>* args = (FunctionCallbackInfo<Value>*)data;
-    VALUE* ruby_args = NULL;
-    int length = args->Length();
-    VALUE callback;
-    VALUE result;
-    VALUE self;
-
-    {
-	HandleScope scope(args->GetIsolate());
-	Handle<External> external = Handle<External>::Cast(args->Data());
-
-	VALUE* self_pointer = (VALUE*)(external->Value());
-	self = *self_pointer;
-	callback = rb_iv_get(self, "@callback");
-
-	if (length > 0) {
-	    ruby_args = ALLOC_N(VALUE, length);
-	}
-
-
-	for (int i = 0; i < length; i++) {
-	    Local<Value> value = ((*args)[i]).As<Value>();
-	    ruby_args[i] = convert_v8_to_ruby(args->GetIsolate(), value);
-	}
-    }
-
-    // may raise exception stay clear of handle scope
-    protected_callback_data callback_data;
-    callback_data.length = length;
-    callback_data.callback = callback;
-    callback_data.args = ruby_args;
-    callback_data.failed = false;
-
-    if ((bool)args->GetIsolate()->GetData(1) == true) {
-	args->GetIsolate()->ThrowException(String::NewFromUtf8(args->GetIsolate(), "Terminated execution during tansition from Ruby to JS"));
-	V8::TerminateExecution(args->GetIsolate());
-	return NULL;
-    }
-
-    result = rb_rescue2((VALUE(*)(...))&protected_callback, (VALUE)(&callback_data),
-			(VALUE(*)(...))&rescue_callback, (VALUE)(&callback_data), rb_eException, (VALUE)0);
-
-    if(callback_data.failed) {
-	VALUE parent = rb_iv_get(self, "@parent");
-	rb_iv_set(parent, "@current_exception", result);
-	args->GetIsolate()->ThrowException(String::NewFromUtf8(args->GetIsolate(), "Ruby exception"));
-    }
-    else {
-	HandleScope scope(args->GetIsolate());
-	Handle<Value> v8_result = convert_ruby_to_v8(args->GetIsolate(), result);
-	args->GetReturnValue().Set(v8_result);
-    }
-
-    if (length > 0) {
-	xfree(ruby_args);
-    }
-
-    if ((bool)args->GetIsolate()->GetData(1) == true) {
-      Isolate* isolate = args->GetIsolate();
-      V8::TerminateExecution(isolate);
-    }
-
-    return NULL;
-}
-
-static void ruby_callback(const FunctionCallbackInfo<Value>& args) {
-
-    bool has_gvl = (bool)args.GetIsolate()->GetData(0);
-
-    if(has_gvl) {
-	gvl_ruby_callback((void*)&args);
-    } else {
-	rb_thread_call_with_gvl(gvl_ruby_callback, (void*)(&args));
-    }
-}
-
-
-static VALUE rb_external_function_notify_v8(VALUE self) {
-
-    ContextInfo* context_info;
-
-    VALUE parent = rb_iv_get(self, "@parent");
-    VALUE name = rb_iv_get(self, "@name");
-    VALUE parent_object = rb_iv_get(self, "@parent_object");
-    VALUE parent_object_eval = rb_iv_get(self, "@parent_object_eval");
-
-    bool parse_error = false;
-    bool attach_error = false;
-
-    Data_Get_Struct(parent, ContextInfo, context_info);
-    Isolate* isolate = context_info->isolate_info->isolate;
-
-    {
-	Locker lock(isolate);
-	Isolate::Scope isolate_scope(isolate);
-	HandleScope handle_scope(isolate);
-
-	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();
-
-	// copy self so we can access from v8 external
-	VALUE* self_copy;
-	Data_Get_Struct(self, VALUE, self_copy);
-	*self_copy = self;
-
-	Local<Value> external = External::New(isolate, self_copy);
-
-	if (parent_object == Qnil) {
-	    context->Global()->Set(v8_str, FunctionTemplate::New(isolate, ruby_callback, external)->GetFunction());
-	} 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);
-		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());
-			attach_error = false;
-		    }
-		}
-	    }
-	}
-    }
-
-    // always raise out of V8 context
-    if (parse_error) {
-	rb_raise(rb_eParseError, "Invalid object %s", RSTRING_PTR(parent_object));
-    }
-
-    if (attach_error) {
-	rb_raise(rb_eParseError, "Was expecting %s to be an object", RSTRING_PTR(parent_object));
-    }
-
-    return Qnil;
-}
-
-void maybe_free_isolate_info(IsolateInfo* isolate_info) {
-    // an isolate can only be freed if no Isolate or Context (ruby) object
-    // still need it
-    if (isolate_info == NULL || isolate_info->refs_count > 0) {
-        return;
-    }
-
-    if (isolate_info->isolate) {
-	    Locker lock(isolate_info->isolate);
-    }
-
-    if (isolate_info->isolate) {
-        if (isolate_info->interrupted) {
-            fprintf(stderr, "WARNING: V8 isolate was interrupted by Ruby, it can not be disposed and memory will not be reclaimed till the Ruby process exits.");
-        } else {
-
-            isolate_info->isolate->Dispose();
-        }
-        isolate_info->isolate = NULL;
-    }
-
-    if (isolate_info->startup_data) {
-        delete[] isolate_info->startup_data->data;
-        delete isolate_info->startup_data;
-    }
-
-    delete isolate_info->allocator;
-    xfree(isolate_info);
-}
-
-void deallocate_isolate(void* data) {
-    IsolateInfo* isolate_info = (IsolateInfo*) data;
-
-    isolate_info->refs_count--;
-
-    maybe_free_isolate_info(isolate_info);
-}
-
-void deallocate(void* data) {
-    ContextInfo* context_info = (ContextInfo*)data;
-    IsolateInfo* isolate_info = context_info->isolate_info;
-
-    if (context_info->context && isolate_info && isolate_info->isolate) {
-        Locker lock(isolate_info->isolate);
-        v8::Isolate::Scope isolate_scope(isolate_info->isolate);
-        context_info->context->Reset();
-        delete context_info->context;
-    }
-
-    if (isolate_info) {
-        isolate_info->refs_count--;
-        maybe_free_isolate_info(isolate_info);
-    }
-}
-
-void deallocate_external_function(void * data) {
-    xfree(data);
-}
-
-void deallocate_snapshot(void * data) {
-    SnapshotInfo* snapshot_info = (SnapshotInfo*)data;
-
-    delete[] snapshot_info->data;
-
-    xfree(snapshot_info);
-}
-
-VALUE allocate_external_function(VALUE klass) {
-    VALUE* self = ALLOC(VALUE);
-    return Data_Wrap_Struct(klass, NULL, deallocate_external_function, (void*)self);
-}
-
-VALUE allocate(VALUE klass) {
-    ContextInfo* context_info = ALLOC(ContextInfo);
-    context_info->isolate_info = NULL;
-    context_info->context = NULL;
-
-    return Data_Wrap_Struct(klass, NULL, deallocate, (void*)context_info);
-}
-
-VALUE allocate_snapshot(VALUE klass) {
-    SnapshotInfo* snapshot_info = ALLOC(SnapshotInfo);
-    snapshot_info->data = NULL;
-    snapshot_info->raw_size = 0;
-
-    return Data_Wrap_Struct(klass, NULL, deallocate_snapshot, (void*)snapshot_info);
-}
-
-VALUE allocate_isolate(VALUE klass) {
-    IsolateInfo* isolate_info = ALLOC(IsolateInfo);
-
-    isolate_info->isolate = NULL;
-    isolate_info->allocator = NULL;
-    isolate_info->startup_data = NULL;
-    isolate_info->interrupted = false;
-    isolate_info->refs_count = 0;
-
-    return Data_Wrap_Struct(klass, NULL, deallocate_isolate, (void*)isolate_info);
-}
-
-static VALUE
-rb_context_stop(VALUE self) {
-
-    ContextInfo* context_info;
-    Data_Get_Struct(self, ContextInfo, context_info);
-
-    Isolate* isolate = context_info->isolate_info->isolate;
-
-    // flag for termination
-    isolate->SetData(1, (void*)true);
-
-    V8::TerminateExecution(isolate);
-    rb_funcall(self, rb_intern("stop_attached"), 0);
-
-    return Qnil;
-}
-
-extern "C" {
-
-    void Init_mini_racer_extension ( void )
-    {
-	VALUE rb_mMiniRacer = rb_define_module("MiniRacer");
-	VALUE rb_cContext = rb_define_class_under(rb_mMiniRacer, "Context", rb_cObject);
-	VALUE rb_cSnapshot = rb_define_class_under(rb_mMiniRacer, "Snapshot", rb_cObject);
-	VALUE rb_cIsolate = rb_define_class_under(rb_mMiniRacer, "Isolate", rb_cObject);
-	VALUE rb_cPlatform = rb_define_class_under(rb_mMiniRacer, "Platform", rb_cObject);
-
-	VALUE rb_eEvalError = rb_define_class_under(rb_mMiniRacer, "EvalError", rb_eStandardError);
-	rb_eScriptTerminatedError = rb_define_class_under(rb_mMiniRacer, "ScriptTerminatedError", rb_eEvalError);
-	rb_eParseError = rb_define_class_under(rb_mMiniRacer, "ParseError", rb_eEvalError);
-	rb_eScriptRuntimeError = rb_define_class_under(rb_mMiniRacer, "RuntimeError", rb_eEvalError);
-	rb_cJavaScriptFunction = rb_define_class_under(rb_mMiniRacer, "JavaScriptFunction", rb_cObject);
-	rb_eSnapshotError = rb_define_class_under(rb_mMiniRacer, "SnapshotError", rb_eStandardError);
-	rb_ePlatformAlreadyInitializedError = rb_define_class_under(rb_mMiniRacer, "PlatformAlreadyInitialized", rb_eStandardError);
-	rb_cFailedV8Conversion = rb_define_class_under(rb_mMiniRacer, "FailedV8Conversion", rb_cObject);
-
-	VALUE rb_cExternalFunction = rb_define_class_under(rb_cContext, "ExternalFunction", rb_cObject);
-	rb_define_method(rb_cContext, "stop", (VALUE(*)(...))&rb_context_stop, 0);
-	rb_define_alloc_func(rb_cContext, allocate);
-	rb_define_alloc_func(rb_cSnapshot, allocate_snapshot);
-	rb_define_alloc_func(rb_cIsolate, allocate_isolate);
-
-	rb_define_private_method(rb_cContext, "eval_unsafe",(VALUE(*)(...))&rb_context_eval_unsafe, 1);
-	rb_define_private_method(rb_cContext, "init_with_isolate",(VALUE(*)(...))&rb_context_init_with_isolate, 1);
-	rb_define_private_method(rb_cExternalFunction, "notify_v8", (VALUE(*)(...))&rb_external_function_notify_v8, 0);
-	rb_define_alloc_func(rb_cExternalFunction, allocate_external_function);
-
-	rb_define_method(rb_cSnapshot, "size", (VALUE(*)(...))&rb_snapshot_size, 0);
-	rb_define_method(rb_cSnapshot, "warmup!", (VALUE(*)(...))&rb_snapshot_warmup, 1);
-	rb_define_private_method(rb_cSnapshot, "load", (VALUE(*)(...))&rb_snapshot_load, 1);
-
-	rb_define_method(rb_cIsolate, "idle_notification", (VALUE(*)(...))&rb_isolate_idle_notification, 1);
-	rb_define_private_method(rb_cIsolate, "init_with_snapshot",(VALUE(*)(...))&rb_isolate_init_with_snapshot, 1);
-
-	rb_define_singleton_method(rb_cPlatform, "set_flag_as_str!", (VALUE(*)(...))&rb_platform_set_flag_as_str, 1);
-    }
-
-}

data/vendor/gems/mini_racer/lib/mini_racer.rb

@@ -1,261 +0,0 @@
-require "mini_racer/version"
-require "mini_racer_extension"
-require "thread"
-
-module MiniRacer
-
-  class EvalError < StandardError; end
-  class ScriptTerminatedError < EvalError; end
-  class ParseError < EvalError; end
-  class SnapshotError < StandardError; end
-  class PlatformAlreadyInitialized < StandardError; end
-
-  class FailedV8Conversion
-    attr_reader :info
-    def initialize(info)
-      @info = info
-    end
-  end
-
-  class RuntimeError < EvalError
-    def initialize(message)
-      message, js_backtrace = message.split("\n", 2)
-      if js_backtrace && !js_backtrace.empty?
-        @js_backtrace = js_backtrace.split("\n")
-        @js_backtrace.map!{|f| "JavaScript #{f.strip}"}
-      else
-        @js_backtrace = nil
-      end
-      super(message)
-    end
-
-    def backtrace
-      val = super
-      return unless val
-      if @js_backtrace
-        @js_backtrace + val
-      else
-        val
-      end
-    end
-  end
-
-  # helper class returned when we have a JavaScript function
-  class JavaScriptFunction
-    def to_s
-      "JavaScript Function"
-    end
-  end
-
-  class Isolate
-    def initialize(snapshot = nil)
-      unless snapshot.nil? || snapshot.is_a?(Snapshot)
-        raise ArgumentError, "snapshot must be a Snapshot object, passed a #{snapshot.inspect}"
-      end
-
-      @lock = Mutex.new
-
-      # defined in the C class
-      init_with_snapshot(snapshot)
-    end
-
-    def with_lock
-      @lock.synchronize { yield }
-    end
-  end
-
-  class Platform
-    class << self
-      def set_flags!(*args, **kwargs)
-        flags_to_strings([args, kwargs]).each do |flag|
-          # defined in the C class
-          set_flag_as_str!(flag)
-        end
-      end
-
-    private
-
-      def flags_to_strings(flags)
-        flags.flatten.map { |flag| flag_to_string(flag) }.flatten
-      end
-
-      # normalize flags to strings, and adds leading dashes if needed
-      def flag_to_string(flag)
-        if flag.is_a?(Hash)
-          flag.map do |key, value|
-            "#{flag_to_string(key)} #{value}"
-          end
-        else
-          str = flag.to_s
-          str = "--#{str}" unless str.start_with?('--')
-          str
-        end
-      end
-    end
-  end
-
-  # eval is defined in the C class
-  class Context
-
-    class ExternalFunction
-      def initialize(name, callback, parent)
-        unless String === name
-          raise ArgumentError, "parent_object must be a String"
-        end
-        parent_object, _ , @name = name.rpartition(".")
-        @callback = callback
-        @parent = parent
-        @parent_object_eval = nil
-        @parent_object = nil
-
-        unless parent_object.empty?
-          @parent_object = parent_object
-
-          @parent_object_eval = ""
-          prev = ""
-          first = true
-          parent_object.split(".").each do |obj|
-            prev << obj
-            if first
-              @parent_object_eval << "if (typeof #{prev} === 'undefined') { #{prev} = {} };\n"
-            else
-              @parent_object_eval << "#{prev} = #{prev} || {};\n"
-            end
-            prev << "."
-            first = false
-          end
-          @parent_object_eval << "#{parent_object};"
-        end
-        notify_v8
-      end
-    end
-
-    attr_reader :isolate
-
-    def initialize(options = nil)
-      options ||= {}
-
-      check_init_options!(options)
-
-      @functions = {}
-      @timeout = nil
-      @current_exception = nil
-      @timeout = options[:timeout]
-      @isolate = options[:isolate] || Isolate.new(options[:snapshot])
-
-      @callback_mutex = Mutex.new
-      @callback_running = false
-      @thread_raise_called = false
-      @eval_thread = nil
-
-      isolate.with_lock do
-        # defined in the C class
-        init_with_isolate(@isolate)
-      end
-    end
-
-    def load(filename)
-      # TODO do this native cause no need to allocate VALUE here
-      eval(File.read(filename))
-    end
-
-    def eval(str)
-      @eval_thread = Thread.current
-      isolate.with_lock do
-        @current_exception = nil
-        timeout do
-          eval_unsafe(str)
-        end
-      end
-    ensure
-      @eval_thread = nil
-    end
-
-
-    def attach(name, callback)
-
-      wrapped = lambda do |*args|
-        begin
-          @callback_mutex.synchronize{
-            @callback_running = true
-          }
-
-          callback.call(*args)
-        ensure
-          @callback_mutex.synchronize {
-            @callback_running = false
-
-            # this is some odd code, but it is required
-            # if we raised on this thread we better wait for it
-            # otherwise we may end up raising in an unsafe spot
-            if @thread_raise_called
-              sleep 0.1
-            end
-            @thread_raise_called = false
-          }
-        end
-      end
-
-      isolate.with_lock do
-        external = ExternalFunction.new(name, wrapped, self)
-        @functions["#{name}"] = external
-      end
-    end
-
-  private
-
-    def stop_attached
-      @callback_mutex.synchronize{
-        if @callback_running
-          @eval_thread.raise ScriptTerminatedError, "Terminated during callback"
-          @thread_raise_called = true
-        end
-      }
-    end
-
-    def timeout(&blk)
-      return blk.call unless @timeout
-
-      _,wp = IO.pipe
-
-      Thread.new do
-        begin
-          result = IO.select([wp],[],[],(@timeout/1000.0))
-          if !result
-            stop
-          end
-        rescue
-          STDERR.puts "FAILED TO TERMINATE DUE TO TIMEOUT"
-        end
-      end
-
-      rval = blk.call
-      wp.write("done")
-
-      rval
-    end
-
-    def check_init_options!(options)
-      assert_option_is_nil_or_a('isolate', options[:isolate], Isolate)
-      assert_option_is_nil_or_a('snapshot', options[:snapshot], Snapshot)
-
-      if options[:isolate] && options[:snapshot]
-        raise ArgumentError, 'can only pass one of isolate and snapshot options'
-      end
-    end
-
-    def assert_option_is_nil_or_a(option_name, object, klass)
-      unless object.nil? || object.is_a?(klass)
-        raise ArgumentError, "#{option_name} must be a #{klass} object, passed a #{object.inspect}"
-      end
-    end
-  end
-
-  # `size` and `warmup!` public methods are defined in the C class
-  class Snapshot
-    def initialize(str = '')
-      # defined in the C class
-      load(str)
-    end
-  end
-end

data/vendor/gems/mini_racer/lib/mini_racer/version.rb

@@ -1,3 +0,0 @@
-module MiniRacer
-  VERSION = "0.1.4"
-end