therubyracer 0.6.3 → 0.7.0.pre

data/ext/v8/v8_str.h

@@ -1,9 +1,11 @@
 #ifndef _RUBY_V8_STR_
 #define _RUBY_V8_STR_
 
-#include "ruby.h" 
+#include "rr.h"
+
+void rr_init_str();
 
 VALUE v8_str_new(VALUE clazz, VALUE str);
 VALUE v8_str_to_s(VALUE self);
-
+VALUE rr_reflect_v8_string(v8::Handle<v8::Value> value);
 #endif

data/ext/v8/v8_template.cpp

@@ -3,13 +3,205 @@
 #include "v8_ref.h"
 #include "v8_func.h"
 #include "v8_template.h"
-#include "converters.h"
+#include "v8_external.h"
+#include "v8_callbacks.h"
 #include "callbacks.h"
+#include "converters.h"
 
 using namespace v8;
 
+namespace {
+
+  VALUE rb_hash_lookup(VALUE hash, const char *key) {
+    return rb_funcall(hash, rb_intern("[]"), 1, rb_str_new2(key));
+  }
+
+  VALUE rb_hash_aset(VALUE hash, const char *key, VALUE value) {
+    return ::rb_hash_aset(hash, rb_str_new2(key), value);
+  }
+
+  Local<Template> tmpl(VALUE self) {
+    return V8_Ref_Get<Template>(self);
+  }
+  Local<ObjectTemplate> obj(VALUE self) {
+    return V8_Ref_Get<ObjectTemplate>(self);
+  }
+  Local<FunctionTemplate> func(VALUE self) {
+    return V8_Ref_Get<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);
+    tmpl(self)->Set(key, data);
+    return Qnil;
+  }
+
+  namespace Obj {
+
+    /**
+     * 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)));
+    }
+
+    /**
+     * Returns the value if the setter intercepts the request.
+     * Otherwise, returns an empty handle.
+     */
+    Handle<Value> RubyNamedPropertySetter(Local<String> property, Local<Value> value, const AccessorInfo& info) {
+      HandleScope handles;
+      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));
+      return rr_rb2v8(result);
+    }
+
+
+    /**
+     * Returns a non-empty handle if the interceptor intercepts the request.
+     * The result is true if the property exists and false otherwise.
+     */
+    Handle<Boolean> RubyNamedPropertyQuery(Local<String> property, const AccessorInfo& info) {
+      HandleScope handles;
+      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));
+      Handle<Value> intercepts = rr_rb2v8(result);
+      return intercepts.IsEmpty() ? Handle<Boolean>() : intercepts->ToBoolean();
+    }
+
+    /**
+     * Returns a non-empty handle if the deleter intercepts the request.
+     * The return value is true if the property could be deleted and false
+     * otherwise.
+     */
+    Handle<Boolean> RubyNamedPropertyDeleter(Local<String> property, const AccessorInfo& info) {
+      HandleScope handles;
+      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));
+      Handle<Value> intercepts = rr_rb2v8(result);
+      return intercepts.IsEmpty() ? Handle<Boolean>() : intercepts->ToBoolean();
+    }
+
+    /**
+     * Returns an array containing the names of the properties the named
+     * property getter intercepts.
+     */
+    Handle<Array> RubyNamedPropertyEnumerator(const AccessorInfo& info) {
+      HandleScope handles;
+      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));
+      Handle<Value> v(rr_rb2v8(result));
+      if (v.IsEmpty()) {
+        return Array::New();
+      } else if (!v->IsArray()) {
+        Local<Array> a = Array::New();
+        a->Set(Integer::New(0), v->ToString());
+        return a;
+      } else {
+        return (Handle<Array>)Array::Cast(*v);
+      }
+    }
+
+    VALUE New(VALUE clazz) {
+      HandleScope handles;
+      return V8_Ref_Create(clazz, ObjectTemplate::New());
+    }
+    VALUE NewInstance(VALUE self) {
+      HandleScope scope;
+      if (!Context::InContext()) {
+        rb_raise(rb_eScriptError, "ObjectTemplate::NewInstance() called without an entered Context");
+        return Qnil;
+      }
+      Local<Object> object(obj(self)->NewInstance());
+      if (object.IsEmpty()) {
+        rb_raise(rb_eFatal, "V8 returned empty handle on call to ObjectTemplate::NewInstance()");
+        return Qnil;
+      }
+      return rr_v82rb(object);
+    }
+    VALUE SetNamedPropertyHandler(VALUE self, VALUE getter, VALUE setter, VALUE query, VALUE deleter, VALUE enumerator) {
+      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)
+      );
+      return Qnil;
+    }
+  }
+
+  namespace Func {
+
+    Handle<Value> RubyInvocationCallback(const Arguments& args) {
+      HandleScope handles;
+      VALUE code = (VALUE)External::Unwrap(args.Data());
+      VALUE rb_args = rr_v82rb(args);
+      VALUE result = rb_funcall(code, rb_intern("call"), 1, rb_args);
+      return rr_rb2v8(result);
+    }
+
+    VALUE New(VALUE function_template) {
+      HandleScope handles;
+      rb_need_block();
+      VALUE code = rb_block_proc();
+      if (NIL_P(code)) {
+        return Qnil;
+      }
+      Local<FunctionTemplate> templ = FunctionTemplate::New(RubyInvocationCallback, rr_v8_external_create(code));
+      return V8_Ref_Create(function_template,templ,code);
+    }
+    VALUE GetFunction(VALUE self) {
+      HandleScope handles;
+      if (!Context::InContext()) {
+        rb_raise(rb_eScriptError, "calls to FunctionTemplate::GetFunction() require a Context to be entered");
+        return Qnil;
+      }
+      return rr_v82rb(func(self)->GetFunction());
+    }
+  }
+}
+
+void rr_init_template() {
+  VALUE Template = rr_define_class("Template");
+  rr_define_method(Template, "Set", Set, 2);
+
+  VALUE ObjectTemplate = rr_define_class("ObjectTemplate", Template);
+  rr_define_singleton_method(ObjectTemplate, "New", Obj::New, 0);
+  rr_define_method(ObjectTemplate, "NewInstance", Obj::NewInstance, 0);
+  rr_define_method(ObjectTemplate, "SetNamedPropertyHandler", Obj::SetNamedPropertyHandler, 5);
+
+  VALUE FunctionTemplate = rr_define_class("FunctionTemplate", Template);
+  rr_define_singleton_method(FunctionTemplate, "New", Func::New, 0);
+  rr_define_method(FunctionTemplate, "GetFunction", Func::GetFunction, 0);
+
+
+}
+
 Local<ObjectTemplate> Racer_Create_V8_ObjectTemplate(VALUE value) {
-  Local<ObjectTemplate> tmpl = ObjectTemplate::New();
+    Local<ObjectTemplate> tmpl = ObjectTemplate::New();
   // tmpl->SetInternalFieldCount(2);
   tmpl->SetNamedPropertyHandler(
     RacerRubyNamedPropertyGetter,
@@ -17,37 +209,7 @@ Local<ObjectTemplate> Racer_Create_V8_ObjectTemplate(VALUE value) {
     0, // RacerRubyNamedPropertyQuery,
     0, // RacerRubyNamedPropertyDeleter,
     RacerRubyNamedPropertyEnumerator,
-    External::Wrap((void *)value)
+    rr_v8_external_create(value)
   );
   return tmpl;
 }
-
-
- 
-VALUE v8_Template_Set(VALUE self, VALUE name, VALUE value) {
-  HandleScope handles;
-  Local<Template> tmpl = V8_Ref_Get<Template>(self);
-  Local<Data> data = V8_Ref_Get<Data>(value);
-  tmpl->Set(RSTRING_PTR(name), data);
-  return Qnil;
-}
-
-VALUE v8_ObjectTemplate_New(VALUE clazz) {
-  HandleScope handles;
-  return V8_Ref_Create(clazz, ObjectTemplate::New());
-}
-
-VALUE v8_FunctionTemplate_New(int argc, VALUE *argv, VALUE self) {
-  VALUE code;
-  rb_scan_args(argc, argv, "00&", &code);
-  HandleScope handles;
-  Local<FunctionTemplate> t = FunctionTemplate::New(RacerRubyInvocationCallback, External::Wrap((void *)code));
-  return V8_Ref_Create(self,t,code);
-}
-
-VALUE v8_FunctionTemplate_GetFunction(VALUE self) {
-  HandleScope handles;
-  Local<FunctionTemplate> t = V8_Ref_Get<FunctionTemplate>(self);
-  return V8_Wrap_Function(t->GetFunction());
-}
-

data/ext/v8/v8_template.h

@@ -1,13 +1,12 @@
 #ifndef _RUBY_V8_TEMPLATE_
 #define _RUBY_V8_TEMPLATE_ 
 
-v8::Local<v8::ObjectTemplate> Racer_Create_V8_ObjectTemplate(VALUE object);
+#include "rr.h"
 
-VALUE v8_Template_Set(VALUE self, VALUE name, VALUE value);
+void rr_init_template();
 
-VALUE v8_ObjectTemplate_New(VALUE clazz);
+v8::Local<v8::ObjectTemplate> Racer_Create_V8_ObjectTemplate(VALUE object);
 
-VALUE v8_FunctionTemplate_New(int argc, VALUE *argv, VALUE self);
-VALUE v8_FunctionTemplate_GetFunction(VALUE self);
+VALUE v8_ObjectTemplate_New(VALUE clazz);
 
 #endif

data/ext/v8/v8_try_catch.cpp

@@ -0,0 +1,99 @@
+#include "rr.h"
+#include "v8_try_catch.h"
+#include "v8_msg.h"
+
+using namespace v8;
+
+namespace {
+  VALUE TryCatchClass;
+
+  struct try_catch {
+    TryCatch *tc;
+    bool alive;
+    try_catch(TryCatch *ptr);
+  };
+
+  try_catch::try_catch(TryCatch *ptr) :tc(ptr) {
+    this->alive = true;
+  }
+  
+  struct kill_try_catch {
+    try_catch *tc;
+    kill_try_catch(try_catch *ptr);
+    ~kill_try_catch();
+  };
+  kill_try_catch::kill_try_catch(try_catch *ptr) : tc(ptr) {}
+  kill_try_catch::~kill_try_catch() {
+    tc->alive = false;
+  }
+  
+  
+  void mark_try_catch(try_catch *tc) {
+    //nothing to mark since the TryCatch object is stack allocated.
+  }
+  
+  void free_try_catch(try_catch *ptr) {
+    delete ptr;
+  }
+  
+  TryCatch *unwrap(VALUE self) {
+    try_catch *ref = 0;
+    Data_Get_Struct(self, struct try_catch, ref);
+    if (ref->alive) {
+      return ref->tc;
+    } else {
+      rb_raise(rb_eScriptError, "out of scope access of %s", RSTRING_PTR(rb_inspect(self)));
+      return false;
+    }
+  }
+  
+  VALUE Try(int argc, VALUE *argv, VALUE self) {
+    if (rb_block_given_p()) {
+      HandleScope scope;
+      TryCatch tc;
+      try_catch *wrapper = new try_catch(&tc);
+      kill_try_catch kill_on_return(wrapper);
+      VALUE rb_ref = Data_Wrap_Struct(TryCatchClass, mark_try_catch, free_try_catch, wrapper);
+      VALUE result = rb_yield(rb_ref);
+      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);
+  rb_funcall(TryCatchClass, rb_intern("private_class_method"), 1, rb_str_new2("new"));
+}

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_value.cpp

@@ -0,0 +1,164 @@
+#include "v8_value.h"
+#include "v8_ref.h"
+#include "converters.h"
+
+using namespace v8;
+namespace {
+  Local<Value> unwrap(VALUE value) {
+    return V8_Ref_Get<Value>(value);
+  }
+  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_cV8_C_Value;
+VALUE rr_cV8_C_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>()));
+
+  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(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(rr_cV8_C_Value, "Equals", Equals, 1);
+  rr_define_method(rr_cV8_C_Value, "StrictEquals", StrictEquals, 1);
+
+  rr_define_method(rr_cV8_C_Value, "BooleanValue", BooleanValue, 0);
+  rr_define_method(rr_cV8_C_Value, "NumberValue", NumberValue, 0);
+}
+
+VALUE rr_wrap_v8_value(Handle<Value>& value) {
+  return V8_Ref_Create(rr_cV8_C_Value, value);
+}