Merge pull request #362 from cowboyd/ruby-defined-function-callbacks

Ruby defined function callbacks

Author: cowboyd

ext/v8/external.cc

@@ -13,31 +13,14 @@ namespace rr {
 
   VALUE External::New(VALUE self, VALUE r_isolate, VALUE object) {
     Isolate isolate(r_isolate);
-
-    // as long as this external is alive within JavaScript, it should not be
-    // garbage collected by Ruby.
-    isolate.retainObject(object);
-
     Locker lock(isolate);
 
-    // create the external.
-    Container* container = new Container(object);
-    v8::Local<v8::External> external(v8::External::New(isolate, (void*)container));
-
-    // next, we create a weak reference to this external so that we can be
-    // notified when V8 is done with it. At that point, we can let Ruby know
-    // that this external is done with it.
-    v8::Global<v8::External>* global(new v8::Global<v8::External>(isolate, external));
-    global->SetWeak<Container>(container, &release, v8::WeakCallbackType::kParameter);
-    container->global = global;
-
-    return External(isolate, external);
+    return External(isolate, wrap(isolate, object));
   }
 
   VALUE External::Value(VALUE self) {
     External external(self);
     Locker lock(external);
-    Container* container((Container*)external->Value());
-    return container->object;
+    return unwrap(external);
   }
 }

ext/v8/external.h

@@ -16,6 +16,33 @@ namespace rr {
     inline External(v8::Isolate* isolate, v8::Handle<v8::Value> value) :
       External(isolate, v8::Handle<v8::External>::Cast<v8::Value>(value)) {}
 
+    static inline v8::Local<v8::External> wrap(Isolate isolate, VALUE object) {
+      // as long as this external is alive within JavaScript, it should not be
+      // garbage collected by Ruby.
+      isolate.retainObject(object);
+
+      // create the external.
+      Container* container = new Container(object);
+      v8::Local<v8::External> external(v8::External::New(isolate, (void*)container));
+
+      // next, we create a weak reference to this external so that we can be
+      // notified when V8 is done with it. At that point, we can let Ruby know
+      // that this external is done with it.
+      v8::Global<v8::External>* global(new v8::Global<v8::External>(isolate, external));
+      global->SetWeak<Container>(container, &release, v8::WeakCallbackType::kParameter);
+      container->global = global;
+
+      return External(isolate, external);
+    }
+    static inline VALUE unwrap(v8::Local<v8::External> external) {
+      Container* container = (Container*)external->Value();
+      return container->object;
+    };
+
+    static inline VALUE unwrap(v8::Local<v8::Value> external) {
+      return unwrap(v8::Local<v8::External>::Cast<v8::Value>(external));
+    }
+
     struct Container {
       Container(VALUE v) : object(v) {}
 

ext/v8/function-callback.h

@@ -0,0 +1,125 @@
+// -*- mode: c++ -*-
+#ifndef RR_FUNCTION_CALLBACK_H
+#define RR_FUNCTION_CALLBACK_H
+
+namespace rr {
+
+  typedef Wrapper<v8::FunctionCallbackInfo<v8::Value>> FunctionCallbackInfoWrapper;
+
+  class FunctionCallbackInfo : public FunctionCallbackInfoWrapper {
+  public:
+
+    inline FunctionCallbackInfo(v8::FunctionCallbackInfo<v8::Value> info, v8::Local<v8::Value> data_) :
+      FunctionCallbackInfoWrapper(info), data(data_) {}
+
+    inline FunctionCallbackInfo(VALUE self) : FunctionCallbackInfoWrapper(self) {}
+
+    inline v8::Local<v8::Value> operator [](int i) {
+      return this->container->content[i];
+    }
+
+    /**
+     * Package up the callback data for this function so that it can
+     * invoke a Ruby callable.
+     *
+     * Each `v8::Function` can have one `v8::Value` associated with it
+     * that is passed to its `v8::FunctionCallback`. To support this
+     * same API from ruby, we take the `Value` passed into the
+     * Function constructor *and* the callback and store them *both*
+     * in a single `v8::Object` which we use for the C++ level
+     * callback data.
+     */
+    static v8::Local<v8::Value> wrapData(v8::Isolate* isolate, VALUE r_callback, VALUE r_data) {
+      v8::Local<v8::Object> holder = v8::Object::New(isolate);
+      v8::Local<v8::String> callback_key = v8::String::NewFromUtf8(isolate, "rr::callback");
+      v8::Local<v8::String> data_key = v8::String::NewFromUtf8(isolate, "rr::data");
+      holder->SetHiddenValue(callback_key, External::wrap(isolate, r_callback));
+      holder->SetHiddenValue(data_key, Value(r_data));
+      return holder;
+    }
+
+    /**
+     * Call the Ruby code associated with this callback.
+     *
+     * Unpack the Ruby code, and the callback data from the C++
+     * callback data, and then invoke that code.
+     *
+     * Note: This function implements the `v8::FunctionCallback` API.
+     */
+    static void invoke(const v8::FunctionCallbackInfo<v8::Value>& info) {
+      v8::Isolate* isolate = info.GetIsolate();
+      v8::Local<v8::Object> holder = v8::Local<v8::Object>::Cast<v8::Value>(info.Data());
+      v8::Local<v8::String> data_key = v8::String::NewFromUtf8(isolate, "rr::data");
+      v8::Local<v8::String> callback_key = v8::String::NewFromUtf8(isolate, "rr::callback");
+      v8::Local<v8::Value> data(holder->GetHiddenValue(data_key));
+
+      VALUE code(External::unwrap(holder->GetHiddenValue(callback_key)));
+      Unlocker unlock(info.GetIsolate());
+      rb_funcall(code, rb_intern("call"), 1, (VALUE)FunctionCallbackInfo(info, data));
+    }
+
+    static VALUE Length(VALUE self) {
+      FunctionCallbackInfo info(self);
+      Locker lock(info->GetIsolate());
+      return INT2FIX(info->Length());
+    }
+
+    static VALUE at(VALUE self, VALUE i) {
+      FunctionCallbackInfo info(self);
+      Locker lock(info->GetIsolate());
+      return Value::handleToRubyObject(info->GetIsolate(), info[NUM2INT(i)]);
+    }
+
+    static VALUE Callee(VALUE self) {
+      FunctionCallbackInfo info(self);
+      Locker lock(info->GetIsolate());
+      return Function(info->GetIsolate(), info->Callee());
+    }
+
+    static VALUE This(VALUE self) {
+      FunctionCallbackInfo info(self);
+      Locker lock(info->GetIsolate());
+      return Object(info->GetIsolate(), info->This());
+    }
+
+    static VALUE IsConstructCall(VALUE self) {
+      FunctionCallbackInfo info(self);
+      Locker lock(info->GetIsolate());
+      return Bool(info->IsConstructCall());
+    }
+
+    static VALUE Data(VALUE self) {
+      FunctionCallbackInfo info(self);
+      Locker lock(info->GetIsolate());
+      return Value::handleToRubyObject(info->GetIsolate(), info.data);
+    }
+
+    static VALUE GetIsolate(VALUE self) {
+      FunctionCallbackInfo info(self);
+      return Isolate(info->GetIsolate());
+    }
+
+    static VALUE GetReturnValue(VALUE self) {
+      FunctionCallbackInfo info(self);
+      Locker lock(info->GetIsolate());
+      return ReturnValue(info->GetReturnValue());
+    }
+
+    static inline void Init() {
+      ClassBuilder("FunctionCallbackInfo").
+        defineMethod("Length", &Length).
+        defineMethod("[]", &at).
+        defineMethod("Callee", &Callee).
+        defineMethod("This", &This).
+        defineMethod("IsConstructCall", &IsConstructCall).
+        defineMethod("Data", &Data).
+        defineMethod("GetIsolate", &GetIsolate).
+        defineMethod("GetReturnValue", &GetReturnValue).
+        store(&Class);
+    }
+
+    v8::Local<v8::Value> data;
+  };
+}
+
+#endif /* RR_FUNCTION_CALLBACK_H */

ext/v8/function.cc

@@ -4,7 +4,7 @@ namespace rr {
 
   void Function::Init() {
     ClassBuilder("Function", Object::Class).
-
+      defineSingletonMethod("New", &New).
       defineMethod("NewInstance", &NewInstance).
       defineMethod("Call", &Call).
       defineMethod("SetName", &SetName).
@@ -20,6 +20,23 @@ namespace rr {
       store(&Class);
   }
 
+  VALUE Function::New(int argc, VALUE argv[], VALUE self) {
+    VALUE r_isolate, r_callback, r_data, r_length;
+    rb_scan_args(argc, argv, "22", &r_isolate, &r_callback, &r_data, &r_length);
+    Isolate isolate(r_isolate);
+    Locker lock(isolate);
+
+    // package up the function's callback data to have bot the code and the data
+    // parameter.
+    v8::Local<v8::Value> data(FunctionCallbackInfo::wrapData(isolate, r_callback, r_data));
+
+    int length = RTEST(r_length) ? NUM2INT(r_length) : 0;
+
+    v8::FunctionCallback callback = &FunctionCallbackInfo::invoke;
+
+    return Function(isolate, v8::Function::New(isolate,  callback, data, length));
+  }
+
   VALUE Function::NewInstance(int argc, VALUE argv[], VALUE self) {
     VALUE args;
     rb_scan_args(argc, argv, "01", &args);

ext/v8/function.h

@@ -1,3 +1,4 @@
+// -*- mode: c++ -*-
 #ifndef RR_FUNCTION
 #define RR_FUNCTION
 
@@ -7,8 +8,9 @@ namespace rr {
   public:
     static void Init();
 
+    static VALUE New(int argc, VALUE argv[], VALUE self);
     static VALUE NewInstance(int argc, VALUE argv[], VALUE self);
-    static VALUE Call(VALUE self, VALUE receiver, VALUE argv);
+    static VALUE Call(VALUE self, VALUE receiver, VALUE arguments);
     static VALUE SetName(VALUE self, VALUE name);
     static VALUE GetName(VALUE self);
     static VALUE GetInferredName(VALUE self);
@@ -23,7 +25,6 @@ namespace rr {
     inline Function(VALUE value) : Ref<v8::Function>(value) {}
     inline Function(v8::Isolate* isolate, v8::Handle<v8::Function> function) : Ref<v8::Function>(isolate, function) {}
   };
-
 }
 
 #endif

ext/v8/init.cc

@@ -23,6 +23,8 @@ extern "C" {
     String::Init();
     Symbol::Init();
     Function::Init();
+    FunctionCallbackInfo::Init();
+    ReturnValue::Init();
     Script::Init();
     ScriptOrigin::Init();
     Array::Init();

ext/v8/locks.h

@@ -1,3 +1,4 @@
+// -*- mode: c++ -*-
 #ifndef RR_LOCKER
 #define RR_LOCKER
 

ext/v8/object.cc

@@ -8,6 +8,7 @@ namespace rr {
 
       defineMethod("Set", &Set).
       defineMethod("Get", &Get).
+      defineMethod("GetIdentityHash", &GetIdentityHash).
 
       store(&Class);
   }
@@ -46,6 +47,13 @@ namespace rr {
     }
   }
 
+  VALUE Object::GetIdentityHash(VALUE self) {
+    Object object(self);
+    Locker lock(object.getIsolate());
+
+    return INT2FIX(object->GetIdentityHash());
+  }
+
   Object::operator VALUE() {
     Locker lock(getIsolate());
 

ext/v8/object.h

@@ -34,7 +34,7 @@ namespace rr {
     // static VALUE HasNamedLookupInterceptor(VALUE self);
     // static VALUE HasIndexedLookupInterceptor(VALUE self);
     // static VALUE TurnOnAccessCheck(VALUE self);
-    // static VALUE GetIdentityHash(VALUE self);
+    static VALUE GetIdentityHash(VALUE self);
     // static VALUE SetHiddenValue(VALUE self, VALUE key, VALUE value);
     // static VALUE GetHiddenValue(VALUE self, VALUE key);
     // static VALUE DeleteHiddenValue(VALUE self, VALUE key);

ext/v8/return-value.h

@@ -0,0 +1,90 @@
+// -*- mode: c++ -*-
+#ifndef RR_RETURN_VALUE_H
+#define RR_RETURN_VALUE_H
+
+namespace rr {
+  typedef Wrapper<v8::ReturnValue<v8::Value>> ReturnValueWrapper;
+
+  class ReturnValue : public ReturnValueWrapper {
+  public:
+    ReturnValue(v8::ReturnValue<v8::Value> value) : ReturnValueWrapper(value) {}
+    ReturnValue(VALUE self) : ReturnValueWrapper(self) {}
+
+    static VALUE Set(VALUE self, VALUE handle) {
+      ReturnValue ret(self);
+      Locker lock(ret->GetIsolate());
+      v8::Local<v8::Value> value((Value(handle)));
+      ret->Set(value);
+      return Qnil;
+    }
+
+    static VALUE Set_bool(VALUE self, VALUE value) {
+      ReturnValue ret(self);
+      Locker lock(ret->GetIsolate());
+      ret->Set((bool)Bool(value));
+      return Qnil;
+    }
+
+    static VALUE Set_double(VALUE self, VALUE value) {
+      ReturnValue ret(self);
+      Locker lock(ret->GetIsolate());
+      ret->Set(NUM2DBL(value));
+      return Qnil;
+    }
+
+    static VALUE Set_int32_t(VALUE self, VALUE i) {
+      ReturnValue ret(self);
+      Locker lock(ret->GetIsolate());
+      ret->Set(NUM2INT(i));
+      return Qnil;
+    }
+
+    static VALUE Set_uint32_t(VALUE self, VALUE i) {
+      ReturnValue ret(self);
+      Locker lock(ret->GetIsolate());
+      ret->Set(NUM2UINT(i));
+      return Qnil;
+    }
+
+    static VALUE SetNull(VALUE self) {
+      ReturnValue ret(self);
+      Locker lock(ret->GetIsolate());
+      ret->SetNull();
+      return Qnil;
+    }
+
+    static VALUE SetUndefined(VALUE self) {
+      ReturnValue ret(self);
+      Locker lock(ret->GetIsolate());
+      ret->SetUndefined();
+      return Qnil;
+    }
+
+    static VALUE SetEmptyString(VALUE self) {
+      ReturnValue ret(self);
+      Locker lock(ret->GetIsolate());
+      ret->SetEmptyString();
+      return Qnil;
+    }
+
+    static VALUE GetIsolate(VALUE self) {
+      ReturnValue ret(self);
+      return Isolate(ret->GetIsolate());
+    }
+
+    static inline void Init() {
+      ClassBuilder("ReturnValue").
+        defineMethod("Set", &Set).
+        defineMethod("Set_bool", &Set_bool).
+        defineMethod("Set_double", &Set_double).
+        defineMethod("Set_int32_t", &Set_int32_t).
+        defineMethod("Set_uint32_t", &Set_uint32_t).
+        defineMethod("SetNull", &SetNull).
+        defineMethod("SetUndefined", &SetUndefined).
+        defineMethod("SetEmptyString", &SetEmptyString).
+        defineMethod("GetIsolate", &GetIsolate).
+        store(&Class);
+    }
+  };
+}
+#endif /* RR_RETURN_VALUE_H */