therubyracer 0.8.2 → 0.9.0beta1

data/ext/v8/{v8_func.h → v8_function.h}

@@ -3,9 +3,8 @@
 
 #include "rr.h"
 #include "v8.h"
-#include "v8_ref.h"
 
-void rr_init_func();
+void rr_init_function();
 
 VALUE rr_reflect_v8_function(v8::Handle<v8::Value> value);
 

data/ext/v8/v8_handle.cpp

@@ -0,0 +1,119 @@
+
+#include "rr.h"
+#include "v8_handle.h"
+
+using namespace v8;
+
+v8_handle::v8_handle(Handle<void> handle) : handle(Persistent<void>::New(handle)) {
+  this->weakref_callback = Qnil;
+  this->weakref_callback_parameters = Qnil;
+  this->dead = false;
+}
+
+v8_handle::~v8_handle() {
+  handle.Dispose();
+  handle.Clear();
+  dead = true;
+}
+
+namespace {
+  void v8_handle_mark(v8_handle* handle) {
+    rb_gc_mark(handle->weakref_callback);
+    rb_gc_mark(handle->weakref_callback_parameters);
+  }
+
+  void v8_handle_free(v8_handle* handle) {
+    delete handle;
+  }
+
+  VALUE New(VALUE self, VALUE handle) {
+    if (RTEST(handle)) {
+      Persistent<void> that = rr_v8_handle<void>(handle);
+      return rr_v8_handle_new(self, that);
+    } else {
+      return rr_v8_handle_new(self, Handle<void>());
+    }
+  }
+
+  VALUE IsEmpty(VALUE self) {
+    return rr_v82rb(rr_v8_handle<void>(self).IsEmpty());
+  }
+
+  VALUE Clear(VALUE self) {
+    rr_v8_handle<void>(self).Clear();
+    return Qnil;
+  }
+
+  VALUE Dispose(VALUE self) {
+    rr_v8_handle<void>(self).Dispose();
+    return Qnil;
+  }
+
+  void RubyWeakReferenceCallback(Persistent<Value> value, void* parameter) {
+    VALUE self = (VALUE)parameter;
+    v8_handle* handle = rr_v8_handle_raw(self);
+    VALUE callback = handle->weakref_callback;
+    VALUE parameters = handle->weakref_callback_parameters;
+    if (RTEST(callback)) {
+      rb_funcall(callback, rb_intern("call"), 2, self, parameters);
+    }
+    value.Dispose();
+    handle->handle.Dispose();
+    handle->handle.Clear();
+    handle->dead = true;
+
+  }
+
+  VALUE MakeWeak(VALUE self, VALUE parameters, VALUE callback) {
+    v8_handle* handle = rr_v8_handle_raw(self);
+    handle->weakref_callback = callback;
+    handle->weakref_callback_parameters = parameters;
+    rr_v8_handle<void>(self).MakeWeak((void*)self, RubyWeakReferenceCallback);
+    return Qnil;
+  }
+
+  VALUE ClearWeak(VALUE self) {
+    rr_v8_handle<void>(self).ClearWeak();
+    return Qnil;
+  }
+
+  VALUE IsNearDeath(VALUE self) {
+    return rr_v82rb(rr_v8_handle<void>(self).IsNearDeath());
+  }
+
+  VALUE IsWeak(VALUE self) {
+    return rr_v82rb(rr_v8_handle<void>(self).IsWeak());
+  }
+
+  VALUE dead_p(VALUE self) {
+    return rr_v8_handle_raw(self)->dead ? Qtrue : Qfalse;
+  }
+}
+
+void rr_init_handle() {
+  VALUE HandleClass = rr_define_class("Handle");
+  rr_define_method(HandleClass, "dead?", dead_p, 0);
+  rr_define_singleton_method(HandleClass, "New", New, 1);
+  rr_define_method(HandleClass, "IsEmpty", IsEmpty, 0);
+  rr_define_method(HandleClass, "Clear", Clear, 0);
+  rr_define_method(HandleClass, "Dispose", Dispose, 0);
+  rr_define_method(HandleClass, "MakeWeak", MakeWeak, 2);
+  rr_define_method(HandleClass, "ClearWeak", ClearWeak, 0);
+  rr_define_method(HandleClass, "IsNearDeath", IsNearDeath, 0);
+  rr_define_method(HandleClass, "IsWeak", IsWeak, 0);
+}
+
+VALUE rr_v8_handle_new(VALUE klass, v8::Handle<void> handle) {
+  v8_handle* new_handle = new v8_handle(handle);
+  return Data_Wrap_Struct(klass, v8_handle_mark, v8_handle_free, new_handle);
+}
+
+VALUE rr_v8_handle_class() {
+  return rr_define_class("Handle");
+}
+
+v8_handle* rr_v8_handle_raw(VALUE value) {
+  v8_handle* handle = 0;
+  Data_Get_Struct(value, struct v8_handle, handle);
+  return handle;
+}

data/ext/v8/v8_handle.h

@@ -0,0 +1,27 @@
+#ifndef _RR_V8_HANDLE_
+#define _RR_V8_HANDLE_ 
+
+#include <v8.h>
+#include "ruby.h"
+
+struct v8_handle  {
+  v8_handle(v8::Handle<void> object);
+  virtual ~v8_handle();
+
+  v8::Persistent<void> handle;
+  bool dead;
+  VALUE weakref_callback;
+  VALUE weakref_callback_parameters;
+};
+
+void rr_init_handle();
+
+v8_handle* rr_v8_handle_raw(VALUE value);
+
+template <class T> v8::Persistent<T>& rr_v8_handle(VALUE value) {
+  return (v8::Persistent<T>&)(rr_v8_handle_raw(value)->handle);
+}
+VALUE rr_v8_handle_new(VALUE rbclass, v8::Handle<void> handle);
+VALUE rr_v8_handle_class();
+
+#endif

data/ext/v8/{v8_msg.cpp → v8_message.cpp}

@@ -1,18 +1,17 @@
-#include "v8_msg.h"
-#include "v8_ref.h"
+#include "v8_message.h"
+#include "v8_handle.h"
 
 using namespace v8;
 
 namespace {
   VALUE MessageClass;
   
-  Local<Message> unwrap(VALUE self) {
-    return V8_Ref_Get<Message>(self);
+  Persistent<Message>& unwrap(VALUE self) {
+    return rr_v8_handle<Message>(self);
   }
   
   VALUE Get(VALUE self) {
-    Local<Message> message(unwrap(self));
-    return rr_v82rb(message->Get());
+    return rr_v82rb(unwrap(self)->Get());
   }
 
   VALUE GetSourceLine(VALUE self) {
@@ -49,8 +48,8 @@ namespace {
   }
 }
 
-void rr_init_msg() {
-  MessageClass = rr_define_class("Message");
+void rr_init_message() {
+  MessageClass = rr_define_class("Message", rr_v8_handle_class());
   rr_define_method(MessageClass, "Get", Get, 0);
   rr_define_method(MessageClass, "GetSourceLine", GetSourceLine, 0);
   rr_define_method(MessageClass, "GetScriptResourceName", GetScriptResourceName, 0);
@@ -63,6 +62,6 @@ void rr_init_msg() {
 }
 
 VALUE rr_reflect_v8_message(Handle<Message> value) {
-  return rr_v8_ref_create(MessageClass, value);
+  return rr_v8_handle_new(MessageClass, value);
 }
 

data/ext/v8/{v8_msg.h → v8_message.h}

@@ -4,7 +4,7 @@
 #include "v8.h"
 #include "rr.h"
 
-void rr_init_msg();
+void rr_init_message();
 VALUE rr_reflect_v8_message(v8::Handle<v8::Message> value);
 
 #endif

data/ext/v8/{v8_obj.cpp → v8_object.cpp}

@@ -1,5 +1,6 @@
-#include "v8_obj.h"
-#include "v8_ref.h"
+#include "v8_handle.h"
+#include "v8_weakref.h"
+#include "v8_object.h"
 #include "v8_value.h"
 #include "v8_template.h"
 #include "v8_external.h"
@@ -8,36 +9,36 @@ using namespace v8;
 
 #include <cstdio>
 
-VALUE rr_cV8_C_Object;
-
 namespace {
-  
-  Local<Object> unwrap(VALUE robj) {
-    return V8_Ref_Get<Object>(robj);
+
+  VALUE ObjectClass;
+
+  Persistent<Object>& unwrap(VALUE object) {
+    return rr_v8_handle<Object>(object);
   }
-  
+
   VALUE Get(VALUE self, VALUE key) {
     HandleScope handles;
-    Local<Object> obj(unwrap(self));
+    Persistent<Object> obj(unwrap(self));
     if (rb_obj_is_kind_of(key, rb_cNumeric)) {
       return rr_v82rb(obj->Get(NUM2UINT(key)));
     } else {
       return rr_v82rb(obj->Get(rr_rb2v8(key)->ToString()));
     }
   }
-  
+
   VALUE New(VALUE rbclass) {
     HandleScope handles;
     if (!Context::InContext()) {
       rb_raise(rb_eScriptError, "Object::New() called without an entered Context");
       return Qnil;
     }
-    return rr_v8_ref_create(rbclass, Object::New());
+    return rr_v8_handle_new(rbclass, Object::New());
   }
-  
+
   VALUE Set(VALUE self, VALUE key, VALUE value) {
     HandleScope handles;
-    Local<Object> obj = unwrap(self);
+    Persistent<Object> obj = unwrap(self);
     if (rb_obj_is_kind_of(key, rb_cNumeric)) {
       return rr_v82rb(obj->Set(NUM2UINT(key), rr_rb2v8(value)));
     } else {
@@ -47,7 +48,7 @@ namespace {
 
   VALUE GetPropertyNames(VALUE self) {
     HandleScope handles;
-    Local<Object> object = unwrap(self);  
+    Persistent<Object> object = unwrap(self);
     Local<Value> names = object->GetPropertyNames();
     return rr_v82rb(names);
   }
@@ -70,27 +71,48 @@ namespace {
   }
   VALUE SetPrototype(VALUE self, VALUE prototype) {
     HandleScope scope;
-    Handle<Value> proto = rr_rb2v8(prototype);
-    Local<Object> me = unwrap(self);
+    Handle<Value> proto(rr_rb2v8(prototype));
     return rr_v82rb(unwrap(self)->SetPrototype(rr_rb2v8(prototype)));
   }
 }
 
-void rr_init_obj() {
-  rr_cV8_C_Object = rr_define_class("Object", rr_cV8_C_Value);
-  rr_define_singleton_method(rr_cV8_C_Object, "New", New, 0);
-  rr_define_method(rr_cV8_C_Object, "Get", Get, 1);
-  rr_define_method(rr_cV8_C_Object, "Set", Set, 2);
-  rr_define_method(rr_cV8_C_Object, "GetPropertyNames", GetPropertyNames, 0);
-  rr_define_method(rr_cV8_C_Object, "GetHiddenValue", GetHiddenValue, 1);
-  rr_define_method(rr_cV8_C_Object, "SetHiddenValue", SetHiddenValue, 2);
-  rr_define_method(rr_cV8_C_Object, "GetPrototype", GetPrototype, 0);
-  rr_define_method(rr_cV8_C_Object, "SetPrototype", SetPrototype, 1);
+VALUE rr_v8_object_class() {
+  return ObjectClass;
+}
+
+void rr_init_object() {
+  ObjectClass = rr_define_class("Object", rr_v8_value_class());
+  rr_define_singleton_method(ObjectClass, "New", New, 0);
+  rr_define_method(ObjectClass, "Get", Get, 1);
+  rr_define_method(ObjectClass, "Set", Set, 2);
+  rr_define_method(ObjectClass, "GetPropertyNames", GetPropertyNames, 0);
+  rr_define_method(ObjectClass, "GetHiddenValue", GetHiddenValue, 1);
+  rr_define_method(ObjectClass, "SetHiddenValue", SetHiddenValue, 2);
+  rr_define_method(ObjectClass, "GetPrototype", GetPrototype, 0);
+  rr_define_method(ObjectClass, "SetPrototype", SetPrototype, 1);
+}
+
+VALUE rr_reflect_v8_object_as(Handle<Value> value, VALUE ruby_class) {
+  Handle<Object> object = Handle<Object>::Cast(value);
+  VALUE handle;
+  v8_weakref* backref;
+  Local<Value> holder = object->GetHiddenValue(String::NewSymbol("TheRubyRacer::Backref"));
+  if (holder.IsEmpty()) {
+    handle = rr_v8_handle_new(ruby_class, object);
+    backref = new v8_weakref(handle);
+    object->SetHiddenValue(String::NewSymbol("TheRubyRacer::Backref"), backref->external);
+  } else {
+    backref = (v8_weakref*)External::Unwrap(holder);
+    handle = backref->get();
+    if (!RTEST(handle)) {
+      handle = rr_v8_handle_new(ruby_class, object);
+      backref->set(handle);
+    }
+  }
+  return handle;
 }
 
 VALUE rr_reflect_v8_object(Handle<Value> value) {
-  Local<Object> object(Object::Cast(*value));
-  Local<Value> peer = object->GetHiddenValue(String::NewSymbol("TheRubyRacer::RubyObject"));
-  return peer.IsEmpty() ? rr_v8_ref_create(rr_cV8_C_Object, object) : (VALUE)External::Unwrap(peer);
+  return rr_reflect_v8_object_as(value, ObjectClass);
 }
 

data/ext/v8/{v8_obj.h → v8_object.h}

@@ -3,9 +3,8 @@
 
 #include "rr.h"
 
-extern VALUE rr_cV8_C_Object;
-
-void rr_init_obj();
+void rr_init_object();
+VALUE rr_v8_object_class();
 VALUE rr_reflect_v8_object(v8::Handle<v8::Value> value);
-
+VALUE rr_reflect_v8_object_as(v8::Handle<v8::Value> object, VALUE ruby_class);
 #endif

data/ext/v8/v8_script.cpp

@@ -1,5 +1,5 @@
 #include "v8.h"
-#include "v8_ref.h"
+#include "v8_handle.h"
 #include "v8_script.h"
 
 using namespace v8;
@@ -10,26 +10,26 @@ namespace {
     HandleScope scope;
     Local<String> src(rr_rb2v8(source)->ToString());
     Local<String> src_name(rr_rb2v8(source_name)->ToString());
-    return rr_v8_ref_create(self, Script::Compile(src, src_name));
+    return rr_v8_handle_new(self, Script::Compile(src, src_name));
   }
 
   VALUE Compile(VALUE self, VALUE source, VALUE source_name) {
     HandleScope scope;
     Local<String> src(rr_rb2v8(source)->ToString());
     Local<String> src_name(rr_rb2v8(source_name)->ToString());
-    return rr_v8_ref_create(self, Script::Compile(src, src_name));
+    return rr_v8_handle_new(self, Script::Compile(src, src_name));
   }
 
   VALUE Run(VALUE self) {
     HandleScope scope;
-    Local<Script> script(V8_Ref_Get<Script>(self));
+    Persistent<Script> script(rr_v8_handle<Script>(self));
     Local<Value> result(script->Run());
     return result.IsEmpty() ? Qnil : rr_v82rb(result);
   }
 }
 
 void rr_init_script() {
-  VALUE ScriptClass = rr_define_class("Script");
+  VALUE ScriptClass = rr_define_class("Script", rr_v8_handle_class());
   rr_define_singleton_method(ScriptClass, "New", New, 2);
   rr_define_singleton_method(ScriptClass, "Compile", Compile, 2);
   rr_define_method(ScriptClass, "Run", Run, 0);

data/ext/v8/{v8_str.cpp → v8_string.cpp}

@@ -1,26 +1,26 @@
 
-#include "v8_str.h"
 #include "v8.h"
-#include "v8_ref.h"
+#include "v8_handle.h"
 #include "v8_value.h"
+#include "v8_string.h"
 
 using namespace v8;
 
 namespace {  
   VALUE StringClass;
   
-  Handle<String> unwrap(VALUE value) {
-    return V8_Ref_Get<String>(value);
+  Persistent<String>& unwrap(VALUE value) {
+    return rr_v8_handle<String>(value);
   }
   VALUE New(VALUE string_class, VALUE data) {
     HandleScope handles;
     VALUE str = rb_funcall(data, rb_intern("to_s"), 0);
-    return rr_v8_ref_create(string_class, String::New(RSTRING_PTR(str), RSTRING_LEN(str)));
+    return rr_v8_handle_new(string_class, String::New(RSTRING_PTR(str), RSTRING_LEN(str)));
   }
   VALUE NewSymbol(VALUE string_class, VALUE data) {
     HandleScope scope;
     VALUE str = rb_funcall(data, rb_intern("to_s"), 0);
-    return rr_v8_ref_create(string_class, String::NewSymbol(RSTRING_PTR(str), RSTRING_LEN(str)));
+    return rr_v8_handle_new(string_class, String::NewSymbol(RSTRING_PTR(str), RSTRING_LEN(str)));
   }
   VALUE Utf8Value(VALUE self) {
     HandleScope handles;
@@ -37,13 +37,11 @@ namespace {
 }
 
 VALUE rr_reflect_v8_string(Handle<Value> value) {
-  HandleScope handles;
-  Local<String> string = String::Cast(*value);
-  return rr_v8_ref_create(StringClass, string);
+  return rr_v8_handle_new(StringClass, Handle<String>::Cast(value));
 }
 
-void rr_init_str() {
-  StringClass = rr_define_class("String", rr_cV8_C_Value);
+void rr_init_string() {
+  StringClass = rr_define_class("String", rr_v8_value_class());
   rr_define_singleton_method(StringClass, "New", New, 1);
   rr_define_singleton_method(StringClass, "NewSymbol", NewSymbol, 1);
   rr_define_method(StringClass, "Utf8Value", Utf8Value, 0);

data/ext/v8/{v8_str.h → v8_string.h}

@@ -3,7 +3,7 @@
 
 #include "rr.h"
 
-void rr_init_str();
+void rr_init_string();
 
 VALUE rr_reflect_v8_string(v8::Handle<v8::Value> value);
 #endif