therubyracer 0.8.2 → 0.9.0beta1

data/Changelog.md

@@ -1,6 +1,6 @@
 # Changelog  
 
-## 0.8.2 - 2011/05/25
+## Edge
 
 * expose the V8 debugger via V8::C::Debug::EnableAgent()
 * force UTf-8 encoding on strings returned from javascript in ruby 1.9

data/ext/v8/rr.cpp

@@ -1,12 +1,13 @@
 #include "rr.h"
-#include "v8_cxt.h"
+#include "v8_context.h"
+#include "v8_handle.h"
 #include "v8_value.h"
-#include "v8_obj.h"
-#include "v8_func.h"
+#include "v8_object.h"
+#include "v8_function.h"
 #include "v8_array.h"
-#include "v8_str.h"
+#include "v8_string.h"
 #include "v8_date.h"
-#include "v8_msg.h"
+#include "v8_message.h"
 #include "v8_external.h"
 #include "v8_exception.h"
 
@@ -33,9 +34,15 @@ VALUE rr_define_const(const char *name, VALUE value) {
   return value;
 }
 
+VALUE rr_const_get(const char *name) {
+  VALUE V8 = rb_define_module("V8");
+  VALUE V8_C = rb_define_module_under(V8, "C");
+  return rb_const_get(V8_C, rb_intern(name));
+}
+
 VALUE rr_v82rb(Handle<Value> value) {
   if (value.IsEmpty()) {
-    return rr_cV8_C_Empty;
+    return rr_v8_value_empty();
   }
   if (value->IsUndefined() || value->IsNull()) {
     return Qnil;
@@ -142,7 +149,7 @@ Handle<Value> rr_rb2v8(VALUE value) {
   case T_FALSE:
     return False();
   case T_DATA:
-    return V8_Ref_Get<Value>(value);
+    return rr_v8_handle<Value>(value);
   case T_OBJECT:
   case T_CLASS:
   case T_ICLASS:

data/ext/v8/rr.h

@@ -10,6 +10,7 @@
 VALUE rr_define_class(const char *name, VALUE superclass = rb_cObject);
 VALUE rr_define_module(const char *name);
 VALUE rr_define_const(const char *name, VALUE value);
+VALUE rr_const_get(const char *name);
 
 VALUE rr_v82rb(v8::Handle<v8::Value> value);
 VALUE rr_v82rb(v8::Handle<v8::Boolean> value);

data/ext/v8/v8.cpp

@@ -1,10 +1,11 @@
-#include "v8_cxt.h"
+#include "v8_handle.h"
+#include "v8_context.h"
 #include "v8_value.h"
-#include "v8_str.h"
-#include "v8_obj.h"
+#include "v8_string.h"
+#include "v8_object.h"
 #include "v8_array.h"
-#include "v8_msg.h"
-#include "v8_func.h"
+#include "v8_message.h"
+#include "v8_function.h"
 #include "v8_date.h"
 #include "v8_script.h"
 #include "v8_template.h"
@@ -19,27 +20,28 @@
 #include <stdio.h>
 
 extern "C" {
-    void Init_v8();
+  void Init_v8();
 }
 
 extern "C" {
-    void Init_v8() {
-        rr_init_cxt();
-        rr_init_value();
-        rr_init_str();
-        rr_init_script();
-        rr_init_template();
-        rr_init_obj();
-        rr_init_func();
-        rr_init_v8_array();
-        rr_init_v8_date();
-        rr_init_msg();
-        rr_init_v8_try_catch();
-        rr_init_v8_callbacks();
-        rr_init_v8_external();
-        rr_init_v8_exception();
-        rr_init_v8_locker();
-        rr_init_v8_debug();
-        rr_init_v8_v8();
-    }
+  void Init_v8() {
+    rr_init_handle();
+    rr_init_context();
+    rr_init_value();
+    rr_init_string();
+    rr_init_script();
+    rr_init_template();
+    rr_init_object();
+    rr_init_function();
+    rr_init_v8_array();
+    rr_init_v8_date();
+    rr_init_message();
+    rr_init_v8_try_catch();
+    rr_init_v8_callbacks();
+    rr_init_v8_external();
+    rr_init_v8_exception();
+    rr_init_v8_locker();
+    rr_init_v8_debug();
+    rr_init_v8_v8();
+  }
 }

data/ext/v8/v8_array.cpp

@@ -1,6 +1,6 @@
+#include "v8_handle.h"
 #include "v8_array.h"
-#include "v8_ref.h"
-#include "v8_obj.h"
+#include "v8_object.h"
 
 using namespace v8;
 
@@ -9,8 +9,8 @@ namespace {
   
   VALUE ArrayClass;
   
-  Local<Array> unwrap(VALUE self) {
-    return V8_Ref_Get<Array>(self);
+  Persistent<Array>& unwrap(VALUE self) {
+    return rr_v8_handle<Array>(self);
   }
   
   VALUE New(int argc, VALUE *argv, VALUE self) {
@@ -24,7 +24,7 @@ namespace {
       length = INT2FIX(0);
     }
     HandleScope scope;
-    return rr_v8_ref_create(self, Array::New(NUM2INT(length)));
+    return rr_v8_handle_new(self, Array::New(NUM2INT(length)));
   }
   
   VALUE Length(VALUE self) {
@@ -37,14 +37,12 @@ namespace {
 }
 
 void rr_init_v8_array() {
-  ArrayClass = rr_define_class("Array", rr_cV8_C_Object);
+  ArrayClass = rr_define_class("Array", rr_v8_object_class());
   rr_define_singleton_method(ArrayClass, "New", New, -1);
   rr_define_method(ArrayClass, "Length", Length, 0);
   rr_define_method(ArrayClass, "CloneElementAt", CloneElementAt, 1);
 }
 
 VALUE rr_reflect_v8_array(Handle<Value> value) {
-  Local<Array> array(Array::Cast(*value));
-  Local<Value> peer = array->GetHiddenValue(String::NewSymbol("TheRubyRacer::RubyObject"));
-  return peer.IsEmpty() ? rr_v8_ref_create(ArrayClass, value) : (VALUE)External::Unwrap(peer);
+  return rr_reflect_v8_object_as(value, ArrayClass);
 }

data/ext/v8/v8_callbacks.cpp

@@ -86,7 +86,7 @@ namespace {
     return rr_v82rb(args(self)->isConstructCall);
   }
   VALUE _Data(VALUE self) {
-    return rr_v82rb(info(self)->data);
+    return rb_iv_get(self, "data");
   }
   
   struct WrapAccessorInfo : Wrap {

data/ext/v8/{v8_cxt.cpp → v8_context.cpp}

@@ -1,7 +1,7 @@
 #include "rr.h"
-#include "v8_ref.h"
-#include "v8_cxt.h"
-#include "v8_msg.h"
+#include "v8_handle.h"
+#include "v8_context.h"
+#include "v8_message.h"
 #include "v8_template.h"
 #include "v8_external.h"
 
@@ -11,18 +11,18 @@ namespace {
 
   VALUE ContextClass;
 
-  Local<Context> unwrap(VALUE value) {
-    return V8_Ref_Get<Context>(value);
+  Persistent<Context>& unwrap(VALUE value) {
+    return rr_v8_handle<Context>(value);
   }
 
   VALUE New(int argc, VALUE *argv, VALUE self) {
     HandleScope handles;
     VALUE global_template; VALUE global_object;
     rb_scan_args(argc,argv, "02", &global_template, &global_object);
-    Handle<ObjectTemplate> v8_global_template(NIL_P(global_template) ? Handle<ObjectTemplate>() : V8_Ref_Get<ObjectTemplate>(global_template));
-    Handle<Value> v8_global_object(NIL_P(global_object) ? Handle<Value>() : V8_Ref_Get<Value>(global_object));
+    Handle<ObjectTemplate> v8_global_template(NIL_P(global_template) ? Handle<ObjectTemplate>() : rr_v8_handle<ObjectTemplate>(global_template));
+    Handle<Value> v8_global_object(NIL_P(global_object) ? Handle<Value>() : rr_v8_handle<Value>(global_object));
     Persistent<Context> cxt(Context::New(0, v8_global_template, v8_global_object));
-    VALUE ref = rr_v8_ref_create(self, cxt);
+    VALUE ref = rr_v8_handle_new(self, cxt);
     cxt.Dispose();
     return ref;
   }
@@ -35,7 +35,7 @@ namespace {
     HandleScope handles;
     if (Context::InContext()) {
       Local<Context> current = Context::GetEntered();
-      return rr_v8_ref_create(self, current);    
+      return rr_v8_handle_new(self, current);    
     } else {
       return Qnil;
     }
@@ -77,8 +77,8 @@ namespace {
   }
 }
 
-void rr_init_cxt() {
-  ContextClass = rr_define_class("Context");
+void rr_init_context() {
+  ContextClass = rr_define_class("Context", rr_v8_handle_class());
   rr_define_singleton_method(ContextClass, "New", New, -1);
   rr_define_singleton_method(ContextClass, "InContext", InContext, 0);
   rr_define_singleton_method(ContextClass, "GetEntered", GetEntered, 0);

data/ext/v8/{v8_cxt.h → v8_context.h}

@@ -1,6 +1,6 @@
 #ifndef _RUBY_V8_CXT_
 #define _RUBY_V8_CXT_ 
 
-void rr_init_cxt();
+void rr_init_context();
 
 #endif

data/ext/v8/v8_date.cpp

@@ -1,7 +1,7 @@
 #include "rr.h"
 #include "v8_date.h"
 #include "v8_value.h"
-#include "v8_ref.h"
+#include "v8_handle.h"
 
 using namespace v8;
 
@@ -11,25 +11,25 @@ namespace {
 
   VALUE New(VALUE self, VALUE time) {
     HandleScope scope;
-    return rr_v8_ref_create(self, Date::New(NUM2DBL(time)));
+    return rr_v8_handle_new(self, Date::New(NUM2DBL(time)));
   }
 
   // Override Value::NumberValue in order to ensure that we call the more specific and optimized
   // Number Value in v8::Date
   VALUE NumberValue(VALUE self) {
-    HandleScope scope;
-    Local<Date> date = V8_Ref_Get<Date>(self);
+    Persistent<Date> date = rr_v8_handle<Date>(self);
     return rr_v82rb(date->NumberValue());
   }
 }
 
 void rr_init_v8_date() {
-  DateClass = rr_define_class("Date", rr_cV8_C_Value);
+  DateClass = rr_define_class("Date", rr_v8_value_class());
   rr_define_singleton_method(DateClass, "New", New, 1);
   rr_define_method(DateClass, "NumberValue", NumberValue, 0);
 }
 
 VALUE rr_reflect_v8_date(Handle<Value> value) {
+  HandleScope hs;
   Local<Date> date(Date::Cast(*value));
-  return rr_v8_ref_create(DateClass, date);
+  return rr_v8_handle_new(DateClass, date);
 }

data/ext/v8/v8_exception.cpp

@@ -1,6 +1,6 @@
 #include "v8_exception.h"
 #include "rr.h"
-#include "v8_ref.h"
+#include "v8_handle.h"
 #include "execinfo.h"
 #include "signal.h"
 
@@ -44,8 +44,8 @@ namespace {
   VALUE StackFrameClass;
   namespace Trace {
 
-    Local<StackTrace> trace(VALUE value) {
-      return V8_Ref_Get<StackTrace>(value);
+    Persistent<StackTrace>& trace(VALUE value) {
+      return rr_v8_handle<StackTrace>(value);
     }
     VALUE GetFrame(VALUE self, VALUE index) {
       HandleScope scope;
@@ -53,8 +53,7 @@ namespace {
     }
     VALUE GetFrameCount(VALUE self) {
       HandleScope scope;
-      Local<StackTrace> t = trace(self);
-      return rr_v82rb(t->GetFrameCount());
+      return rr_v82rb(trace(self)->GetFrameCount());
     }
     VALUE AsArray(VALUE self) {
       return rr_v82rb(trace(self)->AsArray());
@@ -65,8 +64,8 @@ namespace {
   }
 
   namespace Frame {
-    Local<StackFrame> frame(VALUE value) {
-     return V8_Ref_Get<StackFrame>(value);
+    Persistent<StackFrame>& frame(VALUE value) {
+     return rr_v8_handle<StackFrame>(value);
     }
     VALUE GetLineNumber(VALUE self) {
       HandleScope scope;
@@ -107,13 +106,13 @@ void rr_init_v8_exception() {
   rr_define_singleton_method(ExceptionClass, "SyntaxError", SyntaxError, 1);
   rr_define_singleton_method(ExceptionClass, "Error", Error, 1);
 
-  StackTraceClass = rr_define_class("StackTrace");
+  StackTraceClass = rr_define_class("StackTrace", rr_v8_handle_class());
   rr_define_singleton_method(StackTraceClass, "CurrentStackTrace", Trace::CurrentStackTrace, 1);
   rr_define_method(StackTraceClass, "GetFrame", Trace::GetFrame, 1);
   rr_define_method(StackTraceClass, "GetFrameCount", Trace::GetFrameCount, 0);
   rr_define_method(StackTraceClass, "AsArray", Trace::AsArray, 0);
 
-  StackFrameClass = rr_define_class("StackFrame");
+  StackFrameClass = rr_define_class("StackFrame", rr_v8_handle_class());
   rr_define_method(StackFrameClass, "GetLineNumber", Frame::GetLineNumber, 0);
   rr_define_method(StackFrameClass, "GetColumn", Frame::GetColumn, 0);
   rr_define_method(StackFrameClass, "GetScriptName", Frame::GetScriptName, 0);
@@ -127,8 +126,8 @@ void rr_init_v8_exception() {
 }
 
 VALUE rr_reflect_v8_stacktrace(Handle<StackTrace> value) {
-  return rr_v8_ref_create(StackTraceClass, value);
+  return rr_v8_handle_new(StackTraceClass, value);
 }
 VALUE rr_reflect_v8_stackframe(Handle<StackFrame> value) {
-  return rr_v8_ref_create(StackFrameClass, value);
+  return rr_v8_handle_new(StackFrameClass, value);
 }

data/ext/v8/v8_external.cpp

@@ -1,7 +1,7 @@
 #include "rr.h"
 #include "v8_external.h"
 
-#include "v8_ref.h"
+#include "v8_handle.h"
 #include "v8_value.h"
 using namespace v8;
 
@@ -9,14 +9,14 @@ namespace {
   VALUE ExternalClass;
   VALUE references;
 
-  VALUE New(VALUE rbclass, VALUE value) {
+  VALUE New(VALUE self, VALUE value) {
     HandleScope scope;
-    return rr_v8_ref_create(rbclass, rr_v8_external_create(value));
+    return rr_v8_handle_new(self, External::New((void*)value));
   }
   VALUE Unwrap(VALUE self, VALUE value) {
     HandleScope scope;
     if (rb_obj_is_kind_of(value, self)) {
-      return (VALUE)External::Unwrap(V8_Ref_Get<External>(self));
+      return (VALUE)External::Unwrap(rr_v8_handle<External>(self));
     } else {
       rb_raise(rb_eArgError, "cannot unwrap %s. It is not a kind of %s", RSTRING_PTR(rb_class_name(rb_class_of(value))), RSTRING_PTR(rb_class_name(self)));
       return Qnil;
@@ -24,34 +24,17 @@ namespace {
   }
   VALUE _Value(VALUE self) {
     HandleScope scope;
-    return (VALUE)V8_Ref_Get<External>(self)->Value();
-  }
-  void GCWeakReferenceCallback(Persistent<Value> object, void* parameter) {
-    // printf("V8 GC!!!!\n");
-    Local<External> external(External::Cast(*object));
-    rb_hash_delete(references, rb_obj_id((VALUE)external->Value()));
-    // V8::AdjustAmountOfExternalAllocatedMemory(-100000000);
+    return (VALUE)rr_v8_handle<External>(self)->Value();
   }
 }
 
 void rr_init_v8_external() {
-  ExternalClass = rr_define_class("External", rr_cV8_C_Value);
-  references = rb_hash_new();
-  rb_define_const(ExternalClass, "OBJECTS_REFERENCED_FROM_WITHIN_V8", references);
+  ExternalClass = rr_define_class("External", rr_v8_value_class());
   rr_define_singleton_method(ExternalClass, "New", New, 1);
   rr_define_singleton_method(ExternalClass, "Unwrap", Unwrap, 1);
   rr_define_method(ExternalClass, "Value", _Value, 0);
 }
 
 VALUE rr_reflect_v8_external(Handle<Value> external) {
-  return rr_v8_ref_create(ExternalClass, external);
+  return rr_v8_handle_new(ExternalClass, external);
 }
-
-Handle<Value> rr_v8_external_create(VALUE value) {
-  rb_hash_aset(references, rb_obj_id(value), value);
-  Local<Value> external(External::New((void *)value));
-  Persistent<Value> record = Persistent<Value>::New(external);
-  // V8::AdjustAmountOfExternalAllocatedMemory(100000000);
-  record.MakeWeak(NULL, GCWeakReferenceCallback);
-  return external;
-}

data/ext/v8/v8_external.h

@@ -5,5 +5,4 @@
 
 void rr_init_v8_external();
 VALUE rr_reflect_v8_external(v8::Handle<v8::Value> value);
-v8::Handle<v8::Value> rr_v8_external_create(VALUE value);
 #endif

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

@@ -1,14 +1,15 @@
 
-#include "v8_func.h"
-#include "v8_obj.h"
+#include "v8_function.h"
+#include "v8_object.h"
+#include "v8_handle.h"
 
 using namespace v8;
 
 namespace {
   VALUE FunctionClass;
   
-  Local<Function> unwrap(VALUE value) {
-    return V8_Ref_Get<Function>(value);
+  Persistent<Function>& unwrap(VALUE value) {
+    return rr_v8_handle<Function>(value);
   }  
   VALUE Call(VALUE self, VALUE recv, VALUE arguments) {
     HandleScope handles;
@@ -16,9 +17,9 @@ namespace {
       rb_raise(rb_eScriptError, "no open V8 Context in V8::C::Function::Call()");
       return Qnil;
     }
-    Local<Function> function = unwrap(self);
+    Handle<Function> function = unwrap(self);
     Local<Object> thisObj = rr_rb2v8(recv)->ToObject();
-    Handle<Array> args = V8_Ref_Get<Array>(arguments);
+    Handle<Array> args = rr_v8_handle<Array>(arguments);
     int argc = args->Length();
     Handle<Value> argv[argc];
     for (int i = 0; i < argc; i++) {
@@ -29,14 +30,14 @@ namespace {
   
   VALUE NewInstance(VALUE self, VALUE arguments) {
     HandleScope scope;
-    Local<Function> function = unwrap(self);
-    Handle<Array> args = V8_Ref_Get<Array>(arguments);
+    Handle<Function> function = unwrap(self);
+    Handle<Array> args = rr_v8_handle<Array>(arguments);
     int argc = args->Length();
     Handle<Value> argv[argc];
     for (int i = 0; i < argc; i++) {
       argv[i] = args->Get(i);
     }
-    return rr_v8_ref_create(rr_cV8_C_Object, function->NewInstance(argc, argv));
+    return rr_v82rb(function->NewInstance(argc, argv));
   }
   VALUE GetName(VALUE self) {
     HandleScope scope;
@@ -44,7 +45,7 @@ namespace {
   }
   VALUE SetName(VALUE self, VALUE name) {
     HandleScope scope;
-    Local<String> str = V8_Ref_Get<String>(name);
+    Handle<String> str = rr_v8_handle<String>(name);
     unwrap(self)->SetName(str);
     return Qnil;
   }  
@@ -53,8 +54,8 @@ namespace {
   // }
 }
 
-void rr_init_func() {
-  FunctionClass = rr_define_class("Function", rr_cV8_C_Object);
+void rr_init_function() {
+  FunctionClass = rr_define_class("Function", rr_v8_object_class());
   rr_define_method(FunctionClass, "Call", Call, 2);
   rr_define_method(FunctionClass, "NewInstance", NewInstance, 1);
   rr_define_method(FunctionClass, "GetName", GetName, 0);
@@ -63,6 +64,5 @@ void rr_init_func() {
 }
 
 VALUE rr_reflect_v8_function(Handle<Value> value) {
-  Local<Function> function(Function::Cast(*value));
-  return rr_v8_ref_create(FunctionClass, function);
+  return rr_reflect_v8_object_as(value, FunctionClass);
 }