Merge branch 'upgrade-to-v8-4.5' of github.com:cowboyd/therubyracer into 4.5/object-template

Author: cowboyd

ext/v8/array.cc

@@ -27,14 +27,14 @@ namespace rr {
     Array array(self);
     Locker lock(array.getIsolate());
 
-    return UInt32(array->Length());
+    return Uint32_t(array->Length());
   }
 
   VALUE Array::CloneElementAt(VALUE self, VALUE index) {
     Array array(self);
     Locker lock(array.getIsolate());
 
-    return Object(array.getIsolate(), array->CloneElementAt(UInt32(index)));
+    return Object(array.getIsolate(), array->CloneElementAt(Uint32_t(index)));
   }
 
 }

ext/v8/bool.h

@@ -23,6 +23,14 @@ namespace rr {
    */
   class Bool : public Equiv {
   public:
+    /**
+     * Use to convert methods that return Maybe<bool> to a Ruby
+     * VALUE, Such as `Maybe<bool> v8::Object::Get()`:
+     *
+     *   return Bool::Maybe(object->Get(context, key));
+     */
+    typedef Equiv::Maybe<bool, Bool> Maybe;
+
     /**
      * Construct a Bool from a Ruby VALUE
      */

ext/v8/equiv.h

@@ -40,6 +40,27 @@ namespace rr {
      */
     inline operator VALUE() { return value; }
 
+
+    /**
+     * A Maybe class for primitive conversions. Specify the primitive
+     * type and the covversion type, and it will be wrapped in a
+     * Maybe. E.g.
+     *
+     *   v8::Maybe<bool> maybe = methodReturningMaybeBool();
+     *   return Equiv::Maybe<bool, Bool>(maybe);
+     *
+     * will yield a V8::C::Maybe wrapping the underlying maybe value.
+     */
+    template <class T, class S>
+    class Maybe : public rr::Maybe {
+    public:
+      Maybe(v8::Maybe<T> maybe) {
+        if (maybe.IsJust()) {
+          just(S(maybe.FromJust()));
+        }
+      }
+    };
+
   protected:
     VALUE value;
   };

ext/v8/external.cc

@@ -13,31 +13,14 @@ namespace rr {
 
   VALUE External::New(VALUE self, VALUE r_isolate, VALUE object) {
     Isolate isolate(r_isolate);
-
-    // as long as this external is alive within JavaScript, it should not be
-    // garbage collected by Ruby.
-    isolate.retainObject(object);
-
     Locker lock(isolate);
 
-    // create the external.
-    Container* container = new Container(object);
-    v8::Local<v8::External> external(v8::External::New(isolate, (void*)container));
-
-    // next, we create a weak reference to this external so that we can be
-    // notified when V8 is done with it. At that point, we can let Ruby know
-    // that this external is done with it.
-    v8::Global<v8::External>* global(new v8::Global<v8::External>(isolate, external));
-    global->SetWeak<Container>(container, &release, v8::WeakCallbackType::kParameter);
-    container->global = global;
-
-    return External(isolate, external);
+    return External(isolate, wrap(isolate, object));
   }
 
   VALUE External::Value(VALUE self) {
     External external(self);
     Locker lock(external);
-    Container* container((Container*)external->Value());
-    return container->object;
+    return unwrap(external);
   }
 }

ext/v8/external.h

@@ -16,6 +16,33 @@ namespace rr {
     inline External(v8::Isolate* isolate, v8::Handle<v8::Value> value) :
       External(isolate, v8::Handle<v8::External>::Cast<v8::Value>(value)) {}
 
+    static inline v8::Local<v8::External> wrap(Isolate isolate, VALUE object) {
+      // as long as this external is alive within JavaScript, it should not be
+      // garbage collected by Ruby.
+      isolate.retainObject(object);
+
+      // create the external.
+      Container* container = new Container(object);
+      v8::Local<v8::External> external(v8::External::New(isolate, (void*)container));
+
+      // next, we create a weak reference to this external so that we can be
+      // notified when V8 is done with it. At that point, we can let Ruby know
+      // that this external is done with it.
+      v8::Global<v8::External>* global(new v8::Global<v8::External>(isolate, external));
+      global->SetWeak<Container>(container, &release, v8::WeakCallbackType::kParameter);
+      container->global = global;
+
+      return External(isolate, external);
+    }
+    static inline VALUE unwrap(v8::Local<v8::External> external) {
+      Container* container = (Container*)external->Value();
+      return container->object;
+    };
+
+    static inline VALUE unwrap(v8::Local<v8::Value> external) {
+      return unwrap(v8::Local<v8::External>::Cast<v8::Value>(external));
+    }
+
     struct Container {
       Container(VALUE v) : object(v) {}
 

ext/v8/function-callback.h

@@ -0,0 +1,125 @@
+// -*- mode: c++ -*-
+#ifndef RR_FUNCTION_CALLBACK_H
+#define RR_FUNCTION_CALLBACK_H
+
+namespace rr {
+
+  typedef Wrapper<v8::FunctionCallbackInfo<v8::Value>> FunctionCallbackInfoWrapper;
+
+  class FunctionCallbackInfo : public FunctionCallbackInfoWrapper {
+  public:
+
+    inline FunctionCallbackInfo(v8::FunctionCallbackInfo<v8::Value> info, v8::Local<v8::Value> data_) :
+      FunctionCallbackInfoWrapper(info), data(data_) {}
+
+    inline FunctionCallbackInfo(VALUE self) : FunctionCallbackInfoWrapper(self) {}
+
+    inline v8::Local<v8::Value> operator [](int i) {
+      return this->container->content[i];
+    }
+
+    /**
+     * Package up the callback data for this function so that it can
+     * invoke a Ruby callable.
+     *
+     * Each `v8::Function` can have one `v8::Value` associated with it
+     * that is passed to its `v8::FunctionCallback`. To support this
+     * same API from ruby, we take the `Value` passed into the
+     * Function constructor *and* the callback and store them *both*
+     * in a single `v8::Object` which we use for the C++ level
+     * callback data.
+     */
+    static v8::Local<v8::Value> wrapData(v8::Isolate* isolate, VALUE r_callback, VALUE r_data) {
+      v8::Local<v8::Object> holder = v8::Object::New(isolate);
+      v8::Local<v8::String> callback_key = v8::String::NewFromUtf8(isolate, "rr::callback");
+      v8::Local<v8::String> data_key = v8::String::NewFromUtf8(isolate, "rr::data");
+      holder->SetHiddenValue(callback_key, External::wrap(isolate, r_callback));
+      holder->SetHiddenValue(data_key, Value(r_data));
+      return holder;
+    }
+
+    /**
+     * Call the Ruby code associated with this callback.
+     *
+     * Unpack the Ruby code, and the callback data from the C++
+     * callback data, and then invoke that code.
+     *
+     * Note: This function implements the `v8::FunctionCallback` API.
+     */
+    static void invoke(const v8::FunctionCallbackInfo<v8::Value>& info) {
+      v8::Isolate* isolate = info.GetIsolate();
+      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::String> callback_key = v8::String::NewFromUtf8(isolate, "rr::callback");
+      v8::Local<v8::Value> data(holder->GetHiddenValue(data_key));
+
+      VALUE code(External::unwrap(holder->GetHiddenValue(callback_key)));
+      Unlocker unlock(info.GetIsolate());
+      rb_funcall(code, rb_intern("call"), 1, (VALUE)FunctionCallbackInfo(info, data));
+    }
+
+    static VALUE Length(VALUE self) {
+      FunctionCallbackInfo info(self);
+      Locker lock(info->GetIsolate());
+      return INT2FIX(info->Length());
+    }
+
+    static VALUE at(VALUE self, VALUE i) {
+      FunctionCallbackInfo info(self);
+      Locker lock(info->GetIsolate());
+      return Value::handleToRubyObject(info->GetIsolate(), info[NUM2INT(i)]);
+    }
+
+    static VALUE Callee(VALUE self) {
+      FunctionCallbackInfo info(self);
+      Locker lock(info->GetIsolate());
+      return Function(info->GetIsolate(), info->Callee());
+    }
+
+    static VALUE This(VALUE self) {
+      FunctionCallbackInfo info(self);
+      Locker lock(info->GetIsolate());
+      return Object(info->GetIsolate(), info->This());
+    }
+
+    static VALUE IsConstructCall(VALUE self) {
+      FunctionCallbackInfo info(self);
+      Locker lock(info->GetIsolate());
+      return Bool(info->IsConstructCall());
+    }
+
+    static VALUE Data(VALUE self) {
+      FunctionCallbackInfo info(self);
+      Locker lock(info->GetIsolate());
+      return Value::handleToRubyObject(info->GetIsolate(), info.data);
+    }
+
+    static VALUE GetIsolate(VALUE self) {
+      FunctionCallbackInfo info(self);
+      return Isolate(info->GetIsolate());
+    }
+
+    static VALUE GetReturnValue(VALUE self) {
+      FunctionCallbackInfo info(self);
+      Locker lock(info->GetIsolate());
+      return ReturnValue(info->GetReturnValue());
+    }
+
+    static inline void Init() {
+      ClassBuilder("FunctionCallbackInfo").
+        defineMethod("Length", &Length).
+        defineMethod("[]", &at).
+        defineMethod("Callee", &Callee).
+        defineMethod("This", &This).
+        defineMethod("IsConstructCall", &IsConstructCall).
+        defineMethod("Data", &Data).
+        defineMethod("GetIsolate", &GetIsolate).
+        defineMethod("GetReturnValue", &GetReturnValue).
+        store(&Class);
+    }
+
+    v8::Local<v8::Value> data;
+  };
+}
+
+#endif /* RR_FUNCTION_CALLBACK_H */

ext/v8/function.cc

@@ -4,7 +4,7 @@ namespace rr {
 
   void Function::Init() {
     ClassBuilder("Function", Object::Class).
-
+      defineSingletonMethod("New", &New).
       defineMethod("NewInstance", &NewInstance).
       defineMethod("Call", &Call).
       defineMethod("SetName", &SetName).
@@ -20,6 +20,23 @@ namespace rr {
       store(&Class);
   }
 
+  VALUE Function::New(int argc, VALUE argv[], VALUE self) {
+    VALUE r_isolate, r_callback, r_data, r_length;
+    rb_scan_args(argc, argv, "22", &r_isolate, &r_callback, &r_data, &r_length);
+    Isolate isolate(r_isolate);
+    Locker lock(isolate);
+
+    // package up the function's callback data to have bot the code and the data
+    // parameter.
+    v8::Local<v8::Value> data(FunctionCallbackInfo::wrapData(isolate, r_callback, r_data));
+
+    int length = RTEST(r_length) ? NUM2INT(r_length) : 0;
+
+    v8::FunctionCallback callback = &FunctionCallbackInfo::invoke;
+
+    return Function(isolate, v8::Function::New(isolate,  callback, data, length));
+  }
+
   VALUE Function::NewInstance(int argc, VALUE argv[], VALUE self) {
     VALUE args;
     rb_scan_args(argc, argv, "01", &args);

ext/v8/function.h

@@ -1,3 +1,4 @@
+// -*- mode: c++ -*-
 #ifndef RR_FUNCTION
 #define RR_FUNCTION
 
@@ -7,8 +8,9 @@ namespace rr {
   public:
     static void Init();
 
+    static VALUE New(int argc, VALUE argv[], VALUE self);
     static VALUE NewInstance(int argc, VALUE argv[], VALUE self);
-    static VALUE Call(VALUE self, VALUE receiver, VALUE argv);
+    static VALUE Call(VALUE self, VALUE receiver, VALUE arguments);
     static VALUE SetName(VALUE self, VALUE name);
     static VALUE GetName(VALUE self);
     static VALUE GetInferredName(VALUE self);
@@ -23,7 +25,6 @@ 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) {}
   };
-
 }
 
 #endif

ext/v8/init.cc

@@ -13,13 +13,18 @@ extern "C" {
     Handles::Init();
     Context::Init();
     Backref::Init();
+    Maybe::Init();
     Value::Init();
     Object::Init();
     Primitive::Init();
+    Number::Init();
+    Integer::Init();
     Name::Init();
     String::Init();
     Symbol::Init();
     Function::Init();
+    FunctionCallbackInfo::Init();
+    ReturnValue::Init();
     Script::Init();
     ScriptOrigin::Init();
     Array::Init();