supply a function callback to function template

Author: cowboyd

ext/v8/function-callback.h

@@ -9,55 +9,15 @@ namespace rr {
   class FunctionCallbackInfo : public FunctionCallbackInfoWrapper {
   public:
 
-    inline FunctionCallbackInfo(v8::FunctionCallbackInfo<v8::Value> info, v8::Local<v8::Value> data_) :
-      FunctionCallbackInfoWrapper(info), data(data_) {}
+    inline FunctionCallbackInfo(v8::FunctionCallbackInfo<v8::Value> info) :
+      FunctionCallbackInfoWrapper(info) {}
 
     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());
@@ -90,8 +50,13 @@ namespace rr {
 
     static VALUE Data(VALUE self) {
       FunctionCallbackInfo info(self);
+      Isolate isolate(info->GetIsolate());
       Locker lock(info->GetIsolate());
-      return Value::handleToRubyObject(info->GetIsolate(), info.data);
+
+      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::Value> data(holder->GetHiddenValue(data_key));
+      return Value::handleToRubyObject(isolate, data);
     }
 
     static VALUE GetIsolate(VALUE self) {
@@ -117,8 +82,61 @@ namespace rr {
         defineMethod("GetReturnValue", &GetReturnValue).
         store(&Class);
     }
+  };
+
+  class FunctionCallback {
+  public:
+    FunctionCallback(v8::Isolate* i, VALUE c, VALUE d) : isolate(i), code(c), data(d) {}
+
+   /**
+    * 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.
+    */
+    inline operator v8::Local<v8::Value>() {
+      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, code));
+      holder->SetHiddenValue(data_key, Value(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> callback_key = v8::String::NewFromUtf8(isolate, "rr::callback");
+
+      VALUE code(External::unwrap(holder->GetHiddenValue(callback_key)));
+      Unlocker unlock(info.GetIsolate());
+      rb_funcall(code, rb_intern("call"), 1, (VALUE)FunctionCallbackInfo(info));
+    }
+
+    inline operator v8::FunctionCallback() {
+      if (RTEST(code)) {
+        return &invoke;
+      } else {
+        return 0;
+      }
+    }
 
-    v8::Local<v8::Value> data;
+    v8::Isolate* isolate;
+    VALUE code;
+    VALUE data;
   };
 }
 

ext/v8/function-template.h

@@ -1,6 +1,11 @@
 // -*- mode: c++ -*-
 
+#ifndef RR_FUNCTION_TEMPLATE_H
+#define RR_FUNCTION_TEMPLATE_H
+
 namespace rr {
+
+
   class FunctionTemplate : public Ref<v8::FunctionTemplate> {
   public:
     FunctionTemplate(VALUE self) : Ref<v8::FunctionTemplate>(self) {}
@@ -14,12 +19,16 @@ namespace rr {
     }
 
     static VALUE New(int argc, VALUE argv[], VALUE self) {
-      VALUE r_isolate, callback, data, signature, length;
-      rb_scan_args(argc, argv, "14", &r_isolate, &callback, &data, &signature, &length);
+      VALUE r_isolate, r_callback, r_data, r_signature, r_length;
+      rb_scan_args(argc, argv, "14", &r_isolate, &r_callback, &r_data, &r_signature, &r_length);
       Isolate isolate(r_isolate);
       Locker lock(isolate);
 
-      return FunctionTemplate(isolate, v8::FunctionTemplate::New(isolate));
+      FunctionCallback callback(isolate, r_callback, r_data);
+      Signature signature(r_signature);
+      int length(RTEST(r_length) ? NUM2INT(r_length) : 0);
+
+      return FunctionTemplate(isolate, v8::FunctionTemplate::New(isolate, callback, callback, v8::Local<v8::Signature>(), length));
     }
 
     static VALUE GetFunction(VALUE self, VALUE context) {
@@ -31,3 +40,5 @@ namespace rr {
     }
   };
 }
+
+#endif /* RR_FUNCTION_TEMPLATE_H */

ext/v8/function.cc

@@ -26,15 +26,13 @@ namespace rr {
     Isolate isolate(r_isolate);
     Locker lock(isolate);
 
-    // package up the function's callback data to have bot the code and the data
+    // package up the function's callback data to have both the code and the data
     // parameter.
-    v8::Local<v8::Value> data(FunctionCallbackInfo::wrapData(isolate, r_callback, r_data));
+    FunctionCallback callback(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));
+    return Function(isolate, v8::Function::New(isolate,  callback, callback, length));
   }
 
   VALUE Function::NewInstance(int argc, VALUE argv[], VALUE self) {

ext/v8/init.cc

@@ -34,6 +34,7 @@ extern "C" {
     Template::Init();
     ObjectTemplate::Init();
     FunctionTemplate::Init();
+    Signature::Init();
 
     // Accessor::Init();
     // Invocation::Init();

ext/v8/object-template.h

@@ -31,7 +31,6 @@ namespace rr {
       v8::MaybeLocal<v8::Object> object(t->NewInstance());
       return Object::Maybe(isolate, ObjectTemplate(self)->NewInstance(context));
     }
-
   };
 }
 

ext/v8/rr.h

@@ -55,6 +55,7 @@ inline VALUE not_implemented(const char* message) {
 #include "function-callback.h"
 
 #include "template.h"
+#include "signature.h"
 #include "function-template.h"
 #include "object-template.h"
 

ext/v8/signature.cc

@@ -0,0 +1,13 @@
+#include "rr.h"
+
+namespace rr {
+  VALUE Signature::New(int argc, VALUE argv[], VALUE self) {
+    VALUE r_isolate;
+    VALUE r_receiver;
+    rb_scan_args(argc, argv, "11", &r_isolate, &r_receiver);
+
+    Isolate isolate(r_isolate);
+    Locker lock(isolate);
+    return Signature(isolate, v8::Signature::New(isolate, FunctionTemplate(r_receiver)));
+  }
+}

ext/v8/signature.h

@@ -0,0 +1,22 @@
+// -*- mode: c++ -*-
+#ifndef RR_SIGNATURE_H
+#define RR_SIGNATURE_H
+
+namespace rr {
+  class Signature : public Ref<v8::Signature> {
+  public:
+    Signature(VALUE self) : Ref<v8::Signature>(self) {}
+    Signature(v8::Isolate* i, v8::Local<v8::Signature> s) :
+      Ref<v8::Signature>(i, s) {}
+
+    static void Init() {
+      ClassBuilder("Signature").
+        defineSingletonMethod("New", &New).
+        store(&Class);
+    }
+
+    static VALUE New(int argc, VALUE argv[], VALUE self);
+  };
+}
+
+#endif /* RR_SIGNATURE_H */

spec/c/function_spec.rb

@@ -62,8 +62,9 @@ def call(info)
       end
     end
 
+    let(:data) { V8::C::Object::New(@isolate) }
     let(:callback) { FunctionCallback.new @isolate}
-    let(:fn) { V8::C::Function::New(@isolate, callback)}
+    let(:fn) { V8::C::Function::New(@isolate, callback, data)}
 
     before do
       expect(fn.Call(@ctx.Global(), ["world"]).Utf8Value()).to eql "ohai world"
@@ -75,6 +76,8 @@ def call(info)
       expect(callback.callee.GetIdentityHash()).to eql fn.GetIdentityHash()
       expect(callback.this.GetIdentityHash()).to eql @ctx.Global().GetIdentityHash()
       expect(callback.is_construct_call).to be false
+      expect(callback.data).not_to be_nil
+      expect(callback.data.StrictEquals(data)).to be true
     end
   end
 

spec/c/function_template_spec.rb

@@ -2,10 +2,10 @@
 
 describe V8::C::FunctionTemplate do
   requires_v8_context
+  let(:function) { template.GetFunction(@ctx).FromJust() }
 
   describe "New()" do
     describe "with no arguments" do
-      let(:function) { template.GetFunction(@ctx).FromJust() }
       let(:template) { V8::C::FunctionTemplate::New(@isolate) }
       it "creates an empty template" do
         expect(template).to be
@@ -15,5 +15,21 @@
         expect(function.Call(@ctx.Global(), []).StrictEquals(@ctx.Global())).to be true
       end
     end
+    describe "with a function callback" do
+      let(:data) { V8::C::Integer::New(@isolate, 42) }
+      let(:signature) { V8::C::Signature::New(@isolate) }
+      let(:template) { V8::C::FunctionTemplate::New(@isolate, @callback, data, @signature, 0) }
+      before do
+        @callback = ->(info) do
+          @data = info.Data()
+        end
+        function.Call(@ctx.Global(), [])
+      end
+
+      it "does something" do
+        expect(@data).not_to be_nil
+        expect(@data.Value()).to be 42
+      end
+    end
   end
 end