Skip to content
This repository was archived by the owner on Dec 4, 2023. It is now read-only.

Commit 07352d6

Browse files
georgyangelovgeorgyangelov
committed
Implement Object.SetAccessor, Has and Delete
1 parent 905037e commit 07352d6

9 files changed

Lines changed: 387 additions & 55 deletions

File tree

‎ext/v8/enums.h‎

Lines changed: 27 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,27 @@
1+
#include "rr.h"
2+
3+
namespace rr {
4+
5+
class Enums {
6+
public:
7+
static void Init() {
8+
ClassBuilder("AccessControl").
9+
defineConst("DEFAULT", INT2FIX(v8::DEFAULT)).
10+
defineConst("ALL_CAN_READ", INT2FIX(v8::ALL_CAN_READ)).
11+
defineConst("ALL_CAN_WRITE", INT2FIX(v8::ALL_CAN_WRITE)).
12+
defineConst("PROHIBITS_OVERWRITING", INT2FIX(v8::PROHIBITS_OVERWRITING));
13+
14+
ClassBuilder("PropertyAttribute").
15+
defineConst("None", INT2FIX(v8::None)).
16+
defineConst("ReadOnly", INT2FIX(v8::ReadOnly)).
17+
defineConst("DontEnum", INT2FIX(v8::DontEnum)).
18+
defineConst("DontDelete", INT2FIX(v8::DontDelete));
19+
}
20+
21+
template <class T>
22+
static T fromRubyValue(VALUE rb_int) {
23+
return (T)NUM2INT(rb_int);
24+
}
25+
};
26+
27+
};

‎ext/v8/init.cc‎

Lines changed: 3 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -9,6 +9,7 @@ using namespace rr;
99
extern "C" {
1010
void Init_init() {
1111
V8::Init();
12+
Enums::Init();
1213
Isolate::Init();
1314
Handles::Init();
1415
Context::Init();
@@ -26,13 +27,14 @@ extern "C" {
2627
Symbol::Init();
2728
Function::Init();
2829
FunctionCallbackInfo::Init();
30+
PropertyCallbackInfo::Init();
31+
PropertyCallbackInfoVoid::Init();
2932
ReturnValue::Init();
3033
Script::Init();
3134
ScriptOrigin::Init();
3235
Array::Init();
3336
External::Init();
3437

35-
// Accessor::Init();
3638
// Invocation::Init();
3739
// Signature::Init();
3840
// Date::Init();

‎ext/v8/object.cc‎

Lines changed: 47 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1,14 +1,16 @@
11
#include "rr.h"
22

33
namespace rr {
4-
54
void Object::Init() {
65
ClassBuilder("Object", Value::Class).
76
defineSingletonMethod("New", &New).
87

98
defineMethod("Set", &Set).
109
defineMethod("Get", &Get).
1110
defineMethod("GetIdentityHash", &GetIdentityHash).
11+
defineMethod("Has", &Has).
12+
defineMethod("Delete", &Delete).
13+
defineMethod("SetAccessor", &SetAccessor).
1214

1315
store(&Class);
1416
}
@@ -49,11 +51,53 @@ namespace rr {
4951

5052
VALUE Object::GetIdentityHash(VALUE self) {
5153
Object object(self);
52-
Locker lock(object.getIsolate());
54+
Locker lock(object);
5355

5456
return INT2FIX(object->GetIdentityHash());
5557
}
5658

59+
VALUE Object::Has(VALUE self, VALUE r_context, VALUE key) {
60+
Object object(self);
61+
Locker lock(object);
62+
63+
if (rb_obj_is_kind_of(key, rb_cNumeric)) {
64+
return Bool::Maybe(object->Has(Context(r_context), Uint32_t(key)));
65+
} else {
66+
return Bool::Maybe(object->Has(Context(r_context), *Value(key)));
67+
}
68+
}
69+
70+
VALUE Object::Delete(VALUE self, VALUE r_context, VALUE key) {
71+
Object object(self);
72+
Locker lock(object);
73+
74+
if (rb_obj_is_kind_of(key, rb_cNumeric)) {
75+
return Bool::Maybe(object->Delete(Context(r_context), Uint32_t(key)));
76+
} else {
77+
return Bool::Maybe(object->Delete(Context(r_context), *Value(key)));
78+
}
79+
}
80+
81+
VALUE Object::SetAccessor(int argc, VALUE* argv, VALUE self) {
82+
VALUE r_context, name, getter, setter, data, settings, attribute;
83+
rb_scan_args(argc, argv, "52", &r_context, &name, &getter, &setter, &data, &settings, &attribute);
84+
85+
Object object(self);
86+
Context context(r_context);
87+
Isolate isolate(object.getIsolate());
88+
Locker lock(isolate);
89+
90+
return Bool::Maybe(object->SetAccessor(
91+
context,
92+
Name(name),
93+
&PropertyCallbackInfo::invokeGetter,
94+
RTEST(setter) ? &PropertyCallbackInfoVoid::invokeSetter : 0,
95+
v8::MaybeLocal<v8::Value>(PropertyCallbackInfo::wrapData(isolate, getter, setter, data)),
96+
RTEST(settings) ? Enums::fromRubyValue<v8::AccessControl>(settings) : v8::DEFAULT,
97+
RTEST(attribute) ? Enums::fromRubyValue<v8::PropertyAttribute>(attribute) : v8::None
98+
));
99+
}
100+
57101
Object::operator VALUE() {
58102
Isolate isolate(getIsolate());
59103
Locker lock(isolate);
@@ -89,4 +133,5 @@ namespace rr {
89133

90134
return Ref<v8::Object>::operator VALUE();
91135
}
136+
92137
}

‎ext/v8/object.h‎

Lines changed: 7 additions & 46 deletions
Original file line numberDiff line numberDiff line change
@@ -6,53 +6,14 @@ namespace rr {
66
class Object : public Ref<v8::Object> {
77
public:
88
static void Init();
9-
static VALUE New(VALUE self, VALUE isolate);
10-
static VALUE Set(VALUE self, VALUE context, VALUE key, VALUE value);
11-
// static VALUE ForceSet(VALUE self, VALUE key, VALUE value);
12-
static VALUE Get(VALUE self, VALUE context, VALUE key);
13-
// static VALUE GetPropertyAttributes(VALUE self, VALUE key);
14-
// static VALUE Has(VALUE self, VALUE key);
15-
// static VALUE Delete(VALUE self, VALUE key);
16-
// static VALUE ForceDelete(VALUE self, VALUE key);
17-
// static VALUE SetAccessor(int argc, VALUE* argv, VALUE self);
18-
// static VALUE GetPropertyNames(VALUE self);
19-
// static VALUE GetOwnPropertyNames(VALUE self);
20-
// static VALUE GetPrototype(VALUE self);
21-
// static VALUE SetPrototype(VALUE self, VALUE prototype);
22-
// static VALUE FindInstanceInPrototypeChain(VALUE self, VALUE impl);
23-
// static VALUE ObjectProtoToString(VALUE self);
24-
// static VALUE GetConstructorName(VALUE self);
25-
// static VALUE InternalFieldCount(VALUE self);
26-
// static VALUE GetInternalField(VALUE self, VALUE idx);
27-
// static VALUE SetInternalField(VALUE self, VALUE idx, VALUE value);
28-
// static VALUE HasOwnProperty(VALUE self, VALUE key);
29-
// static VALUE HasRealNamedProperty(VALUE self, VALUE key);
30-
// static VALUE HasRealIndexedProperty(VALUE self, VALUE idx);
31-
// static VALUE HasRealNamedCallbackProperty(VALUE self, VALUE key);
32-
// static VALUE GetRealNamedPropertyInPrototypeChain(VALUE self, VALUE key);
33-
// static VALUE GetRealNamedProperty(VALUE self, VALUE key);
34-
// static VALUE HasNamedLookupInterceptor(VALUE self);
35-
// static VALUE HasIndexedLookupInterceptor(VALUE self);
36-
// static VALUE TurnOnAccessCheck(VALUE self);
9+
10+
static VALUE New(VALUE self, VALUE rb_isolate);
11+
static VALUE Set(VALUE self, VALUE r_context, VALUE key, VALUE value);
12+
static VALUE Get(VALUE self, VALUE r_context, VALUE key);
3713
static VALUE GetIdentityHash(VALUE self);
38-
// static VALUE SetHiddenValue(VALUE self, VALUE key, VALUE value);
39-
// static VALUE GetHiddenValue(VALUE self, VALUE key);
40-
// static VALUE DeleteHiddenValue(VALUE self, VALUE key);
41-
// static VALUE IsDirty(VALUE self);
42-
// static VALUE Clone(VALUE self);
43-
// static VALUE CreationContext(VALUE self);
44-
// static VALUE SetIndexedPropertiesToPixelData(VALUE self, VALUE data, VALUE length);
45-
// static VALUE GetIndexedPropertiesPixelData(VALUE self);
46-
// static VALUE HasIndexedPropertiesInPixelData(VALUE self);
47-
// static VALUE GetIndexedPropertiesPixelDataLength(VALUE self);
48-
// static VALUE SetIndexedPropertiesToExternalArrayData(VALUE self);
49-
// static VALUE HasIndexedPropertiesInExternalArrayData(VALUE self);
50-
// static VALUE GetIndexedPropertiesExternalArrayData(VALUE self);
51-
// static VALUE GetIndexedPropertiesExternalArrayDataType(VALUE self);
52-
// static VALUE GetIndexedPropertiesExternalArrayDataLength(VALUE self);
53-
// static VALUE IsCallable(VALUE self);
54-
// static VALUE CallAsFunction(VALUE self, VALUE recv, VALUE argv);
55-
// static VALUE CallAsConstructor(VALUE self, VALUE argv);
14+
static VALUE Has(VALUE self, VALUE r_context, VALUE key);
15+
static VALUE Delete(VALUE self, VALUE r_context, VALUE key);
16+
static VALUE SetAccessor(int argc, VALUE* argv, VALUE self);
5617

5718
inline Object(VALUE value) : Ref<v8::Object>(value) {}
5819
inline Object(v8::Isolate* isolate, v8::Handle<v8::Object> object) : Ref<v8::Object>(isolate, object) {}

‎ext/v8/property-callback-void.h‎

Lines changed: 84 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,84 @@
1+
// -*- mode: c++ -*-
2+
#ifndef RR_PROPERTY_CALLBACK_VOID_H
3+
#define RR_PROPERTY_CALLBACK_VOID_H
4+
5+
namespace rr {
6+
7+
typedef Wrapper<v8::PropertyCallbackInfo<void>> PropertyCallbackInfoVoidWrapper;
8+
9+
class PropertyCallbackInfoVoid : public PropertyCallbackInfoVoidWrapper {
10+
public:
11+
12+
inline PropertyCallbackInfoVoid(v8::PropertyCallbackInfo<void> info) :
13+
PropertyCallbackInfoVoidWrapper(info) {}
14+
15+
inline PropertyCallbackInfoVoid(VALUE self) : PropertyCallbackInfoVoidWrapper(self) {}
16+
17+
/**
18+
* Call the Ruby code associated with this callback.
19+
*
20+
* Unpack the Ruby code, and the callback data from the C++
21+
* callback data, and then invoke that code.
22+
*
23+
* Note: This function implements the `v8::AccessorNameSetterCallback` API.
24+
*/
25+
static void invokeSetter(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<void>& info) {
26+
v8::Isolate* isolate = info.GetIsolate();
27+
28+
v8::Local<v8::Object> holder = v8::Local<v8::Object>::Cast<v8::Value>(info.Data());
29+
v8::Local<v8::String> callback_key = v8::String::NewFromUtf8(isolate, "rr::setter");
30+
31+
VALUE code(External::unwrap(holder->GetHiddenValue(callback_key)));
32+
33+
VALUE rb_property;
34+
if (property->IsSymbol()) {
35+
rb_property = Symbol(isolate, v8::Local<v8::Symbol>::Cast(property));
36+
} else {
37+
rb_property = String(isolate, property->ToString());
38+
}
39+
40+
Unlocker unlock(info.GetIsolate());
41+
rb_funcall(
42+
code, rb_intern("call"), 3,
43+
rb_property,
44+
(VALUE)Value::handleToRubyObject(isolate, value),
45+
(VALUE)PropertyCallbackInfoVoid(info)
46+
);
47+
}
48+
49+
static VALUE This(VALUE self) {
50+
PropertyCallbackInfoVoid info(self);
51+
Locker lock(info->GetIsolate());
52+
return Object(info->GetIsolate(), info->This());
53+
}
54+
55+
static VALUE Data(VALUE self) {
56+
PropertyCallbackInfoVoid info(self);
57+
Isolate isolate(info->GetIsolate());
58+
Locker lock(isolate);
59+
60+
v8::Local<v8::Object> holder = v8::Local<v8::Object>::Cast<v8::Value>(info->Data());
61+
v8::Local<v8::String> data_key = v8::String::NewFromUtf8(isolate, "rr::data");
62+
v8::Local<v8::Value> data(holder->GetHiddenValue(data_key));
63+
64+
return Value::handleToRubyObject(info->GetIsolate(), data);
65+
}
66+
67+
static VALUE GetIsolate(VALUE self) {
68+
PropertyCallbackInfoVoid info(self);
69+
return Isolate(info->GetIsolate());
70+
}
71+
72+
static inline void Init() {
73+
ClassBuilder("PropertyCallbackVoidInfo").
74+
defineMethod("This", &This).
75+
defineMethod("Data", &Data).
76+
defineMethod("GetIsolate", &GetIsolate).
77+
store(&Class);
78+
}
79+
80+
v8::Local<v8::Value> data;
81+
};
82+
}
83+
84+
#endif /* RR_PROPERTY_CALLBACK_VOID_H */

‎ext/v8/property-callback.h‎

Lines changed: 107 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,107 @@
1+
// -*- mode: c++ -*-
2+
#ifndef RR_PROPERTY_CALLBACK_H
3+
#define RR_PROPERTY_CALLBACK_H
4+
5+
namespace rr {
6+
7+
typedef Wrapper<v8::PropertyCallbackInfo<v8::Value>> PropertyCallbackInfoWrapper;
8+
9+
class PropertyCallbackInfo : public PropertyCallbackInfoWrapper {
10+
public:
11+
12+
inline PropertyCallbackInfo(v8::PropertyCallbackInfo<v8::Value> info) :
13+
PropertyCallbackInfoWrapper(info) {}
14+
15+
inline PropertyCallbackInfo(VALUE self) : PropertyCallbackInfoWrapper(self) {}
16+
17+
/**
18+
* Package up the callback data for this object so that it can
19+
* invoke Ruby callables.
20+
*
21+
* Each accessor can have one `v8::Value` associated with it
22+
* that is passed to the `SetAccessor` method. To support this
23+
* same API from ruby, we take the passed data constructor *and*
24+
* the callbacks and store them *both* in a single `v8::Object`
25+
* which we use for the C++ level callback data.
26+
*/
27+
static v8::Local<v8::Value> wrapData(v8::Isolate* isolate, VALUE r_getter, VALUE r_setter, VALUE r_data) {
28+
v8::Local<v8::Object> holder = v8::Object::New(isolate);
29+
30+
v8::Local<v8::String> getter_key = v8::String::NewFromUtf8(isolate, "rr::getter");
31+
v8::Local<v8::String> setter_key = v8::String::NewFromUtf8(isolate, "rr::setter");
32+
v8::Local<v8::String> data_key = v8::String::NewFromUtf8(isolate, "rr::data");
33+
34+
holder->SetHiddenValue(getter_key, External::wrap(isolate, r_getter));
35+
holder->SetHiddenValue(setter_key, External::wrap(isolate, r_setter));
36+
holder->SetHiddenValue(data_key, Value(r_data));
37+
38+
return holder;
39+
}
40+
41+
/**
42+
* Call the Ruby code associated with this callback.
43+
*
44+
* Unpack the Ruby code, and the callback data from the C++
45+
* callback data, and then invoke that code.
46+
*
47+
* Note: This function implements the `v8::AccessorNameGetterCallback` API.
48+
*/
49+
static void invokeGetter(v8::Local<v8::Name> property, const v8::PropertyCallbackInfo<v8::Value>& info) {
50+
v8::Isolate* isolate = info.GetIsolate();
51+
v8::Local<v8::Object> holder = v8::Local<v8::Object>::Cast<v8::Value>(info.Data());
52+
v8::Local<v8::String> callback_key = v8::String::NewFromUtf8(isolate, "rr::getter");
53+
54+
VALUE code(External::unwrap(holder->GetHiddenValue(callback_key)));
55+
56+
VALUE rb_property;
57+
if (property->IsSymbol()) {
58+
rb_property = Symbol(isolate, v8::Local<v8::Symbol>::Cast(property));
59+
} else {
60+
rb_property = String(isolate, property->ToString());
61+
}
62+
63+
Unlocker unlock(info.GetIsolate());
64+
rb_funcall(code, rb_intern("call"), 2, rb_property, (VALUE)PropertyCallbackInfo(info));
65+
}
66+
67+
static VALUE This(VALUE self) {
68+
PropertyCallbackInfo info(self);
69+
Locker lock(info->GetIsolate());
70+
return Object(info->GetIsolate(), info->This());
71+
}
72+
73+
static VALUE Data(VALUE self) {
74+
PropertyCallbackInfo info(self);
75+
Isolate isolate(info->GetIsolate());
76+
Locker lock(isolate);
77+
78+
v8::Local<v8::Object> holder = v8::Local<v8::Object>::Cast<v8::Value>(info->Data());
79+
v8::Local<v8::String> data_key = v8::String::NewFromUtf8(isolate, "rr::data");
80+
v8::Local<v8::Value> data(holder->GetHiddenValue(data_key));
81+
82+
return Value::handleToRubyObject(info->GetIsolate(), data);
83+
}
84+
85+
static VALUE GetIsolate(VALUE self) {
86+
PropertyCallbackInfo info(self);
87+
return Isolate(info->GetIsolate());
88+
}
89+
90+
static VALUE GetReturnValue(VALUE self) {
91+
PropertyCallbackInfo info(self);
92+
Locker lock(info->GetIsolate());
93+
return ReturnValue(info->GetReturnValue());
94+
}
95+
96+
static inline void Init() {
97+
ClassBuilder("PropertyCallbackInfo").
98+
defineMethod("This", &This).
99+
defineMethod("Data", &Data).
100+
defineMethod("GetIsolate", &GetIsolate).
101+
defineMethod("GetReturnValue", &GetReturnValue).
102+
store(&Class);
103+
}
104+
};
105+
}
106+
107+
#endif /* RR_PROPERTY_CALLBACK_H */

0 commit comments

Comments
 (0)