therubyracer 0.8.2 → 0.9.0beta1

data/ext/v8/v8_template.cpp

@@ -1,6 +1,6 @@
 #include "rr.h"
-#include "v8_ref.h"
-#include "v8_func.h"
+#include "v8_handle.h"
+#include "v8_function.h"
 #include "v8_template.h"
 #include "v8_external.h"
 #include "v8_callbacks.h"
@@ -12,49 +12,98 @@ namespace {
   VALUE ObjectTemplateClass;
   VALUE FunctionTemplateClass;
 
-  VALUE rb_hash_lookup(VALUE hash, const char *key) {
-    return rb_funcall(hash, rb_intern("[]"), 1, rb_str_new2(key));
+  struct v8_callback_data {
+    VALUE handler;
+    VALUE getter;
+    VALUE setter;
+    VALUE query;
+    VALUE deleter;
+    VALUE enumerator;
+    VALUE data;
+  };
+
+  void delete_v8_data(Persistent<Value> value, void* parameter) {
+    value.Dispose();
+    delete (v8_callback_data*)parameter;
   }
 
-  VALUE rb_hash_aset(VALUE hash, const char *key, VALUE value) {
-    return ::rb_hash_aset(hash, rb_str_new2(key), value);
+  Local<External> make_v8_data(int argc, VALUE *argv, const char* argf) {
+    VALUE handler; VALUE data;
+    rb_scan_args(argc, argv, argf, &handler, &data);
+    v8_callback_data* v8_data = new v8_callback_data();
+    v8_data->handler = handler;
+    v8_data->data = data;
+    Local<External> external = External::New((void*)v8_data);
+    Persistent<External>::New(external).MakeWeak((void*)v8_data, delete_v8_data);
+    return external;
   }
 
-  Local<Template> tmpl(VALUE self) {
-    return V8_Ref_Get<Template>(self);
+  Persistent<Template> tmpl(VALUE self) {
+    return rr_v8_handle<Template>(self);
   }
-  Local<ObjectTemplate> obj(VALUE self) {
-    return V8_Ref_Get<ObjectTemplate>(self);
+  Persistent<ObjectTemplate> obj(VALUE self) {
+    return rr_v8_handle<ObjectTemplate>(self);
   }
-  Local<FunctionTemplate> func(VALUE self) {
-    return V8_Ref_Get<FunctionTemplate>(self);
+  Persistent<FunctionTemplate> func(VALUE self) {
+    return rr_v8_handle<FunctionTemplate>(self);
   }
 
   VALUE Set(VALUE self, VALUE name, VALUE value) {
     HandleScope handles;
     Local<String> key = rr_rb2v8(name)->ToString();
-    Local<Data> data = V8_Ref_Get<Data>(value);
+    Persistent<Data> data = rr_v8_handle<Data>(value);
     tmpl(self)->Set(key, data);
     return Qnil;
   }
 
   Handle<Value> RubyInvocationCallback(const Arguments& args) {
-    VALUE code = (VALUE)External::Unwrap(args.Data());
+    Handle<External> v8_data_wrapper = Handle<External>::Cast(args.Data());
+    v8_callback_data* v8_data = (v8_callback_data*)v8_data_wrapper->Value();
     VALUE rb_args = rr_v82rb(args);
-    VALUE result = rb_funcall(code, rb_intern("call"), 1, rb_args);
-    return rr_rb2v8(result);
+    rb_iv_set(rb_args, "data", v8_data->data);
+    if (RTEST(v8_data->handler)) {
+      VALUE result = rb_funcall(v8_data->handler, rb_intern("call"), 1, rb_args);
+      return rr_rb2v8(result);
+    } else {
+      return Handle<Value>();
+    }
   }
 
   namespace Obj {
 
+
+    v8_callback_data* accessor_info_data(const AccessorInfo& info) {
+      Handle<External> v8_data_wrapper = Handle<External>::Cast(info.Data());
+      return (v8_callback_data*)v8_data_wrapper->Value();
+    }
+
+    VALUE accessor_info_rb(const AccessorInfo& info) {
+      VALUE rb_data = accessor_info_data(info)->data;
+      VALUE rb_info = rr_v82rb(info);
+      rb_iv_set(rb_info, "data", rb_data);
+      return rb_info;
+    }
+
+    Local<External> accessor_info_data(VALUE getter, VALUE setter, VALUE query, VALUE deleter, VALUE enumerator, VALUE data) {
+      v8_callback_data* v8_data = new v8_callback_data();
+      v8_data->getter = getter;
+      v8_data->setter = setter;
+      v8_data->query = query;
+      v8_data->deleter = deleter;
+      v8_data->enumerator = enumerator;
+      v8_data->data = data;
+      Local<External> external = External::New((void*)v8_data);
+      Persistent<External>::New(external).MakeWeak((void*)v8_data, delete_v8_data);
+      return external;
+    }
+
     /**
      * NamedProperty[Getter|Setter] are used as interceptors on object.
      * See ObjectTemplate::SetNamedPropertyHandler.
      */
     Handle<Value> RubyNamedPropertyGetter(Local<String> property, const AccessorInfo& info) {
-      VALUE code = (VALUE)External::Unwrap(info.Data());
-      VALUE getter = rb_hash_lookup(code, "getter");
-      return rr_rb2v8(rb_funcall(getter, rb_intern("call"), 2, rr_v82rb(property), rr_v82rb(info)));
+      VALUE getter = accessor_info_data(info)->getter;
+      return rr_rb2v8(rb_funcall(getter, rb_intern("call"), 2, rr_v82rb(property), accessor_info_rb(info)));
     }
 
     /**
@@ -62,9 +111,8 @@ namespace {
      * Otherwise, returns an empty handle.
      */
     Handle<Value> RubyNamedPropertySetter(Local<String> property, Local<Value> value, const AccessorInfo& info) {
-      VALUE code = (VALUE)External::Unwrap(info.Data());
-      VALUE setter = rb_hash_lookup(code, "setter");
-      VALUE result = rb_funcall(setter, rb_intern("call"), 3, rr_v82rb(property), rr_v82rb(value), rr_v82rb(info));
+      VALUE setter = accessor_info_data(info)->setter;
+      VALUE result = rb_funcall(setter, rb_intern("call"), 3, rr_v82rb(property), rr_v82rb(value), accessor_info_rb(info));
       return rr_rb2v8(result);
     }
 
@@ -74,9 +122,8 @@ namespace {
      * The result is true if the property exists and false otherwise.
      */
     Handle<Integer> RubyNamedPropertyQuery(Local<String> property, const AccessorInfo& info) {
-      VALUE code = (VALUE)External::Unwrap(info.Data());
-      VALUE query = rb_hash_lookup(code, "query");
-      VALUE result = rb_funcall(query, rb_intern("call"), 2, rr_v82rb(property), rr_v82rb(info));
+      VALUE query = accessor_info_data(info)->query;
+      VALUE result = rb_funcall(query, rb_intern("call"), 2, rr_v82rb(property), accessor_info_rb(info));
       Handle<Value> intercepts = rr_rb2v8(result);
       return intercepts.IsEmpty() ? Handle<Integer>() : Integer::New(None);
     }
@@ -87,9 +134,8 @@ namespace {
      * otherwise.
      */
     Handle<Boolean> RubyNamedPropertyDeleter(Local<String> property, const AccessorInfo& info) {
-      VALUE code = (VALUE)External::Unwrap(info.Data());
-      VALUE deleter = rb_hash_lookup(code, "deleter");
-      VALUE result = rb_funcall(deleter, rb_intern("call"), 2, rr_v82rb(property), rr_v82rb(info));
+      VALUE deleter = accessor_info_data(info)->deleter;
+      VALUE result = rb_funcall(deleter, rb_intern("call"), 2, rr_v82rb(property), accessor_info_rb(info));
       Handle<Value> intercepts = rr_rb2v8(result);
       return intercepts.IsEmpty() ? Handle<Boolean>() : intercepts->ToBoolean();
     }
@@ -99,9 +145,8 @@ namespace {
      * property getter intercepts.
      */
     Handle<Array> RubyNamedPropertyEnumerator(const AccessorInfo& info) {
-      VALUE code = (VALUE)External::Unwrap(info.Data());
-      VALUE enumerator = rb_hash_lookup(code, "enumerator");
-      VALUE result = rb_funcall(enumerator, rb_intern("call"), 1, rr_v82rb(info));
+      VALUE enumerator = accessor_info_data(info)->enumerator;
+      VALUE result = rb_funcall(enumerator, rb_intern("call"), 1, accessor_info_rb(info));
       Handle<Value> v(rr_rb2v8(result));
       if (v.IsEmpty()) {
         return Array::New();
@@ -119,9 +164,8 @@ namespace {
      * request.  Otherwise, returns an empty handle.
      */
     Handle<Value> RubyIndexedPropertyGetter(uint32_t index, const AccessorInfo& info) {
-      VALUE code = (VALUE)External::Unwrap(info.Data());
-      VALUE getter = rb_hash_lookup(code, "getter");
-      VALUE result = rb_funcall(getter, rb_intern("call"), 2, UINT2NUM(index), rr_v82rb(info));
+      VALUE getter = accessor_info_data(info)->getter;
+      VALUE result = rb_funcall(getter, rb_intern("call"), 2, UINT2NUM(index), accessor_info_rb(info));
       return rr_rb2v8(result);
     }
 
@@ -130,9 +174,8 @@ namespace {
      * Otherwise, returns an empty handle.
      */
     Handle<Value> RubyIndexedPropertySetter(uint32_t index, Local<Value> value, const AccessorInfo& info) {
-      VALUE code = (VALUE)External::Unwrap(info.Data());
-      VALUE setter = rb_hash_lookup(code, "setter");
-      VALUE result = rb_funcall(setter, rb_intern("call"), 3, UINT2NUM(index), rr_v82rb(value), rr_v82rb(info));
+      VALUE setter = accessor_info_data(info)->setter;
+      VALUE result = rb_funcall(setter, rb_intern("call"), 3, UINT2NUM(index), rr_v82rb(value), accessor_info_rb(info));
       return rr_rb2v8(result);
     }
 
@@ -141,9 +184,8 @@ namespace {
      * The result is true if the property exists and false otherwise.
      */
      Handle<Integer> RubyIndexedPropertyQuery(uint32_t index, const AccessorInfo& info) {
-       VALUE code = (VALUE)External::Unwrap(info.Data());
-       VALUE query = rb_hash_lookup(code, "query");
-       VALUE result = rb_funcall(query, rb_intern("call"), 2, UINT2NUM(index), rr_v82rb(info));
+       VALUE query = accessor_info_data(info)->query;
+       VALUE result = rb_funcall(query, rb_intern("call"), 2, UINT2NUM(index), accessor_info_rb(info));
        Handle<Value> intercepts = rr_rb2v8(result);
        return intercepts.IsEmpty() ? Handle<Integer>() : Integer::New(None);
      }
@@ -154,9 +196,8 @@ namespace {
      * otherwise.
      */
      Handle<Boolean> RubyIndexedPropertyDeleter(uint32_t index, const AccessorInfo& info) {
-       VALUE code = (VALUE)External::Unwrap(info.Data());
-       VALUE deleter = rb_hash_lookup(code, "deleter");
-       VALUE result = rb_funcall(deleter, rb_intern("call"), 2, UINT2NUM(index), rr_v82rb(info));
+       VALUE deleter = accessor_info_data(info)->deleter;
+       VALUE result = rb_funcall(deleter, rb_intern("call"), 2, UINT2NUM(index), accessor_info_rb(info));
        Handle<Value> intercepts = rr_rb2v8(result);
        return intercepts.IsEmpty() ? Handle<Boolean>() : intercepts->ToBoolean();
      }
@@ -166,9 +207,8 @@ namespace {
      * indexed property getter intercepts.
      */
      Handle<Array> RubyIndexedPropertyEnumerator(const AccessorInfo& info) {
-       VALUE code = (VALUE)External::Unwrap(info.Data());
-       VALUE enumerator = rb_hash_lookup(code, "enumerator");
-       VALUE result = rb_funcall(enumerator, rb_intern("call"), 1, rr_v82rb(info));
+       VALUE enumerator = accessor_info_data(info)->enumerator;
+       VALUE result = rb_funcall(enumerator, rb_intern("call"), 1, accessor_info_rb(info));
        Handle<Value> v(rr_rb2v8(result));
        if (v.IsEmpty()) {
          return Array::New();
@@ -183,7 +223,7 @@ namespace {
 
     VALUE New(VALUE rbclass) {
       HandleScope handles;
-      return rr_v8_ref_create(rbclass, ObjectTemplate::New());
+      return rr_v8_handle_new(rbclass, ObjectTemplate::New());
     }
     VALUE NewInstance(VALUE self) {
       HandleScope scope;
@@ -198,93 +238,68 @@ namespace {
       }
       return rr_v82rb(object);
     }
-    VALUE SetNamedPropertyHandler(VALUE self, VALUE getter, VALUE setter, VALUE query, VALUE deleter, VALUE enumerator) {
+    VALUE SetNamedPropertyHandler(VALUE self, VALUE getter, VALUE setter, VALUE query, VALUE deleter, VALUE enumerator, VALUE data) {
       HandleScope handles;
       if (!RTEST(getter)) {
         rb_raise(rb_eArgError, "you must supply at least a getter to V8::C::ObjectTemplate#SetNamedPropertyHandler()");
         return Qnil;
       }
-      VALUE data = rb_hash_new();
-      rb_hash_aset(data, "getter", getter);
-      rb_hash_aset(data, "setter", setter);
-      rb_hash_aset(data, "query", query);
-      rb_hash_aset(data, "deleter", deleter);
-      rb_hash_aset(data, "enumerator", enumerator);
-      rr_v8_ref_setref(self, "data", data);
       obj(self)->SetNamedPropertyHandler(
         RubyNamedPropertyGetter,
         RTEST(setter) ? RubyNamedPropertySetter : 0,
         RTEST(query) ? RubyNamedPropertyQuery : 0,
         RTEST(deleter) ? RubyNamedPropertyDeleter : 0,
         RTEST(enumerator) ? RubyNamedPropertyEnumerator : 0,
-        rr_v8_external_create(data)
+        accessor_info_data(getter, setter, query, deleter, enumerator, data)
       );
       return Qnil;
     }
-    VALUE SetIndexedPropertyHandler(VALUE self, VALUE getter, VALUE setter, VALUE query, VALUE deleter, VALUE enumerator) {
+
+    VALUE SetIndexedPropertyHandler(VALUE self, VALUE getter, VALUE setter, VALUE query, VALUE deleter, VALUE enumerator, VALUE data) {
       HandleScope scope;
       if (!RTEST(getter)) {
         rb_raise(rb_eArgError, "you must supply at least a getter to V8::C::ObjectTemplate#SetNamedPropertyHandler()");
         return Qnil;
       }
-      VALUE data = rb_hash_new();
-      rb_hash_aset(data, "getter", getter);
-      rb_hash_aset(data, "setter", setter);
-      rb_hash_aset(data, "query", query);
-      rb_hash_aset(data, "deleter", deleter);
-      rb_hash_aset(data, "enumerator", enumerator);
-      //TODO: is this really necessary?
-      rr_v8_ref_setref(self, "data", data);
       obj(self)->SetIndexedPropertyHandler(
         RubyIndexedPropertyGetter,
         RTEST(setter) ? RubyIndexedPropertySetter : 0,
         RTEST(query) ? RubyIndexedPropertyQuery : 0,
         RTEST(deleter) ? RubyIndexedPropertyDeleter : 0,
         RTEST(enumerator) ? RubyIndexedPropertyEnumerator : 0,
-        rr_v8_external_create(data)
+        accessor_info_data(getter, setter, query, deleter, enumerator, data)
       );
       return Qnil;
     }
-    VALUE SetCallAsFunctionHandler(VALUE self) {
-      HandleScope scope;
-      VALUE code = rb_block_proc();
-      if (NIL_P(code)) {
-        return Qnil;
-      }
-      obj(self)->SetCallAsFunctionHandler(RubyInvocationCallback, rr_v8_external_create(code));
+    VALUE SetCallAsFunctionHandler(int argc, VALUE *argv, VALUE self) {
+      Handle<Value> v8_data = make_v8_data(argc, argv, "11");
+      obj(self)->SetCallAsFunctionHandler(RubyInvocationCallback, v8_data);
       return Qnil;
     }
   }
 
   namespace Func {
 
-    VALUE New(VALUE function_template) {
-      HandleScope handles;
-      VALUE code = rb_block_proc();
-      if (NIL_P(code)) {
-        return Qnil;
-      }
-      Local<FunctionTemplate> templ = FunctionTemplate::New(RubyInvocationCallback, rr_v8_external_create(code));
-      VALUE ref = rr_v8_ref_create(function_template,templ);
-      rr_v8_ref_setref(ref, "code", code);
-      return ref;
+    VALUE New(int argc, VALUE *argv, VALUE self) {
+      HandleScope h;
+      Handle<External> v8_data = make_v8_data(argc, argv, "02");
+      Local<FunctionTemplate> t = FunctionTemplate::New(RubyInvocationCallback, v8_data);
+      VALUE handle = rr_v8_handle_new(self,t);
+      return handle;
     }
-    VALUE SetCallHandler(VALUE self) {
-      HandleScope handles;
-      VALUE code = rb_block_proc();
-      if (NIL_P(code)) {
-        return Qnil;
-      }
-      func(self)->SetCallHandler(RubyInvocationCallback, rr_v8_external_create(code));
+    VALUE SetCallHandler(int argc, VALUE *argv, VALUE self) {
+      HandleScope h;
+      Handle<Value> v8_data = make_v8_data(argc, argv, "11");
+      func(self)->SetCallHandler(RubyInvocationCallback, v8_data);
       return Qnil;
     }
     VALUE PrototypeTemplate(VALUE self) {
       HandleScope scope;
-      return rr_v8_ref_create(ObjectTemplateClass, func(self)->PrototypeTemplate());
+      return rr_v8_handle_new(ObjectTemplateClass, func(self)->PrototypeTemplate());
     }
     VALUE InstanceTemplate(VALUE self) {
       HandleScope scope;
-      return rr_v8_ref_create(ObjectTemplateClass, func(self)->InstanceTemplate());
+      return rr_v8_handle_new(ObjectTemplateClass, func(self)->InstanceTemplate());
     }
     VALUE Inherit(VALUE self, VALUE function_template) {
       HandleScope scope;
@@ -308,19 +323,19 @@ namespace {
 }
 
 void rr_init_template() {
-  VALUE Template = rr_define_class("Template");
+  VALUE Template = rr_define_class("Template", rr_v8_handle_class());
   rr_define_method(Template, "Set", Set, 2);
 
   ObjectTemplateClass = rr_define_class("ObjectTemplate", Template);
   rr_define_singleton_method(ObjectTemplateClass, "New", Obj::New, 0);
   rr_define_method(ObjectTemplateClass, "NewInstance", Obj::NewInstance, 0);
-  rr_define_method(ObjectTemplateClass, "SetNamedPropertyHandler", Obj::SetNamedPropertyHandler, 5);
-  rr_define_method(ObjectTemplateClass, "SetIndexedPropertyHandler", Obj::SetIndexedPropertyHandler, 5);
-  rr_define_method(ObjectTemplateClass, "SetCallAsFunctionHandler", Obj::SetCallAsFunctionHandler, 0);
+  rr_define_method(ObjectTemplateClass, "SetNamedPropertyHandler", Obj::SetNamedPropertyHandler, 6);
+  rr_define_method(ObjectTemplateClass, "SetIndexedPropertyHandler", Obj::SetIndexedPropertyHandler, 6);
+  rr_define_method(ObjectTemplateClass, "SetCallAsFunctionHandler", Obj::SetCallAsFunctionHandler, -1);
 
   FunctionTemplateClass = rr_define_class("FunctionTemplate", Template);
-  rr_define_singleton_method(FunctionTemplateClass, "New", Func::New, 0);
-  rr_define_method(FunctionTemplateClass, "SetCallHandler", Func::SetCallHandler, 0);
+  rr_define_singleton_method(FunctionTemplateClass, "New", Func::New, -1);
+  rr_define_method(FunctionTemplateClass, "SetCallHandler", Func::SetCallHandler, -1);
   rr_define_method(FunctionTemplateClass, "PrototypeTemplate", Func::PrototypeTemplate, 0);
   rr_define_method(FunctionTemplateClass, "InstanceTemplate", Func::InstanceTemplate, 0);
   rr_define_method(FunctionTemplateClass, "Inherit", Func::Inherit, 1);

data/ext/v8/v8_try_catch.cpp

@@ -1,6 +1,6 @@
 #include "rr.h"
 #include "v8_try_catch.h"
-#include "v8_msg.h"
+#include "v8_message.h"
 
 using namespace v8;
 

data/ext/v8/v8_v8.cpp

@@ -17,6 +17,12 @@ namespace {
    VALUE IdleNotification(VALUE self) {
      return rr_v82rb(V8::IdleNotification());
    }
+
+  VALUE SetFlagsFromString(VALUE self, VALUE string) {
+    V8::SetFlagsFromString(RSTRING_PTR(string), RSTRING_LEN(string));
+    return Qnil;
+  }
+
 }
 
 
@@ -25,4 +31,5 @@ void rr_init_v8_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_value.cpp

@@ -1,13 +1,16 @@
+#include "v8_handle.h"
 #include "v8_value.h"
-#include "v8_ref.h"
 
 using namespace v8;
 namespace {
-  Local<Value> unwrap(VALUE value) {
-    return V8_Ref_Get<Value>(value);
+
+  VALUE ValueClass;
+
+  Persistent<Value>& unwrap(VALUE value) {
+    return rr_v8_handle<Value>(value);
   }
   VALUE IsEmpty(VALUE value) {
-    return value == rr_cV8_C_Empty ? Qtrue : Qfalse;
+    return value == rr_v8_value_empty() ? Qtrue : Qfalse;
   }
   VALUE IsUndefined(VALUE self) {
     HandleScope scope;
@@ -123,45 +126,50 @@ namespace {
   }  
 }
 
-VALUE rr_cV8_C_Value;
-VALUE rr_cV8_C_Empty;
+VALUE rr_v8_value_class() {
+  return ValueClass;
+}
+
+VALUE rr_v8_value_empty() {
+  return rr_const_get("Empty");
+}
 
 void rr_init_value() {
-  rr_cV8_C_Value = rr_define_class("Value");
-  rr_cV8_C_Empty = rr_define_const("Empty", rr_v8_ref_create(rr_cV8_C_Value, Handle<Value>()));
+  ValueClass = rr_define_class("Value", rr_v8_handle_class());
+  rr_define_const("Empty", rr_v8_handle_new(ValueClass, Handle<Value>()));
 
-  rr_define_method(rr_cV8_C_Value, "IsEmpty", IsEmpty, 0);
-  rr_define_method(rr_cV8_C_Value, "IsUndefined", IsUndefined, 0);
-  rr_define_method(rr_cV8_C_Value, "IsNull", IsNull, 0);
-  rr_define_method(rr_cV8_C_Value, "IsTrue", IsTrue, 0);
-  rr_define_method(rr_cV8_C_Value, "IsFalse", IsFalse, 0);
-  rr_define_method(rr_cV8_C_Value, "IsString", IsString, 0);
-  rr_define_method(rr_cV8_C_Value, "IsFunction", IsFunction, 0);
-  rr_define_method(rr_cV8_C_Value, "IsArray", IsArray, 0);
-  rr_define_method(rr_cV8_C_Value, "IsObject", IsObject, 0);
-  rr_define_method(rr_cV8_C_Value, "IsBoolean", IsBoolean, 0);
-  rr_define_method(rr_cV8_C_Value, "IsNumber", IsNumber, 0);
-  rr_define_method(rr_cV8_C_Value, "IsExternal", IsExternal, 0);
-  rr_define_method(rr_cV8_C_Value, "IsInt32", IsInt32, 0);
-  rr_define_method(rr_cV8_C_Value, "IsUint32", IsUint32, 0);
-  rr_define_method(rr_cV8_C_Value, "IsDate", IsDate, 0);
+  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(rr_cV8_C_Value, "ToBoolean", ToBoolean, 0);
-  rr_define_method(rr_cV8_C_Value, "ToNumber", ToNumber, 0);
-  rr_define_method(rr_cV8_C_Value, "ToString", ToString, 0);
-  rr_define_method(rr_cV8_C_Value, "ToDetailString", ToDetailString, 0);
-  rr_define_method(rr_cV8_C_Value, "ToObject", ToObject, 0);
-  rr_define_method(rr_cV8_C_Value, "ToInteger", ToInteger, 0);
-  rr_define_method(rr_cV8_C_Value, "ToUint32", ToUint32, 0);
-  rr_define_method(rr_cV8_C_Value, "ToArrayIndex", ToArrayIndex, 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(rr_cV8_C_Value, "Equals", Equals, 1);
-  rr_define_method(rr_cV8_C_Value, "StrictEquals", StrictEquals, 1);
+  rr_define_method(ValueClass, "Equals", Equals, 1);
+  rr_define_method(ValueClass, "StrictEquals", StrictEquals, 1);
 
-  rr_define_method(rr_cV8_C_Value, "BooleanValue", BooleanValue, 0);
-  rr_define_method(rr_cV8_C_Value, "NumberValue", NumberValue, 0);
+  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_ref_create(rr_cV8_C_Value, value);
+  return rr_v8_handle_new(ValueClass, value);
 }