therubyracer-freebsd 0.10.1

data/ext/v8/v8_template.h

@@ -0,0 +1,8 @@
+#ifndef _RUBY_V8_TEMPLATE_
+#define _RUBY_V8_TEMPLATE_ 
+
+#include "rr.h"
+
+void rr_init_template();
+
+#endif

data/ext/v8/v8_try_catch.cpp

@@ -0,0 +1,70 @@
+#include "rr.h"
+#include "v8_try_catch.h"
+#include "v8_message.h"
+
+using namespace v8;
+
+namespace {
+  VALUE TryCatchClass;
+
+  TryCatch *unwrap(VALUE self) {
+    TryCatch *tc = 0;
+    Data_Get_Struct(self, class TryCatch, tc);
+    if (RTEST(rb_iv_get(self, "dead"))) {
+      rb_raise(rb_eScriptError, "out of scope access of %s", RSTRING_PTR(rb_inspect(self)));
+      return false;
+    } else {
+      return tc;
+    }
+  }
+  
+  VALUE Try(int argc, VALUE *argv, VALUE self) {
+    if (rb_block_given_p()) {
+      HandleScope scope;
+      TryCatch tc;
+      VALUE try_catch = Data_Wrap_Struct(TryCatchClass, 0, 0, &tc);
+      rb_iv_set(try_catch, "dead", Qfalse);
+      VALUE result = rb_yield(try_catch);
+      rb_iv_set(try_catch, "dead", Qtrue);
+      tc.Reset();
+      return result;
+    } else {
+      return Qnil;
+    }
+  }
+  
+  VALUE HasCaught(VALUE self) {
+    TryCatch *tc = unwrap(self);
+    return tc ? rr_v82rb(tc->HasCaught()) : Qnil;
+  }
+  
+  VALUE _Exception(VALUE self) {
+    TryCatch *tc = unwrap(self);
+    return tc ? rr_v82rb(tc->Exception()) : Qnil;
+  }
+  
+  VALUE _StackTrace(VALUE self) {
+    TryCatch *tc = unwrap(self);
+    return tc ? rr_v82rb(tc->StackTrace()) : Qnil;
+  }    
+  
+  VALUE _Message(VALUE self) {
+    TryCatch *tc = unwrap(self);
+    return tc ? rr_v82rb(tc->Message()) : Qnil;
+  }
+  
+  VALUE CanContinue(VALUE self) {
+    TryCatch *tc = unwrap(self);
+    return tc ? rr_v82rb(tc->CanContinue()) : Qnil;    
+  }
+}
+
+void rr_init_v8_try_catch() {
+  TryCatchClass = rr_define_class("TryCatch");
+  rr_define_singleton_method(TryCatchClass, "try", Try, -1);
+  rr_define_method(TryCatchClass, "HasCaught", HasCaught, 0);
+  rr_define_method(TryCatchClass, "Exception", _Exception, 0);
+  rr_define_method(TryCatchClass, "StackTrace", _StackTrace, 0);
+  rr_define_method(TryCatchClass, "Message", _Message, 0);
+  rr_define_method(TryCatchClass, "CanContinue", CanContinue, 0);
+}

data/ext/v8/v8_try_catch.h

@@ -0,0 +1,5 @@
+#ifndef _RR_V8_TRY_CATCH_
+#define _RR_V8_TRY_CATCH_
+
+void rr_init_v8_try_catch();
+#endif

data/ext/v8/v8_v8.cpp

@@ -0,0 +1,34 @@
+
+#include "rr.h"
+
+using namespace v8;
+
+namespace {
+
+  VALUE IsDead(VALUE self) {
+    return rr_v82rb(V8::IsDead());
+  }
+
+  VALUE AdjustAmountOfExternalAllocatedMemory(VALUE self, VALUE bytes) {
+    V8::AdjustAmountOfExternalAllocatedMemory(NUM2INT(bytes));
+    return Qnil;
+  }
+
+   VALUE IdleNotification(VALUE self) {
+     return rr_v82rb(V8::IdleNotification());
+   }
+
+  VALUE SetFlagsFromString(VALUE self, VALUE string) {
+    V8::SetFlagsFromString(RSTRING_PTR(string), (int)RSTRING_LEN(string));
+    return Qnil;
+  }
+}
+
+
+void rr_init_v8_v8() {
+  VALUE V8Module = rr_define_module("V8");
+  rr_define_singleton_method(V8Module, "IsDead", IsDead, 0);
+  rr_define_singleton_method(V8Module, "AdjustAmountOfExternalAllocatedMemory", AdjustAmountOfExternalAllocatedMemory, 1);
+  rr_define_singleton_method(V8Module, "IdleNotification", IdleNotification, 0);
+  rr_define_singleton_method(V8Module, "SetFlagsFromString", SetFlagsFromString, 1);
+}

data/ext/v8/v8_v8.h

@@ -0,0 +1,6 @@
+#ifndef _RR_V8_V8_
+#define _RR_V8_V8_
+
+void rr_init_v8_v8();
+
+#endif

data/ext/v8/v8_value.cpp

@@ -0,0 +1,175 @@
+#include "v8_handle.h"
+#include "v8_value.h"
+
+using namespace v8;
+namespace {
+
+  VALUE ValueClass;
+
+  Persistent<Value>& unwrap(VALUE value) {
+    return rr_v8_handle<Value>(value);
+  }
+  VALUE IsEmpty(VALUE value) {
+    return value == rr_v8_value_empty() ? Qtrue : Qfalse;
+  }
+  VALUE IsUndefined(VALUE self) {
+    HandleScope scope;
+    return rr_v82rb(unwrap(self)->IsUndefined());
+  }
+  VALUE IsNull(VALUE self) {
+    HandleScope scope;
+    return rr_v82rb(unwrap(self)->IsNull());
+  }
+  VALUE IsTrue(VALUE self) {
+    HandleScope scope;
+    return rr_v82rb(unwrap(self)->IsTrue());
+  }
+  VALUE IsFalse(VALUE self) {
+    HandleScope scope;
+    return rr_v82rb(unwrap(self)->IsFalse());
+  }
+  VALUE IsString(VALUE self) {
+    HandleScope scope;
+    return rr_v82rb(unwrap(self)->IsString());
+  }
+  VALUE IsFunction(VALUE self) {
+    HandleScope scope;
+    return rr_v82rb(unwrap(self)->IsFunction());
+  }
+  VALUE IsArray(VALUE self) {
+    HandleScope scope;
+    return rr_v82rb(unwrap(self)->IsArray());
+  }
+  VALUE IsObject(VALUE self) {
+    HandleScope scope;
+    return rr_v82rb(unwrap(self)->IsObject());
+  }
+  VALUE IsBoolean(VALUE self) {
+    HandleScope scope;
+    return rr_v82rb(unwrap(self)->IsBoolean());
+  }
+  VALUE IsNumber(VALUE self) {
+    HandleScope scope;
+    return rr_v82rb(unwrap(self)->IsNumber());
+  }
+  VALUE IsExternal(VALUE self) {
+    HandleScope scope;
+    return rr_v82rb(unwrap(self)->IsExternal());
+  }
+  VALUE IsInt32(VALUE self) {
+    HandleScope scope;
+    return rr_v82rb(unwrap(self)->IsInt32());
+  }
+  VALUE IsUint32(VALUE self) {
+    HandleScope scope;
+    return rr_v82rb(unwrap(self)->IsUint32());
+  }
+  VALUE IsDate(VALUE self) {
+    HandleScope scope;
+    return rr_v82rb(unwrap(self)->IsDate());
+  }
+
+  VALUE ToBoolean(VALUE self) {
+    HandleScope scope;
+    return rr_v82rb(unwrap(self)->ToBoolean());
+  }
+  VALUE ToNumber(VALUE self) {
+    HandleScope scope;
+    return rr_v82rb(unwrap(self)->ToNumber());
+  }
+  VALUE ToString(VALUE self) {
+    HandleScope scope;
+    return rr_v82rb(unwrap(self)->ToString());
+  }
+  VALUE ToDetailString(VALUE self) {
+    HandleScope scope;
+    return rr_v82rb(unwrap(self)->ToDetailString());
+  }
+  VALUE ToObject(VALUE self) {
+    HandleScope scope;
+    return rr_v82rb(unwrap(self)->ToObject());
+  }
+  VALUE ToInteger(VALUE self) {
+    HandleScope scope;
+    return rr_v82rb(unwrap(self)->ToInteger());
+  }
+  VALUE ToUint32(VALUE self) {
+    HandleScope scope;
+    return rr_v82rb(unwrap(self)->ToUint32());
+  }
+  VALUE ToInt32(VALUE self) {
+    HandleScope scope;
+    return rr_v82rb(unwrap(self)->ToInt32());
+  }
+  VALUE ToArrayIndex(VALUE self) {
+    HandleScope scope;
+    return rr_v82rb(unwrap(self)->ToArrayIndex());
+  }
+
+  VALUE Equals(VALUE self, VALUE that) {
+    HandleScope scope;
+    return rr_v82rb(unwrap(self)->Equals(unwrap(that)));
+  }
+  VALUE StrictEquals(VALUE self, VALUE that) {
+    HandleScope scope;
+    return rr_v82rb(unwrap(self)->StrictEquals(unwrap(that)));
+  }
+
+  VALUE BooleanValue(VALUE self) {
+    HandleScope scope;
+    return rr_v82rb(unwrap(self)->BooleanValue());
+  }
+
+  VALUE NumberValue(VALUE self) {
+    HandleScope scope;
+    return rr_v82rb(unwrap(self)->NumberValue());
+  }  
+}
+
+VALUE rr_v8_value_class() {
+  return ValueClass;
+}
+
+VALUE rr_v8_value_empty() {
+  return rr_const_get("Empty");
+}
+
+void rr_init_value() {
+  ValueClass = rr_define_class("Value", rr_v8_handle_class());
+  rr_define_const("Empty", rr_v8_handle_new(ValueClass, Handle<Value>()));
+
+  rr_define_method(ValueClass, "IsEmpty", IsEmpty, 0);
+  rr_define_method(ValueClass, "IsUndefined", IsUndefined, 0);
+  rr_define_method(ValueClass, "IsNull", IsNull, 0);
+  rr_define_method(ValueClass, "IsTrue", IsTrue, 0);
+  rr_define_method(ValueClass, "IsFalse", IsFalse, 0);
+  rr_define_method(ValueClass, "IsString", IsString, 0);
+  rr_define_method(ValueClass, "IsFunction", IsFunction, 0);
+  rr_define_method(ValueClass, "IsArray", IsArray, 0);
+  rr_define_method(ValueClass, "IsObject", IsObject, 0);
+  rr_define_method(ValueClass, "IsBoolean", IsBoolean, 0);
+  rr_define_method(ValueClass, "IsNumber", IsNumber, 0);
+  rr_define_method(ValueClass, "IsExternal", IsExternal, 0);
+  rr_define_method(ValueClass, "IsInt32", IsInt32, 0);
+  rr_define_method(ValueClass, "IsUint32", IsUint32, 0);
+  rr_define_method(ValueClass, "IsDate", IsDate, 0);
+
+  rr_define_method(ValueClass, "ToBoolean", ToBoolean, 0);
+  rr_define_method(ValueClass, "ToNumber", ToNumber, 0);
+  rr_define_method(ValueClass, "ToString", ToString, 0);
+  rr_define_method(ValueClass, "ToDetailString", ToDetailString, 0);
+  rr_define_method(ValueClass, "ToObject", ToObject, 0);
+  rr_define_method(ValueClass, "ToInteger", ToInteger, 0);
+  rr_define_method(ValueClass, "ToUint32", ToUint32, 0);
+  rr_define_method(ValueClass, "ToArrayIndex", ToArrayIndex, 0);
+
+  rr_define_method(ValueClass, "Equals", Equals, 1);
+  rr_define_method(ValueClass, "StrictEquals", StrictEquals, 1);
+
+  rr_define_method(ValueClass, "BooleanValue", BooleanValue, 0);
+  rr_define_method(ValueClass, "NumberValue", NumberValue, 0);
+}
+
+VALUE rr_wrap_v8_value(Handle<Value>& value) {
+  return rr_v8_handle_new(ValueClass, value);
+}

data/ext/v8/v8_value.h

@@ -0,0 +1,10 @@
+#ifndef _RR_V8_VALUE_
+#define _RR_V8_VALUE_ 
+
+#include "rr.h"
+
+void rr_init_value();
+VALUE rr_wrap_v8_value(v8::Handle<v8::Value>& value);
+VALUE rr_v8_value_class();
+VALUE rr_v8_value_empty();
+#endif

data/ext/v8/v8_weakref.cpp

@@ -0,0 +1,61 @@
+#include "v8.h"
+#include "v8_weakref.h"
+
+using namespace v8;
+
+v8_weakref::v8_weakref(VALUE object) {
+  this->v8_active = true;
+  this->rb_active = true;
+  this->external = Persistent<External>::New(External::New((void *)this));
+  this->external.MakeWeak(this, v8_weakref_dispose);
+  this->set(object);
+}
+
+void v8_weakref::set(VALUE value) {
+  this->object_id = rb_obj_id(value);
+  this->rb_active = true;
+  VALUE data = Data_Wrap_Struct(rb_cObject, 0, 0, this);
+  rr_define_finalizer(value,(void*)v8_weakref_finalize, data);
+}
+
+VALUE v8_weakref::get() {
+  if (this->object_id) {
+    return rb_rescue((VALUE (*)(...))v8_weakref_id2ref, this->object_id, (VALUE (*)(...))v8_weakref_nil, Qnil);
+  } else {
+    return Qnil;
+  }
+}
+
+VALUE v8_weakref_finalize(VALUE object_id, VALUE data) {
+  v8_weakref* weakref = 0;
+  Data_Get_Struct(data, struct v8_weakref, weakref);
+  weakref->object_id = Qnil;
+  weakref->rb_active = false;
+  if (!weakref->v8_active) {
+    delete weakref;
+  }
+  return Qnil;
+}
+
+void v8_weakref_dispose(Persistent<Value> value, void* data) {
+  value.Dispose();
+  value.Clear();
+  v8_weakref* weakref = (v8_weakref*)data;
+  weakref->v8_active = false;
+  if (!weakref->rb_active) {
+    delete weakref;
+  }
+}
+
+VALUE v8_weakref_nil(VALUE nil, VALUE exception) {
+  return nil;
+}
+
+VALUE v8_weakref_objectspace() {
+  return rb_const_get(rb_cObject, rb_intern("ObjectSpace"));
+}
+
+VALUE v8_weakref_id2ref(VALUE id) {
+  return rb_funcall(v8_weakref_objectspace(), rb_intern("_id2ref"), 1, id);
+}
+

data/ext/v8/v8_weakref.h

@@ -0,0 +1,29 @@
+#ifndef _RR_V8_WEAKREF_
+#define _RR_V8_WEAKREF_ 
+
+#include <v8.h>
+#include "ruby.h"
+#include "rr.h"
+
+struct v8_weakref  {
+  v8_weakref(VALUE object);
+  VALUE get();
+  void set(VALUE object);
+  void retain();
+  void release();
+
+  VALUE object_id;
+  bool v8_active;
+  bool rb_active;
+  v8::Persistent<v8::External> external;
+};
+
+void  v8_weakref_dispose(v8::Persistent<v8::Value> value, void* weakref);
+VALUE v8_weakref_finalize(VALUE self, VALUE object_id);
+VALUE v8_weakref_objectspace();
+VALUE v8_weakref_nil(VALUE nil, VALUE exception);
+VALUE v8_weakref_id2ref(VALUE id);
+
+// extern "C" VALUE rb_proc_new(VALUE (*)(ANYARGS/* VALUE yieldarg[, VALUE procarg] */), VALUE);
+
+#endif

data/lib/v8.rb

@@ -0,0 +1,23 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+module V8
+  require 'v8/version'
+  require 'v8/v8' #native glue
+  require 'v8/c/locker'
+  require 'v8/portal'
+  require 'v8/portal/caller'
+  require 'v8/portal/proxies'
+  require 'v8/portal/templates'
+  require 'v8/portal/function'
+  require 'v8/portal/constructor'
+  require 'v8/portal/interceptors'
+  require 'v8/context'
+  require 'v8/object'
+  require 'v8/array'
+  require 'v8/function'
+  require 'v8/tap'
+  require 'v8/access'
+  require 'v8/error'
+  require 'v8/stack'
+end

data/lib/v8/access.rb

@@ -0,0 +1,92 @@
+require 'set'
+module V8
+  class Access
+    def get(obj, name, &dontintercept)
+      methods = accessible_methods(obj)
+      if methods.include?(name)
+        method = obj.method(name)
+        method.arity == 0 ? method.call : method.unbind
+      elsif obj.respond_to?(:[]) && !special?(name)
+        obj.send(:[], name, &dontintercept)
+      else
+        yield
+      end
+    end
+
+    def iget(obj, index, &dontintercept)
+      if obj.respond_to?(:[])
+        obj.send(:[], index, &dontintercept)
+      else
+        yield
+      end
+    end
+
+    def set(obj, name, value, &dontintercept)
+      setter = name + "="
+      methods = accessible_methods(obj, true)
+      if methods.include?(setter)
+        obj.send(setter, value)
+      elsif obj.respond_to?(:[]=) && !special?(name)
+        obj.send(:[]=, name, value, &dontintercept)
+      else
+        yield
+      end
+    end
+
+    def iset(obj, index, value, &dontintercept)
+      if obj.respond_to?(:[]=)
+        obj.send(:[]=, index, value, &dontintercept)
+      else
+        yield
+      end
+    end
+
+    def query(obj, name, attributes)
+      if obj.respond_to?(name)
+        attributes.dont_delete
+        unless obj.respond_to?(name + "=")
+          attributes.read_only
+        end
+      else
+        yield
+      end
+    end
+
+    def iquery(obj, index, attributes)
+      if obj.respond_to?(:[])
+        attributes.dont_delete
+        unless obj.respond_to?(:[]=)
+          attributes.read_only
+        end
+      else
+        yield
+      end
+    end
+
+    def names(obj)
+      accessible_methods(obj)
+    end
+
+    def indices(obj)
+      obj.respond_to?(:length) ? (0..obj.length).to_a : yield
+    end
+
+    private
+
+    def accessible_methods(obj, special_methods = false)
+      obj.public_methods(false).map {|m| m.to_s}.to_set.tap do |methods|
+        ancestors = obj.class.ancestors.dup
+        while ancestor = ancestors.shift
+          break if ancestor == ::Object
+          methods.merge(ancestor.public_instance_methods(false).map {|m| m.to_s})
+        end
+        methods.reject!(&special?) unless special_methods
+      end
+    end
+
+    def special?(name = nil)
+      @special ||= lambda {|m| m == "[]" || m == "[]=" || m =~ /=$/}
+      name.nil? ? @special : @special[name]
+    end
+  end
+end