Add Object::GetPrototype and Object::SetPrototype

Author: georgyangelov

ext/v8/object.cc

@@ -18,6 +18,8 @@ namespace rr {
       defineMethod("GetOwnPropertyDescriptor", &GetOwnPropertyDescriptor).
       defineMethod("GetPropertyNames", &GetPropertyNames).
       defineMethod("GetOwnPropertyNames", &GetOwnPropertyNames).
+      defineMethod("GetPrototype", &GetPrototype).
+      defineMethod("SetPrototype", &SetPrototype).
 
       store(&Class);
   }
@@ -183,6 +185,23 @@ namespace rr {
     return Array::Maybe(object.getIsolate(), object->GetOwnPropertyNames(Context(r_context)));
   }
 
+  VALUE Object::GetPrototype(VALUE self) {
+    Object object(self);
+    Locker lock(object);
+
+    return Value(object.getIsolate(), object->GetPrototype());
+  }
+
+  VALUE Object::SetPrototype(VALUE self, VALUE r_context, VALUE prototype) {
+    Object object(self);
+    Locker lock(object);
+
+    return Bool::Maybe(object->SetPrototype(
+      Context(r_context),
+      *Value(prototype)
+    ));
+  }
+
   Object::operator VALUE() {
     Isolate isolate(getIsolate());
     Locker lock(isolate);

ext/v8/object.h

@@ -23,6 +23,8 @@ namespace rr {
     static VALUE GetOwnPropertyDescriptor(VALUE self, VALUE r_context, VALUE key);
     static VALUE GetPropertyNames(VALUE self, VALUE r_context);
     static VALUE GetOwnPropertyNames(VALUE self, VALUE r_context);
+    static VALUE GetPrototype(VALUE self);
+    static VALUE SetPrototype(VALUE self, VALUE r_context, VALUE prototype);
 
     inline Object(VALUE value) : Ref<v8::Object>(value) {}
     inline Object(v8::Isolate* isolate, v8::Handle<v8::Object> object) : Ref<v8::Object>(isolate, object) {}

spec/c/object_spec.rb

@@ -250,34 +250,36 @@
     end
   end
 
-  # TODO: Enable this when the methods are implemented in the extension
-  # it 'can retrieve all property names' do
-  #   o = V8::C::Object.New
-  #   o.Set(V8::C::String.New('foo'), V8::C::String.New('bar'))
-  #   o.Set(V8::C::String.New('baz'), V8::C::String.New('bang'))
-  #
-  #   names = o.GetPropertyNames()
-  #   names.Length().should eql 2
-  #   names.Get(0).Utf8Value().should eql 'foo'
-  #   names.Get(1).Utf8Value().should eql 'baz'
-  # end
-  #
-  # it 'can set an accessor from ruby' do
-  #   o = V8::C::Object.New
-  #   property = V8::C::String.New('statement')
-  #   callback_data = V8::C::String.New('I am Legend')
-  #   left = V8::C::String.New('Yo! ')
-  #   getter = proc do |name, info|
-  #     info.This().StrictEquals(o).should be_true
-  #     info.Holder().StrictEquals(o).should be_true
-  #     V8::C::String::Concat(left, info.Data())
-  #   end
-  #   setter = proc do |name, value, info|
-  #     left = value
-  #   end
-  #   o.SetAccessor(property, getter, setter, callback_data)
-  #   o.Get(property).Utf8Value().should eql 'Yo! I am Legend'
-  #   o.Set(property, V8::C::String::New('Bro! '))
-  #   o.Get(property).Utf8Value().should eql 'Bro! I am Legend'
-  # end
+  context 'with prototypes' do
+    let(:o) { V8::C::Object.New(@isolate) }
+    let(:prototype) { V8::C::Object.New(@isolate) }
+    let(:prototype_key) { V8::C::String.NewFromUtf8(@isolate, 'foo') }
+    let(:o_key) { V8::C::String.NewFromUtf8(@isolate, 'bar') }
+
+    before do
+      expect(prototype.Set(@ctx, prototype_key, prototype_key)).to be_successful
+      expect(o.Set(@ctx, o_key, o_key)).to be_successful
+
+      expect(o.SetPrototype(@ctx, prototype)).to be_successful
+    end
+
+    it 'can set the object prototype' do
+      expect(o.Get(@ctx, prototype_key)).to strict_eq prototype_key
+    end
+
+    it 'can enumerate only own properties' do
+      names = o.GetOwnPropertyNames(@ctx)
+
+      expect(names).to be_successful
+      expect(names.FromJust.Get(@ctx, 0)).to v8_eq o_key
+    end
+
+    it 'can enumerate all properties' do
+      names = o.GetPropertyNames(@ctx)
+
+      expect(names).to be_successful
+      expect(names.FromJust.Get(@ctx, 0)).to v8_eq o_key
+      expect(names.FromJust.Get(@ctx, 1)).to v8_eq prototype_key
+    end
+  end
 end