add FunctionTemplate#{New,GetFunction}

Author: cowboyd

ext/v8/function-template.h

@@ -0,0 +1,33 @@
+// -*- mode: c++ -*-
+
+namespace rr {
+  class FunctionTemplate : public Ref<v8::FunctionTemplate> {
+  public:
+    FunctionTemplate(VALUE self) : Ref<v8::FunctionTemplate>(self) {}
+    FunctionTemplate(v8::Isolate* isolate, v8::Local<v8::FunctionTemplate> t) :
+      Ref<v8::FunctionTemplate>(isolate, t) {}
+    static inline void Init() {
+      ClassBuilder("FunctionTemplate", Template::Class).
+        defineSingletonMethod("New", &New).
+        defineMethod("GetFunction", &GetFunction).
+        store(&Class);
+    }
+
+    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);
+      Isolate isolate(r_isolate);
+      Locker lock(isolate);
+
+      return FunctionTemplate(isolate, v8::FunctionTemplate::New(isolate));
+    }
+
+    static VALUE GetFunction(VALUE self, VALUE context) {
+      FunctionTemplate t(self);
+      Isolate isolate(t.getIsolate());
+      Locker lock(isolate);
+
+      return Function::Maybe(isolate, t->GetFunction(Context(context)));
+    }
+  };
+}

ext/v8/function.h

@@ -24,6 +24,7 @@ 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) {}
+    typedef MaybeLocal<Function, v8::Function> Maybe;
   };
 }
 

ext/v8/init.cc

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

ext/v8/rr.h

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

ext/v8/template.h

@@ -10,6 +10,7 @@ namespace rr {
     inline static void Init() {
       ClassBuilder("Template").
         defineMethod("Set", &Set).
+        defineMethod("SetAccessorProperty", &SetAccessorProperty).
         store(&Class);
     }
 
@@ -24,6 +25,13 @@ namespace rr {
       Template(self)->Set(Name(name), val, attributes);
       return Qnil;
     }
+
+    static VALUE SetAccessorProperty(int argc, VALUE argv[], VALUE self) {
+      VALUE r_name, r_getter, setter, attributes, access;
+      rb_scan_args(argc, argv, "14", &r_name, &r_getter, &setter, &attributes, &access);
+      Template(self)->SetAccessorProperty(Name(r_name));
+      return Qnil;
+    }
   };
 }
 

lib/v8/c.rb

@@ -0,0 +1,3 @@
+require 'v8/weak'
+require 'v8/c/maybe'
+require 'v8/c/property_attribute'

spec/c/function_template_spec.rb

@@ -0,0 +1,19 @@
+require 'c_spec_helper'
+
+describe V8::C::FunctionTemplate do
+  requires_v8_context
+
+  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
+      end
+      it "has an empty function" do
+        expect(function).to be
+        expect(function.Call(@ctx.Global(), []).StrictEquals(@ctx.Global())).to be true
+      end
+    end
+  end
+end

spec/c/template_spec.rb

@@ -0,0 +1,48 @@
+require 'c_spec_helper'
+
+describe V8::C::Template do
+  requires_v8_context
+
+  let(:key) { V8::C::String::NewFromUtf8(@isolate, "key") }
+  let(:value) { V8::C::Integer::New(@isolate, 23) }
+  let(:template) { V8::C::ObjectTemplate::New(@isolate) }
+
+  describe "Set()" do
+
+    describe "without property attributes" do
+      before do
+        template.Set(key, value)
+      end
+      it "places those values on all new instances" do
+        object = template.NewInstance(@ctx).FromJust()
+        expect(object.Get(@ctx, key).FromJust().Value).to be 23
+      end
+    end
+
+    describe "with property attributes" do
+      before do
+        template.Set(key, value, V8::C::PropertyAttribute::ReadOnly)
+        @object = template.NewInstance(@ctx).FromJust()
+        @object.Set(@ctx, key, V8::C::Integer::New(@isolate, 25))
+      end
+      it "applies those property attributes" do
+        expect(@object.Get(@ctx, key).FromJust().Value).to be 23
+      end
+    end
+  end
+
+  describe "SetAccessorProperty()" do
+    describe "with the bare minimum" do
+      before do
+        template.SetAccessorProperty(key)
+        @object = template.NewInstance(@ctx).FromJust()
+        @object.Set(@ctx, key, value)
+      end
+      it "cannot be shared across contexts" do
+        ctx2 = V8::C::Context::New(@isolate)
+        expect(@object.Get(@ctx, key).FromJust().Value).to be 23
+        expect(@object.Get(ctx2, key).FromJust()).to be_nil
+      end
+    end
+  end
+end