add support for NewInstance()

Author: cowboyd

ext/v8/maybe.h

@@ -66,6 +66,16 @@ namespace rr {
     // the underlying value.
     VALUE object;
   };
+
+  template <class T, class V>
+  class MaybeLocal : public Maybe {
+  public:
+    MaybeLocal(v8::Isolate* isolate, v8::MaybeLocal<V> maybe) {
+      if (!maybe.IsEmpty()) {
+        just(T(isolate, maybe.ToLocalChecked()));
+      }
+    }
+  };
 }
 
 #endif /* RR_MAYBE_H */

ext/v8/object-template.h

@@ -3,13 +3,15 @@
 #define RR_OBJECT_TEMPLATE_H
 
 namespace rr {
-  class ObjectTemplate : Ref<v8::Template> {
+  class ObjectTemplate : Ref<v8::ObjectTemplate> {
   public:
+    ObjectTemplate(VALUE self) : Ref<v8::ObjectTemplate>(self) {}
     ObjectTemplate(v8::Isolate* isolate, v8::Handle<v8::ObjectTemplate> tmpl) :
-      Ref<v8::Template>(isolate, tmpl) {}
+      Ref<v8::ObjectTemplate>(isolate, tmpl) {}
     inline static void Init() {
       ClassBuilder("ObjectTemplate", Template::Class).
         defineSingletonMethod("New", &New).
+        defineMethod("NewInstance", &NewInstance).
         store(&Class);
     }
 
@@ -21,9 +23,15 @@ namespace rr {
       return ObjectTemplate(isolate, v8::ObjectTemplate::New(isolate));
     }
 
-    static VALUE NewInstance(VALUE self , VALUE context) {
-
+    static VALUE NewInstance(VALUE self , VALUE r_context) {
+      ObjectTemplate t(self);
+      Context context(r_context);
+      Isolate isolate(context.getIsolate());
+      Locker lock(isolate);
+      v8::MaybeLocal<v8::Object> object(t->NewInstance());
+      return Object::Maybe(isolate, ObjectTemplate(self)->NewInstance(context));
     }
+
   };
 }
 

ext/v8/object.h

@@ -56,6 +56,7 @@ namespace rr {
 
     inline Object(VALUE value) : Ref<v8::Object>(value) {}
     inline Object(v8::Isolate* isolate, v8::Handle<v8::Object> object) : Ref<v8::Object>(isolate, object) {}
+    typedef MaybeLocal<Object, v8::Object> Maybe;
 
     virtual operator VALUE();
 

spec/c/object_template_spec.rb

@@ -5,9 +5,6 @@
   let(:template) { V8::C::ObjectTemplate::New(@isolate) }
 
   it "can be used to create object instances" do
-    expect(template.NewInstance(@ctx)).to be
-  end
-  it "can be used to create a new object" do
-
+    expect(template.NewInstance(@ctx).FromJust()).to be_instance_of V8::C::Object
   end
 end