Merge remote-tracking branch 'origin/upgrade-to-v8-4.5' into 4.5/object-template

cowboyd · cowboyd · commit 0c9acc1931bc · 2015-07-21T08:44:34.000-05:00
Conflicts:
	ext/v8/function-callback.h
diff --git a/ext/v8/boolean.h b/ext/v8/boolean.h
@@ -0,0 +1,40 @@
+// -*- mode: c++ -*-
+
+#ifndef RR_BOOLEAN_H
+#define RR_BOOLEAN_H
+
+namespace rr {
+  class Boolean : public Ref<v8::Boolean> {
+  public:
+    Boolean(v8::Isolate* isolate, v8::Local<v8::Boolean> handle) :
+      Ref<v8::Boolean>(isolate, handle) {}
+    Boolean(VALUE value) : Ref<v8::Boolean>(value) {}
+
+    static void Init() {
+      ClassBuilder("Boolean", Value::Class).
+        defineSingletonMethod("New", &New).
+        defineMethod("Value", &Value).
+        store(&Class);
+    }
+
+    static VALUE New(VALUE self, VALUE r_isolate, VALUE boolean) {
+      Isolate isolate(r_isolate);
+      Locker lock(isolate);
+
+      return Boolean(isolate, v8::Boolean::New(isolate, RTEST(boolean)));
+    }
+
+    static VALUE Value(VALUE self) {
+      Boolean boolean(self);
+      Locker lock(boolean);
+
+      if (boolean->Value()) {
+        return Qtrue;
+      } else {
+        return Qfalse;
+      }
+    }
+  };
+}
+
+#endif /* RR_BOOLEAN_H */
diff --git a/ext/v8/function-callback.h b/ext/v8/function-callback.h
@@ -27,7 +27,7 @@ namespace rr {
     static VALUE at(VALUE self, VALUE i) {
       FunctionCallbackInfo info(self);
       Locker lock(info->GetIsolate());
-      return Value::handleToRubyObject(info->GetIsolate(), info[NUM2INT(i)]);
+      return Value(info->GetIsolate(), info[NUM2INT(i)]);
     }
 
     static VALUE Callee(VALUE self) {
@@ -56,7 +56,8 @@ namespace rr {
       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);
+
+      return Value(info->GetIsolate(), data);
     }
 
     static VALUE GetIsolate(VALUE self) {
diff --git a/ext/v8/function.cc b/ext/v8/function.cc
@@ -58,7 +58,7 @@ namespace rr {
 
     std::vector< v8::Handle<v8::Value> > vector(Value::convertRubyArray(isolate, argv));
 
-    return Value::handleToRubyObject(isolate, function->Call(Value(receiver), RARRAY_LENINT(argv), &vector[0]));
+    return Value(isolate, function->Call(Value(receiver), RARRAY_LENINT(argv), &vector[0]));
   }
 
   VALUE Function::SetName(VALUE self, VALUE name) {
@@ -74,14 +74,14 @@ namespace rr {
     Function function(self);
     Locker lock(function.getIsolate());
 
-    return Value::handleToRubyObject(function.getIsolate(), function->GetName());
+    return Value(function.getIsolate(), function->GetName());
   }
 
   VALUE Function::GetInferredName(VALUE self) {
     Function function(self);
     Locker lock(function.getIsolate());
 
-    return Value::handleToRubyObject(function.getIsolate(), function->GetInferredName());
+    return Value(function.getIsolate(), function->GetInferredName());
   }
 
   VALUE Function::GetScriptLineNumber(VALUE self) {
diff --git a/ext/v8/init.cc b/ext/v8/init.cc
@@ -18,6 +18,9 @@ extern "C" {
     Value::Init();
     Object::Init();
     Primitive::Init();
+    Null::Init();
+    Undefined::Init();
+    Boolean::Init();
     Number::Init();
     Integer::Init();
     Name::Init();
diff --git a/ext/v8/name.h b/ext/v8/name.h
@@ -9,6 +9,8 @@ namespace rr {
     static VALUE GetIdentityHash(VALUE self);
 
     Name(VALUE self) : Ref<v8::Name>(self) {}
+    Name(v8::Isolate* isolate, v8::Local<v8::Name> name) :
+      Ref<v8::Name>(isolate, name) {}
   };
 }
 
diff --git a/ext/v8/null.h b/ext/v8/null.h
@@ -0,0 +1,18 @@
+// -*- mode: c++ -*-
+#ifndef RR_NULL_H
+#define RR_NULL_H
+
+namespace rr {
+  class Null : public Ref<v8::Value> {
+  public:
+    Null(v8::Isolate* isolate, v8::Local<v8::Value> undefined) :
+      Ref<v8::Value>(isolate, undefined) {}
+
+    static inline void Init() {
+      ClassBuilder("Null", Primitive::Class).
+        store(&Class);
+    }
+  };
+}
+
+#endif /* RR_NULL_H */
diff --git a/ext/v8/rr.h b/ext/v8/rr.h
@@ -33,9 +33,12 @@ inline VALUE not_implemented(const char* message) {
 #include "context.h"
 
 #include "value.h"
+#include "boolean.h"
 #include "object.h"
 #include "array.h"
 #include "primitive.h"
+#include "undefined.h"
+#include "null.h"
 #include "number.h"
 #include "integer.h"
 
diff --git a/ext/v8/script.cc b/ext/v8/script.cc
@@ -37,6 +37,6 @@ namespace rr {
     Context context(rb_context);
     Locker lock(context->GetIsolate());
 
-    return Value::handleToRubyObject(context->GetIsolate(), Script(self)->Run());
+    return Value(context->GetIsolate(), Script(self)->Run());
   }
 }
diff --git a/ext/v8/symbol.cc b/ext/v8/symbol.cc
@@ -69,6 +69,6 @@ namespace rr {
     Isolate isolate(symbol.getIsolate());
     Locker lock(isolate);
 
-    return Value::handleToRubyObject(isolate, symbol->Name());
+    return Value(isolate, symbol->Name());
   }
 }
diff --git a/ext/v8/undefined.h b/ext/v8/undefined.h
@@ -0,0 +1,18 @@
+// -*- mode: c++ -*-
+#ifndef RR_UNDEFINED_H
+#define RR_UNDEFINED_H
+
+namespace rr {
+  class Undefined : public Ref<v8::Value> {
+  public:
+    Undefined(v8::Isolate* isolate, v8::Local<v8::Value> undefined) :
+      Ref<v8::Value>(isolate, undefined) {}
+
+    static inline void Init() {
+      ClassBuilder("Undefined", Primitive::Class).
+        store(&Class);
+    }
+  };
+}
+
+#endif /* RR_UNDEFINED_H */
diff --git a/ext/v8/value.cc b/ext/v8/value.cc
@@ -2,24 +2,18 @@
 
 namespace rr {
 
-  VALUE Value::Empty;
-
   void Value::Init() {
-    Empty = rb_eval_string("Object.new");
-
     ClassBuilder("Value").
-      defineConst("Empty", Empty).
-
       defineMethod("IsUndefined", &IsUndefined).
       defineMethod("IsNull", &IsNull).
       defineMethod("IsTrue", &IsTrue).
       defineMethod("IsFalse", &IsFalse).
+      defineMethod("IsBoolean", &IsBoolean).
       defineMethod("IsString", &IsString).
       defineMethod("IsFunction", &IsFunction).
       // defineMethod("IsArray", &IsArray).
       defineMethod("IsObject", &IsObject).
-      // defineMethod("IsBoolean", &IsBoolean).
-      // defineMethod("IsNumber", &IsNumber).
+      defineMethod("IsNumber", &IsNumber).
       defineMethod("IsExternal", &IsExternal).
       defineMethod("IsInt32", &IsInt32).
       defineMethod("IsUint32", &IsUint32).
@@ -32,20 +26,15 @@ namespace rr {
       defineMethod("ToString", &ToString).
       // defineMethod("ToDetailString", &ToDetailString).
       // defineMethod("ToObject", &ToObject).
-      // defineMethod("BooleanValue", &BooleanValue).
+      defineMethod("BooleanValue", &BooleanValue).
       // defineMethod("NumberValue", &NumberValue).
       // defineMethod("IntegerValue", &IntegerValue).
       // defineMethod("Uint32Value", &Uint32Value).
       // defineMethod("IntegerValue", &IntegerValue).
       defineMethod("Equals", &Equals).
       defineMethod("StrictEquals", &StrictEquals).
 
-      defineMethod("ToRubyObject", &ToRubyObject).
-      defineSingletonMethod("FromRubyObject", &FromRubyObject).
-
       store(&Class);
-
-    rb_gc_register_address(&Empty);
   }
 
   VALUE Value::IsUndefined(VALUE self) {
@@ -76,6 +65,13 @@ namespace rr {
     return Bool(value->IsFalse());
   }
 
+  VALUE Value::IsBoolean(VALUE self) {
+    Value value(self);
+    Locker lock(value);
+
+    return Bool(value->IsBoolean());
+  }
+
   VALUE Value::IsString(VALUE self) {
     Value value(self);
     Locker lock(value.getIsolate());
@@ -104,6 +100,12 @@ namespace rr {
     return Bool(value->IsExternal());
   }
 
+  VALUE Value::IsNumber(VALUE self) {
+    Value value(self);
+    Locker lock(value);
+    return Bool(value->IsNumber());
+  }
+
   VALUE Value::IsInt32(VALUE self) {
     Value value(self);
     Locker lock(value.getIsolate());
@@ -125,45 +127,42 @@ namespace rr {
     return String(value.getIsolate(), value->ToString());
   }
 
-  VALUE Value::Equals(VALUE self, VALUE other) {
+  VALUE Value::BooleanValue(VALUE self, VALUE r_context) {
     Value value(self);
-    Locker lock(value.getIsolate());
+    Locker lock(value);
 
-    return Bool(value->Equals(Value(other)));
+    return Bool::Maybe(value->BooleanValue(Context(r_context)));
   }
 
-  VALUE Value::StrictEquals(VALUE self, VALUE other) {
+  VALUE Value::Equals(VALUE self, VALUE other) {
     Value value(self);
     Locker lock(value.getIsolate());
 
-    return Bool(value->StrictEquals(Value(other)));
+    return Bool(value->Equals(Value(other)));
   }
 
-  VALUE Value::ToRubyObject(VALUE self) {
+  VALUE Value::StrictEquals(VALUE self, VALUE other) {
     Value value(self);
     Locker lock(value.getIsolate());
 
-    return handleToRubyObject(value.getIsolate(), value);
-  }
-
-  VALUE Value::FromRubyObject(VALUE selfClass, VALUE rb_isolate, VALUE value) {
-    Isolate isolate(rb_isolate);
-    Locker lock(isolate);
-
-    return Value(isolate, rubyObjectToHandle(isolate, value));
+    return Bool(value->StrictEquals(Value(other)));
   }
 
-  VALUE Value::handleToRubyObject(v8::Isolate* isolate, v8::Handle<v8::Value> handle) {
-    if (handle.IsEmpty() || handle->IsUndefined() || handle->IsNull()) {
+  Value::operator VALUE() {
+    if (handle.IsEmpty()) {
       return Qnil;
     }
 
-    if (handle->IsTrue()) {
-      return Qtrue;
+    if (handle->IsUndefined()) {
+      return Undefined(isolate, handle);
+    }
+
+    if (handle->IsNull()) {
+      return Null(isolate, handle);
     }
 
-    if (handle->IsFalse()) {
-      return Qfalse;
+    if (handle->IsBoolean()) {
+      return Boolean(isolate, handle.As<v8::Boolean>());
     }
 
     if (handle->IsExternal()) {
@@ -182,14 +181,16 @@ namespace rr {
       return Number(isolate, handle);
     }
 
-    if (handle->IsBoolean()) {
-      return handle->BooleanValue() ? Qtrue : Qfalse;
+    if (handle->IsString()) {
+      return String(isolate, handle.As<v8::String>());
     }
 
-    // TODO
+    if (handle->IsSymbol()) {
+      return Symbol(isolate, handle.As<v8::Symbol>());
+    }
 
-    if (handle->IsString()) {
-      return String(isolate, handle->ToString());
+    if (handle->IsName()) {
+      return Name(isolate, handle.As<v8::Name>());
     }
 
     // TODO
@@ -204,15 +205,10 @@ namespace rr {
     if (handle->IsObject()) {
       return Object(isolate, handle->ToObject());
     }
-
-    return Value(isolate, handle);
+    return Ref<v8::Value>::operator VALUE();
   }
 
   v8::Handle<v8::Value> Value::rubyObjectToHandle(v8::Isolate* isolate, VALUE value) {
-    if (rb_equal(value, Empty)) {
-      return v8::Handle<v8::Value>();
-    }
-
     switch (TYPE(value)) {
     case T_FIXNUM:
       return v8::Integer::New(isolate, NUM2INT(value));
diff --git a/ext/v8/value.h b/ext/v8/value.h
@@ -18,7 +18,7 @@ namespace rr {
     public:
       Maybe(v8::Isolate* isolate, v8::MaybeLocal<v8::Value> maybe) {
         if (!maybe.IsEmpty()) {
-          just(Value::handleToRubyObject(isolate, maybe.ToLocalChecked()));
+          just(Value(isolate, maybe.ToLocalChecked()));
         }
       }
     };
@@ -34,7 +34,7 @@ namespace rr {
     // static VALUE IsArray(VALUE self);
     static VALUE IsObject(VALUE self);
     static VALUE IsBoolean(VALUE self);
-    // static VALUE IsNumber(VALUE self);
+    static VALUE IsNumber(VALUE self);
     static VALUE IsExternal(VALUE self);
     static VALUE IsInt32(VALUE self);
     static VALUE IsUint32(VALUE self);
@@ -47,7 +47,7 @@ namespace rr {
     static VALUE ToString(VALUE self);
     // static VALUE ToDetailString(VALUE self);
     // static VALUE ToObject(VALUE self);
-    // static VALUE BooleanValue(VALUE self);
+    static VALUE BooleanValue(VALUE self, VALUE context);
     // static VALUE NumberValue(VALUE self);
     // static VALUE IntegerValue(VALUE self);
     // static VALUE Uint32Value(VALUE self);
@@ -62,12 +62,10 @@ namespace rr {
     inline Value(VALUE value) : Ref<v8::Value>(value) {}
     inline Value(v8::Isolate* isolate, v8::Handle<v8::Value> value) : Ref<v8::Value>(isolate, value) {}
 
-    static VALUE handleToRubyObject(v8::Isolate* isolate, v8::Handle<v8::Value> value);
+    operator VALUE();
     static v8::Handle<v8::Value> rubyObjectToHandle(v8::Isolate* isolate, VALUE value);
 
     static std::vector< v8::Handle<v8::Value> > convertRubyArray(v8::Isolate* isolate, VALUE value);
-
-    static VALUE Empty;
   };
 
 }
diff --git a/spec/c/value_spec.rb b/spec/c/value_spec.rb

Original file line number	Diff line number	Diff line change
`@@ -58,7 +58,7 @@ namespace rr {`
`58`	`58`
`59`	`59`	`std::vector< v8::Handle<v8::Value> > vector(Value::convertRubyArray(isolate, argv));`
`60`	`60`
`61`		`- return Value::handleToRubyObject(isolate, function->Call(Value(receiver), RARRAY_LENINT(argv), &vector[0]));`
	`61`	`+ return Value(isolate, function->Call(Value(receiver), RARRAY_LENINT(argv), &vector[0]));`
`62`	`62`	`}`
`63`	`63`
`64`	`64`	`VALUE Function::SetName(VALUE self, VALUE name) {`
`@@ -74,14 +74,14 @@ namespace rr {`
`74`	`74`	`Function function(self);`
`75`	`75`	`Locker lock(function.getIsolate());`
`76`	`76`
`77`		`- return Value::handleToRubyObject(function.getIsolate(), function->GetName());`
	`77`	`+ return Value(function.getIsolate(), function->GetName());`
`78`	`78`	`}`
`79`	`79`
`80`	`80`	`VALUE Function::GetInferredName(VALUE self) {`
`81`	`81`	`Function function(self);`
`82`	`82`	`Locker lock(function.getIsolate());`
`83`	`83`
`84`		`- return Value::handleToRubyObject(function.getIsolate(), function->GetInferredName());`
	`84`	`+ return Value(function.getIsolate(), function->GetInferredName());`
`85`	`85`	`}`
`86`	`86`
`87`	`87`	`VALUE Function::GetScriptLineNumber(VALUE self) {`
Original file line number	Diff line number	Diff line change
`@@ -9,6 +9,8 @@ namespace rr {`
`9`	`9`	`static VALUE GetIdentityHash(VALUE self);`
`10`	`10`
`11`	`11`	`Name(VALUE self) : Ref<v8::Name>(self) {}`
	`12`	`+ Name(v8::Isolate* isolate, v8::Local<v8::Name> name) :`
	`13`	`+ Ref<v8::Name>(isolate, name) {}`
`12`	`14`	`};`
`13`	`15`	`}`
`14`	`16`
Original file line number	Diff line number	Diff line change
`@@ -37,6 +37,6 @@ namespace rr {`
`37`	`37`	`Context context(rb_context);`
`38`	`38`	`Locker lock(context->GetIsolate());`
`39`	`39`
`40`		`- return Value::handleToRubyObject(context->GetIsolate(), Script(self)->Run());`
	`40`	`+ return Value(context->GetIsolate(), Script(self)->Run());`
`41`	`41`	`}`
`42`	`42`	`}`
Original file line number	Diff line number	Diff line change
`@@ -69,6 +69,6 @@ namespace rr {`
`69`	`69`	`Isolate isolate(symbol.getIsolate());`
`70`	`70`	`Locker lock(isolate);`
`71`	`71`
`72`		`- return Value::handleToRubyObject(isolate, symbol->Name());`
	`72`	`+ return Value(isolate, symbol->Name());`
`73`	`73`	`}`
`74`	`74`	`}`