therubyracer 0.7.1 → 0.7.2.pre

data/Rakefile

@@ -7,7 +7,7 @@ manifest.exclude "lib/v8/*.bundle", "lib/v8/*.so", "ext/**/test/*", "ext/**/test
 Gem::Specification.new do |gemspec|
   $gemspec = gemspec
   gemspec.name = gemspec.rubyforge_project = "therubyracer"
-  gemspec.version = "0.7.1"
+  gemspec.version = "0.7.2.pre"
   gemspec.summary = "Embed the V8 Javascript interpreter into Ruby"
   gemspec.description = "Call javascript code and manipulate javascript objects from ruby. Call ruby code and manipulate ruby objects from javascript."
   gemspec.email = "cowboyd@thefrontside.net"
@@ -33,9 +33,10 @@ task :gemspec => :clean do
 end
 
 task :clean do
-  sh "rm -f ext/v8/Makefile"
   sh "rm -rf pkg"
   sh "rm -rf *.gem"
+  sh "rm -rf ext/v8/Makefile"
+  sh "rm -rf ext/v8/*.bundle ext/v8/*.so"
   sh "rm -rf lib/v8/*.bundle lib/v8/*.so"
 end
 

data/ext/v8/rr.cpp

@@ -7,6 +7,7 @@
 #include "v8_str.h"
 #include "v8_date.h"
 #include "v8_msg.h"
+#include "v8_external.h"
 
 using namespace v8;
 
@@ -25,25 +26,16 @@ VALUE rr_define_const(const char *name, VALUE value) {
   return value;
 }
 
-VALUE rr_str_to_perl_case(VALUE str) {
-  VALUE V8 = rb_define_module("V8");
-  VALUE to = rb_define_module_under(V8, "To");
-  return rb_funcall(to, rb_intern("perl_case"), 1, str);  
-}
-
-VALUE rr_str_to_camel_case(VALUE str) {
-  VALUE V8 = rb_define_module("V8");
-  VALUE to = rb_define_module_under(V8, "To");
-  return rb_funcall(to, rb_intern("camel_case"), 1, str);
-}
-
 VALUE rr_v82rb(Handle<Value> value) {
   if (value.IsEmpty()) {
     return rr_cV8_C_Empty;
   }
-  if (value.IsEmpty() || value->IsUndefined() || value->IsNull()) {
+  if (value->IsUndefined() || value->IsNull()) {
     return Qnil;
   }
+  if (value->IsExternal()) {
+    return rr_reflect_v8_external(value);
+  }
   if (value->IsUint32()) {
     return UINT2NUM(value->Uint32Value());
   }
@@ -74,9 +66,6 @@ VALUE rr_v82rb(Handle<Value> value) {
   return rr_wrap_v8_value(value);  
 }
 
-VALUE rr_v82rb(Handle<Context> value) {
-  return rr_reflect_v8_context(value);
-}
 VALUE rr_v82rb(Handle<Message> value) {
   return rr_reflect_v8_message(value);
 }
@@ -120,7 +109,6 @@ VALUE rr_v82rb(int32_t value) {
   return INT2FIX(value);
 }
 
-
 Handle<Value> rr_rb2v8(VALUE value) {
   switch (TYPE(value)) {
   case T_FIXNUM:
@@ -138,7 +126,6 @@ Handle<Value> rr_rb2v8(VALUE value) {
   case T_DATA:
     return V8_Ref_Get<Value>(value);
   case T_OBJECT:
-    return rr_reflect_rb_object(value);
   case T_CLASS:
   case T_ICLASS:
   case T_MODULE:

data/ext/v8/rr.h

@@ -9,8 +9,6 @@
 
 VALUE rr_define_class(const char *name, VALUE superclass = rb_cObject);
 VALUE rr_define_const(const char *name, VALUE value);
-VALUE rr_str_to_perl_case(VALUE str);
-VALUE rr_str_to_camel_case(VALUE str);
 
 VALUE rr_v82rb(v8::Handle<v8::Value> value);
 VALUE rr_v82rb(v8::Handle<v8::Boolean> value);
@@ -21,7 +19,6 @@ VALUE rr_v82rb(v8::Handle<v8::Function> value);
 VALUE rr_v82rb(v8::Handle<v8::Integer> value);
 VALUE rr_v82rb(v8::Handle<v8::Uint32> value);
 VALUE rr_v82rb(v8::Handle<v8::Int32> value);
-VALUE rr_v82rb(v8::Handle<v8::Context> value);
 VALUE rr_v82rb(v8::Handle<v8::Message> value);
 VALUE rr_v82rb(bool value);
 VALUE rr_v82rb(double value);

data/ext/v8/upstream/Makefile

@@ -5,7 +5,7 @@ V8SRC=build/v8
 LIBV8=build/v8/libv8.a
 LIBV8_G=build/v8/libv8_g.a
 GCC_VERSION=$(shell ruby -e 'puts %x{gcc --version} =~ /(\d)\.(\d)\.\d/ ? $$1 + $$2 : "UNKNOWN"')
-ARCH=$(shell ruby -e "puts ['foo'].pack('p').size == 8 ? 'x64' : 'ia32'")
+ARCH=$(shell ruby build_cpu.rb)
 
 all: $(LIBV8)
 

data/ext/v8/v8_array.cpp

@@ -24,7 +24,7 @@ namespace {
       length = INT2FIX(0);
     }
     HandleScope scope;
-    return V8_Ref_Create(self, Array::New(NUM2INT(length)));
+    return rr_v8_ref_create(self, Array::New(NUM2INT(length)));
   }
   
   VALUE Length(VALUE self) {
@@ -45,12 +45,6 @@ void rr_init_v8_array() {
 
 VALUE rr_reflect_v8_array(Handle<Value> value) {
   Local<Array> array(Array::Cast(*value));
-  Local<Value> peer = array->GetHiddenValue(String::New("TheRubyRacer::RubyObject"));
-  if (peer.IsEmpty()) {
-    VALUE arr = V8_Ref_Create(ArrayClass, array);
-    rb_iv_set(arr, "@context", rr_v82rb(Context::GetEntered()));
-    return arr;
-  } else {
-    return (VALUE)External::Unwrap(peer);
-  }
+  Local<Value> peer = array->GetHiddenValue(String::NewSymbol("TheRubyRacer::RubyObject"));
+  return peer.IsEmpty() ? rr_v8_ref_create(ArrayClass, value) : (VALUE)External::Unwrap(peer);
 }

data/ext/v8/v8_callbacks.cpp

@@ -70,7 +70,7 @@ namespace {
     return rr_v82rb(args(self)->length);
   }
   VALUE Get(VALUE self, VALUE index) {
-    int i = NUM2INT(rb_to_int(index));
+    int i = NUM2INT(index);
     return rr_v82rb(args(self)->values->Get(i));
   }
   VALUE Callee(VALUE self) {

data/ext/v8/v8_cxt.cpp

@@ -1,75 +1,63 @@
 #include "rr.h"
+#include "v8_ref.h"
 #include "v8_cxt.h"
 #include "v8_msg.h"
 #include "v8_template.h"
 #include "v8_external.h"
-#include "converters.h"
 
 using namespace v8;
 
-VALUE V8_C_Context;
-
-//TODO: rename everything to Context_
-//TODO: do the object init from within here
+namespace {
 
+  VALUE ContextClass;
 
-namespace {
-  
   Local<Context> unwrap(VALUE value) {
     return V8_Ref_Get<Context>(value);
   }
-  
-  //TODO: make this scriptable and less static
+
   VALUE New(int argc, VALUE *argv, VALUE self) {
     HandleScope handles;
-    VALUE scope;
-    rb_scan_args(argc,argv, "01", &scope);
-    if (NIL_P(scope)) {
-      Persistent<Context> cxt(Context::New());
-      VALUE ref = V8_Ref_Create(self, cxt);
-      cxt.Dispose();
-      return ref;
-    } else {
-      Persistent<Context> context = Context::New(0, Racer_Create_V8_ObjectTemplate(scope));
-      Context::Scope enter(context);
-      context->Global()->SetHiddenValue(String::New("TheRubyRacer::RubyObject"), rr_v8_external_create(scope));
-      VALUE ref = V8_Ref_Create(self, context, scope);
-      context.Dispose();
-      return ref;
-    }
+    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));
+    Persistent<Context> cxt(Context::New(0, v8_global_template, v8_global_object));
+    VALUE ref = rr_v8_ref_create(self, cxt);
+    cxt.Dispose();
+    return ref;
   }
 
   VALUE InContext(VALUE self) {
     return Context::InContext() ? Qtrue : Qfalse;  
   }
-  
+
   VALUE GetEntered(VALUE self) {
     HandleScope handles;
     if (Context::InContext()) {
       Local<Context> current = Context::GetEntered();
-      return V8_Ref_Create(self, current);    
+      return rr_v8_ref_create(self, current);    
     } else {
       return Qnil;
     }
   }
-  
+
   VALUE Global(VALUE self) {
     HandleScope handles;
     return rr_v82rb(unwrap(self)->Global());
   }  
-  
+
   VALUE Enter(VALUE self) {
     HandleScope handles;
     unwrap(self)->Enter();
     return self;
   }
-  
+
   VALUE Exit(VALUE self) {
     HandleScope handles;
     unwrap(self)->Exit();
     return self;
   }
-  
+
   VALUE IsEntered(VALUE self) {
     HandleScope handles;
     if (Context::InContext()) {
@@ -81,7 +69,7 @@ namespace {
 }
 
 void rr_init_cxt() {
-  VALUE ContextClass = V8_C_Context = rr_define_class("Context");
+  ContextClass = rr_define_class("Context");
   rr_define_singleton_method(ContextClass, "New", New, -1);
   rr_define_singleton_method(ContextClass, "InContext", InContext, 0);
   rr_define_singleton_method(ContextClass, "GetEntered", GetEntered, 0);
@@ -91,8 +79,3 @@ void rr_init_cxt() {
   rr_define_method(ContextClass, "IsEntered", IsEntered, 0);
 }
 
-VALUE rr_reflect_v8_context(Handle<Context> value) {
-  return V8_Ref_Create(V8_C_Context, value);
-}
-
-

data/ext/v8/v8_cxt.h

@@ -1,13 +1,6 @@
 #ifndef _RUBY_V8_CXT_
 #define _RUBY_V8_CXT_ 
 
-#include "ruby.h"
-#include "v8.h"
-#include "v8_ref.h"
-
-extern VALUE V8_C_Context;
-
 void rr_init_cxt();
-VALUE rr_reflect_v8_context(v8::Handle<v8::Context> value);
 
 #endif

data/ext/v8/v8_exception.cpp

@@ -51,5 +51,6 @@ void rr_init_v8_exception() {
   rr_define_singleton_method(ExceptionClass, "Error", Error, 1);
   
   v8::V8::SetFatalErrorHandler(fatal);
-  signal(SIGSEGV, segfault);
+  //comment this in for debugging.
+  // signal(SIGSEGV, segfault);
 }

data/ext/v8/v8_external.cpp

@@ -1,28 +1,31 @@
-#include "v8_external.h"
 #include "rr.h"
+#include "v8_external.h"
+
 #include "v8_ref.h"
+#include "v8_value.h"
 using namespace v8;
 
 namespace {
   VALUE ExternalClass;
   VALUE references;
-  VALUE _Value(VALUE self) {
-    HandleScope scope;
-    return (VALUE)V8_Ref_Get<External>(self)->Value();
-  }
-  VALUE Wrap(VALUE rbclass, VALUE value) {
+
+  VALUE New(VALUE rbclass, VALUE value) {
     HandleScope scope;
     return rr_v8_ref_create(rbclass, rr_v8_external_create(value));
   }
   VALUE Unwrap(VALUE self, VALUE value) {
+    HandleScope scope;
     if (rb_obj_is_kind_of(value, self)) {
-      return _Value(value);
+      return (VALUE)External::Unwrap(V8_Ref_Get<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;
     }
   }
-
+  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));
@@ -32,17 +35,21 @@ namespace {
 }
 
 void rr_init_v8_external() {
-  ExternalClass = rr_define_class("External");
+  ExternalClass = rr_define_class("External", rr_cV8_C_Value);
   references = rb_hash_new();
   rb_define_const(ExternalClass, "OBJECTS_REFERENCED_FROM_WITHIN_V8", references);
-  rr_define_singleton_method(ExternalClass, "Wrap", Wrap, 1);
+  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);
+}
+
 Handle<Value> rr_v8_external_create(VALUE value) {
   rb_hash_aset(references, rb_obj_id(value), value);
-  Local<Value> external(External::Wrap((void *)value));
+  Local<Value> external(External::New((void *)value));
   Persistent<Value> record = Persistent<Value>::New(external);
   // V8::AdjustAmountOfExternalAllocatedMemory(100000000);
   record.MakeWeak(NULL, GCWeakReferenceCallback);

data/ext/v8/v8_external.h

@@ -4,5 +4,6 @@
 #include "rr.h"
 
 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

@@ -1,12 +1,9 @@
 
-#include "converters.h"
 #include "v8_func.h"
 #include "v8_obj.h"
 
 using namespace v8;
 
-VALUE rr_cV8_C_Function;
-
 namespace {
   VALUE FunctionClass;
   
@@ -39,7 +36,7 @@ namespace {
     for (int i = 0; i < argc; i++) {
       argv[i] = args->Get(i);
     }
-    return rr_v82rb(function->NewInstance(argc, argv));
+    return rr_v8_ref_create(rr_cV8_C_Object, function->NewInstance(argc, argv));
   }
   VALUE GetName(VALUE self) {
     return rr_v82rb(unwrap(self)->GetName());
@@ -65,5 +62,5 @@ void rr_init_func() {
 
 VALUE rr_reflect_v8_function(Handle<Value> value) {
   Local<Function> function(Function::Cast(*value));
-  return V8_Ref_Create(FunctionClass, function);
+  return rr_v8_ref_create(FunctionClass, function);
 }

data/ext/v8/v8_func.h

@@ -5,8 +5,6 @@
 #include "v8.h"
 #include "v8_ref.h"
 
-extern VALUE rr_cV8_C_Function;
-
 void rr_init_func();
 
 VALUE rr_reflect_v8_function(v8::Handle<v8::Value> value);

data/ext/v8/v8_msg.cpp

@@ -1,4 +1,3 @@
-#include "converters.h"
 #include "v8_msg.h"
 #include "v8_ref.h"
 
@@ -58,6 +57,6 @@ void rr_init_msg() {
 }
 
 VALUE rr_reflect_v8_message(Handle<Message> value) {
-  return V8_Ref_Create(MessageClass, value);
+  return rr_v8_ref_create(MessageClass, value);
 }
 

data/ext/v8/v8_obj.cpp

@@ -3,7 +3,6 @@
 #include "v8_value.h"
 #include "v8_template.h"
 #include "v8_external.h"
-#include "converters.h"
 
 using namespace v8;
 
@@ -27,13 +26,13 @@ namespace {
     }
   }
   
-  VALUE New(VALUE clazz) {
+  VALUE New(VALUE rbclass) {
     HandleScope handles;
     if (!Context::InContext()) {
       rb_raise(rb_eScriptError, "Object::New() called without an entered Context");
       return Qnil;
     }
-    return V8_Ref_Create(clazz, Object::New());
+    return rr_v8_ref_create(rbclass, Object::New());
   }
   
   VALUE Set(VALUE self, VALUE key, VALUE value) {
@@ -59,8 +58,6 @@ namespace {
     } else {
       rb_raise(rb_eScriptError, "Object::SetHiddenValue() called without an entered Context");
     }
-    //TODO: need to store a reference here? what's the best way
-    // rr_v8_ref_setref(self, "RubyPeer", )
     return Qnil;
   }
   VALUE GetHiddenValue(VALUE self, VALUE key) {
@@ -71,7 +68,6 @@ namespace {
 
 void rr_init_obj() {
   rr_cV8_C_Object = rr_define_class("Object", rr_cV8_C_Value);
-  rb_define_attr(rr_cV8_C_Object, "context", 1, 0);
   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);
@@ -82,13 +78,7 @@ void rr_init_obj() {
 
 VALUE rr_reflect_v8_object(Handle<Value> value) {
   Local<Object> object(Object::Cast(*value));
-  Local<Value> peer = object->GetHiddenValue(String::New("TheRubyRacer::RubyObject"));
+  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);
 }
 
-
-v8::Handle<v8::Value> rr_reflect_rb_object(VALUE value) {
-  Local<Object> o = Racer_Create_V8_ObjectTemplate(value)->NewInstance();
-  o->SetHiddenValue(String::New("TheRubyRacer::RubyObject"), rr_v8_external_create(value));
-  return o;  
-}