nodegit · johnhaley81 · Jan 15, 2016 · Jan 5, 2016 · Jan 5, 2016 · Jan 10, 2016
diff --git a/.jshintrc b/.jshintrc
@@ -18,7 +18,7 @@
   "maxlen": 80,
   "node": true,
   "predef": [
-    "-Promise"
+    "Promise"
   ],
   "proto": true,
   "quotmark": "double",

diff --git a/examples/general.js b/examples/general.js
@@ -1,6 +1,5 @@
 var nodegit = require("../");
 var path = require("path");
-var Promise = require("nodegit-promise");
 var oid;
 var odb;
 var repo;

diff --git a/examples/index-add-and-remove.js b/examples/index-add-and-remove.js
@@ -1,6 +1,5 @@
 var nodegit = require("../");
 var path = require("path");
-var Promise = require("nodegit-promise");
 var promisify = require("promisify-node");
 var fse = promisify(require("fs-extra"));
 

diff --git a/generate/index.js b/generate/index.js
@@ -1,4 +1,3 @@
-var Promise = require('nodegit-promise');
 var generateJson = require("./scripts/generateJson");
 var generateNativeCode = require("./scripts/generateNativeCode");
 var generateMissingTests = require("./scripts/generateMissingTests");

diff --git a/generate/scripts/generateMissingTests.js b/generate/scripts/generateMissingTests.js
@@ -1,5 +1,4 @@
 const path = require("path");
-const Promise = require("nodegit-promise");
 const promisify = require("promisify-node");
 const fse = promisify(require("fs-extra"));
 const utils = require("./utils");

diff --git a/generate/templates/manual/include/async_baton.h b/generate/templates/manual/include/async_baton.h
@@ -0,0 +1,16 @@
+#ifndef ASYNC_BATON
+#define ASYNC_BATON
+
+#include <uv.h>
+#include <nan.h>
+
+// Base class for Batons used for callbacks (for example,
+// JS functions passed as callback parameters,
+// or field properties of configuration objects whose values are callbacks)
+struct AsyncBaton {
+  uv_async_t req;
+
+  bool done;
+};
+
+#endif
diff --git a/generate/templates/manual/include/promise_completion.h b/generate/templates/manual/include/promise_completion.h
@@ -0,0 +1,46 @@
+#ifndef PROMISE_COMPLETION
+#define PROMISE_COMPLETION
+
+#include <nan.h>
+
+#include "async_baton.h"
+
+// PromiseCompletion forwards either the resolved result or the rejection reason
+// to the native layer, once the promise completes
+//
+// inherits ObjectWrap so it can be used in v8 and managed by the garbage collector
+// it isn't wired up to be instantiated or accessed from the JS layer other than
+// for the purpose of promise result forwarding
+class PromiseCompletion : public Nan::ObjectWrap
+{
+  // callback type called when a promise completes
+  typedef void (*Callback) (bool isFulfilled, AsyncBaton *baton, v8::Local<v8::Value> resultOfPromise);
+
+  static NAN_METHOD(New);
+  static NAN_METHOD(PromiseFulfilled);
+  static NAN_METHOD(PromiseRejected);
+
+  // persistent handles for NAN_METHODs
+  static Nan::Persistent<v8::Function> newFn;
+  static Nan::Persistent<v8::Function> promiseFulfilled;
+  static Nan::Persistent<v8::Function> promiseRejected;
+
+  static v8::Local<v8::Value> Bind(Nan::Persistent<v8::Function> &method, v8::Local<v8::Object> object);
+  static void CallCallback(bool isFulfilled, const Nan::FunctionCallbackInfo<v8::Value> &info);
+
+  // callback and baton stored for the promise that this PromiseCompletion is
+  // attached to.  when the promise completes, the callback will be called with
+  // the result, and the stored baton.
+  Callback callback;
+  AsyncBaton *baton;
+
+  void Setup(v8::Local<v8::Function> thenFn, v8::Local<v8::Value> result, AsyncBaton *baton, Callback callback);
+public:
+  // If result is a promise, this will instantiate a new PromiseCompletion
+  // and have it forward the promise result / reason via the baton and callback
+  static bool ForwardIfPromise(v8::Local<v8::Value> result, AsyncBaton *baton, Callback callback);
+
+  static void InitializeComponent();
+};
+
+#endif
diff --git a/generate/templates/manual/src/promise_completion.cc b/generate/templates/manual/src/promise_completion.cc
@@ -0,0 +1,103 @@
+#include "../include/promise_completion.h"
+
+Nan::Persistent<v8::Function> PromiseCompletion::newFn;
+Nan::Persistent<v8::Function> PromiseCompletion::promiseFulfilled;
+Nan::Persistent<v8::Function> PromiseCompletion::promiseRejected;
+
+// initializes the persistent handles for NAN_METHODs
+void PromiseCompletion::InitializeComponent() {
+  v8::Local<v8::FunctionTemplate> newTemplate = Nan::New<v8::FunctionTemplate>(New);
+  newTemplate->InstanceTemplate()->SetInternalFieldCount(1);
+  newFn.Reset(newTemplate->GetFunction());
+
+  promiseFulfilled.Reset(Nan::New<v8::FunctionTemplate>(PromiseFulfilled)->GetFunction());
+  promiseRejected.Reset(Nan::New<v8::FunctionTemplate>(PromiseRejected)->GetFunction());
+}
+
+bool PromiseCompletion::ForwardIfPromise(v8::Local<v8::Value> result, AsyncBaton *baton, Callback callback)
+{
+  Nan::HandleScope scope;
+
+  // check if the result is a promise
+  if (result->IsObject()) {
+    Nan::MaybeLocal<v8::Value> maybeThenProp = Nan::Get(result->ToObject(), Nan::New("then").ToLocalChecked());
+    if (!maybeThenProp.IsEmpty()) {
+      v8::Local<v8::Value> thenProp = maybeThenProp.ToLocalChecked();
+      if(thenProp->IsFunction()) {
+        // we can be reasonably certain that the result is a promise
+
+        // create a new v8 instance of PromiseCompletion
+        v8::Local<v8::Object> object = Nan::NewInstance(Nan::New(newFn)).ToLocalChecked();
+
+        // set up the native PromiseCompletion object
+        PromiseCompletion *promiseCompletion = ObjectWrap::Unwrap<PromiseCompletion>(object);
+        promiseCompletion->Setup(thenProp.As<v8::Function>(), result, baton, callback);
+
+        return true;
+      }
+    }
+  }
+
+  return false;
+}
+
+// creates a new instance of PromiseCompletion, wrapped in a v8 object
+NAN_METHOD(PromiseCompletion::New) {
+  PromiseCompletion *promiseCompletion = new PromiseCompletion();
+  promiseCompletion->Wrap(info.This());
+  info.GetReturnValue().Set(info.This());
+}
+
+// sets up a Promise to forward the promise result via the baton and callback
+void PromiseCompletion::Setup(v8::Local<v8::Function> thenFn, v8::Local<v8::Value> result, AsyncBaton *baton, Callback callback) {
+  this->callback = callback;
+  this->baton = baton;
+
+  v8::Local<v8::Object> promise = result->ToObject();
+
+  v8::Local<v8::Object> thisHandle = handle();
+
+  v8::Local<v8::Value> argv[2] = {
+    Bind(promiseFulfilled, thisHandle),
+    Bind(promiseRejected, thisHandle)
+  };
+
+  // call the promise's .then method with resolve and reject callbacks
+  Nan::Callback(thenFn).Call(promise, 2, argv);
+}
+
+// binds an object to be the context of the function.
+// there might be a better way to do this than calling Function.bind...
+v8::Local<v8::Value> PromiseCompletion::Bind(Nan::Persistent<v8::Function> &function, v8::Local<v8::Object> object) {
+  Nan::EscapableHandleScope scope;
+
+  v8::Local<v8::Function> bind =
+    Nan::Get(Nan::New(function), Nan::New("bind").ToLocalChecked())
+      .ToLocalChecked().As<v8::Function>();
+
+  v8::Local<v8::Value> argv[1] = { object };
+
+  return scope.Escape(bind->Call(Nan::New(function), 1, argv));
+}
+
+// calls the callback stored in the PromiseCompletion, passing the baton that
+// was provided in construction
+void PromiseCompletion::CallCallback(bool isFulfilled, const Nan::FunctionCallbackInfo<v8::Value> &info) {
+  v8::Local<v8::Value> resultOfPromise;
+
+  if (info.Length() > 0) {
+    resultOfPromise = info[0];
+  }
+
+  PromiseCompletion *promiseCompletion = ObjectWrap::Unwrap<PromiseCompletion>(info.This()->ToObject());
+
+  (*promiseCompletion->callback)(isFulfilled, promiseCompletion->baton, resultOfPromise);
+}
+
+NAN_METHOD(PromiseCompletion::PromiseFulfilled) {
+  CallCallback(true, info);
+}
+
+NAN_METHOD(PromiseCompletion::PromiseRejected) {
+  CallCallback(false, info);
+}
diff --git a/generate/templates/partials/callback_helpers.cc b/generate/templates/partials/callback_helpers.cc
@@ -77,18 +77,10 @@ void {{ cppClassName }}::{{ cppFunctionName }}_{{ cbFunction.name }}_async(uv_as
   Nan::TryCatch tryCatch;
   Local<v8::Value> result = callback->Call({{ cbFunction.args|jsArgsCount }}, argv);
 
-  if (result->IsObject() && Nan::Has(result->ToObject(), Nan::New("then").ToLocalChecked()).FromJust()) {
-    Local<v8::Value> thenProp = Nan::Get(result->ToObject(), Nan::New("then").ToLocalChecked()).ToLocalChecked();
-
-    if (thenProp->IsFunction()) {
-      // we can be reasonbly certain that the result is a promise
-      Local<Object> promise = result->ToObject();
-
-      baton->promise.Reset(promise);
+  uv_close((uv_handle_t*) &baton->req, NULL);
 
-      uv_close((uv_handle_t*) &baton->req, (uv_close_cb) {{ cppFunctionName}}_{{ cbFunction.name }}_setupAsyncPromisePolling);
-      return;
-    }
+  if(PromiseCompletion::ForwardIfPromise(result, baton, {{ cppFunctionName }}_{{ cbFunction.name }}_promiseCompleted)) {
+    return;
   }
 
   {% each cbFunction|returnsInfo false true as _return %}
@@ -117,36 +109,14 @@ void {{ cppClassName }}::{{ cppFunctionName }}_{{ cbFunction.name }}_async(uv_as
   {% endeach %}
 
   baton->done = true;
-  uv_close((uv_handle_t*) &baton->req, NULL);
 }
 
-void {{ cppClassName }}::{{ cppFunctionName }}_{{ cbFunction.name }}_setupAsyncPromisePolling(uv_async_t* req) {
-  {{ cppFunctionName }}_{{ cbFunction.name|titleCase }}Baton* baton = static_cast<{{ cppFunctionName }}_{{ cbFunction.name|titleCase }}Baton*>(req->data);
-  uv_async_init(uv_default_loop(), &baton->req, (uv_async_cb) {{ cppFunctionName }}_{{ cbFunction.name }}_asyncPromisePolling);
-  uv_async_send(&baton->req);
-}
-
-void {{ cppClassName }}::{{ cppFunctionName }}_{{ cbFunction.name }}_asyncPromisePolling(uv_async_t* req, int status) {
+void {{ cppClassName }}::{{ cppFunctionName }}_{{ cbFunction.name }}_promiseCompleted(bool isFulfilled, AsyncBaton *_baton, v8::Local<v8::Value> result) {
   Nan::HandleScope scope;
 
-  {{ cppFunctionName }}_{{ cbFunction.name|titleCase }}Baton* baton = static_cast<{{ cppFunctionName }}_{{ cbFunction.name|titleCase }}Baton*>(req->data);
-  Local<Object> promise = Nan::New<Object>(baton->promise);
-  Nan::Callback* isPendingFn = new Nan::Callback(Nan::Get(promise, Nan::New("isPending").ToLocalChecked()).ToLocalChecked().As<Function>());
-  Local<Value> argv[1]; // MSBUILD won't assign an array of length 0
-  Local<Boolean> isPending = isPendingFn->Call(promise, 0, argv)->ToBoolean();
-
-  if (isPending->Value()) {
-    uv_async_send(&baton->req);
-    return;
-  }
-
-  Nan::Callback* isFulfilledFn = new Nan::Callback(Nan::Get(promise, Nan::New("isFulfilled").ToLocalChecked()).ToLocalChecked().As<Function>());
-  Local<Boolean> isFulfilled = isFulfilledFn->Call(promise, 0, argv)->ToBoolean();
-
-  if (isFulfilled->Value()) {
-    Nan::Callback* resultFn = new Nan::Callback(Nan::Get(promise, Nan::New("value").ToLocalChecked()).ToLocalChecked().As<Function>());
-    Local<v8::Value> result = resultFn->Call(promise, 0, argv);
+  {{ cppFunctionName }}_{{ cbFunction.name|titleCase }}Baton* baton = static_cast<{{ cppFunctionName }}_{{ cbFunction.name|titleCase }}Baton*>(_baton);
 
+  if (isFulfilled) {
     {% each cbFunction|returnsInfo false true as _return %}
       if (result.IsEmpty() || result->IsNativeError()) {
         baton->result = {{ cbFunction.return.error }};
@@ -171,23 +141,18 @@ void {{ cppClassName }}::{{ cppFunctionName }}_{{ cbFunction.name }}_asyncPromis
         baton->result = {{ cbFunction.return.noResults }};
       }
     {% endeach %}
-    baton->done = true;
   }
   else {
     // promise was rejected
     {{ cppClassName }}* instance = static_cast<{{ cppClassName }}*>(baton->{% each cbFunction.args|argsInfo as arg %}
       {% if arg.payload == true %}{{arg.name}}{% elsif arg.lastArg %}{{arg.name}}{% endif %}
     {% endeach %});
     Local<v8::Object> parent = instance->handle();
-    Nan::Callback* reasonFn = new Nan::Callback(Nan::Get(promise, Nan::New("reason").ToLocalChecked()).ToLocalChecked().As<Function>());
-    Local<v8::Value> reason = reasonFn->Call(promise, 0, argv);
-    parent->SetHiddenValue(Nan::New("NodeGitPromiseError").ToLocalChecked(), reason);
+    parent->SetHiddenValue(Nan::New("NodeGitPromiseError").ToLocalChecked(), result);
 
     baton->result = {{ cbFunction.return.error }};
-    baton->done = true;
   }
-
-  uv_close((uv_handle_t*) &baton->req, NULL);
+  baton->done = true;
 }
   {%endif%}
 {%endeach%}
diff --git a/generate/templates/partials/field_accessors.cc b/generate/templates/partials/field_accessors.cc
@@ -171,18 +171,10 @@
         Nan::TryCatch tryCatch;
         Local<v8::Value> result = instance->{{ field.name }}->Call({{ field.args|jsArgsCount }}, argv);
 
-        if (result->IsObject() && Nan::Has(result->ToObject(), Nan::New("then").ToLocalChecked()).FromJust()) {
-          Local<v8::Value> thenProp = Nan::Get(result->ToObject(), Nan::New("then").ToLocalChecked()).ToLocalChecked();
-
-          if (thenProp->IsFunction()) {
-            // we can be reasonbly certain that the result is a promise
-            Local<Object> promise = result->ToObject();
-
-            baton->promise.Reset(promise);
+        uv_close((uv_handle_t*) &baton->req, NULL);
 
-            uv_close((uv_handle_t*) &baton->req, (uv_close_cb) {{ field.name }}_setupAsyncPromisePolling);
-            return;
-          }
+        if(PromiseCompletion::ForwardIfPromise(result, baton, {{ cppClassName }}::{{ field.name }}_promiseCompleted)) {
+          return;
         }
 
         {% each field|returnsInfo false true as _return %}
@@ -210,36 +202,14 @@
           }
         {% endeach %}
         baton->done = true;
-        uv_close((uv_handle_t*) &baton->req, NULL);
-      }
-      void {{ cppClassName }}::{{ field.name }}_setupAsyncPromisePolling(uv_async_t* req) {
-        {{ field.name|titleCase }}Baton* baton = static_cast<{{ field.name|titleCase }}Baton*>(req->data);
-        uv_async_init(uv_default_loop(), &baton->req, (uv_async_cb) {{ field.name }}_asyncPromisePolling);
-        uv_async_send(&baton->req);
       }
 
-      void {{ cppClassName }}::{{ field.name }}_asyncPromisePolling(uv_async_t* req, int status) {
+      void {{ cppClassName }}::{{ field.name }}_promiseCompleted(bool isFulfilled, AsyncBaton *_baton, v8::Local<v8::Value> result) {
         Nan::HandleScope scope;
 
-        {{ field.name|titleCase }}Baton* baton = static_cast<{{ field.name|titleCase }}Baton*>(req->data);
-        Local<Object> promise = Nan::New<Object>(baton->promise);
-
-        Nan::Callback* isPendingFn = new Nan::Callback(Nan::Get(promise, Nan::New("isPending").ToLocalChecked()).ToLocalChecked().As<Function>());
-        Local<Value> argv[1]; // MSBUILD won't assign an array of length 0
-        Local<Boolean> isPending = isPendingFn->Call(promise, 0, argv)->ToBoolean();
-
-        if (isPending->Value()) {
-          uv_async_send(&baton->req);
-          return;
-        }
-
-        Nan::Callback* isFulfilledFn = new Nan::Callback(Nan::Get(promise, Nan::New("isFulfilled").ToLocalChecked()).ToLocalChecked().As<Function>());
-        Local<Boolean> isFulfilled = isFulfilledFn->Call(promise, 0, argv)->ToBoolean();
-
-        if (isFulfilled->Value()) {
-          Nan::Callback* resultFn = new Nan::Callback(Nan::Get(promise, Nan::New("value").ToLocalChecked()).ToLocalChecked().As<Function>());
-          Local<v8::Value> result = resultFn->Call(promise, 0, argv);
+        {{ field.name|titleCase }}Baton* baton = static_cast<{{ field.name|titleCase }}Baton*>(_baton);
 
+        if (isFulfilled) {
           {% each field|returnsInfo false true as _return %}
             if (result.IsEmpty() || result->IsNativeError()) {
               baton->result = {{ field.return.error }};
@@ -264,23 +234,18 @@
               baton->result = {{ field.return.noResults }};
             }
           {% endeach %}
-          baton->done = true;
         }
         else {
           // promise was rejected
           {{ cppClassName }}* instance = static_cast<{{ cppClassName }}*>(baton->{% each field.args|argsInfo as arg %}
             {% if arg.payload == true %}{{arg.name}}{% elsif arg.lastArg %}{{arg.name}}{% endif %}
           {% endeach %});
           Local<v8::Object> parent = instance->handle();
-          Nan::Callback* reasonFn = new Nan::Callback(Nan::Get(promise, Nan::New("reason").ToLocalChecked()).ToLocalChecked().As<Function>());
-          Local<v8::Value> reason = reasonFn->Call(promise, 0, argv);
-          parent->SetHiddenValue(Nan::New("NodeGitPromiseError").ToLocalChecked(), reason);
+          parent->SetHiddenValue(Nan::New("NodeGitPromiseError").ToLocalChecked(), result);
 
           baton->result = {{ field.return.error }};
-          baton->done = true;
         }
-
-        uv_close((uv_handle_t*) &baton->req, NULL);
+        baton->done = true;
       }
     {% endif %}
   {% endif %}

diff --git a/generate/templates/templates/binding.gyp b/generate/templates/templates/binding.gyp
@@ -16,6 +16,7 @@
       "sources": [
         "src/lock_master.cc",
         "src/nodegit.cc",
+        "src/promise_completion.cc",
         "src/wrapper.cc",
         "src/functions/copy.cc",
         "src/functions/sleep_for_ms.cc",