pj-nodegit 0.27.0 → 0.28.1

package/src/commit.cc

@@ -12,7 +12,6 @@ extern "C" {
 #include "../include/functions/copy.h"
 #include "../include/commit.h"
 #include "nodegit_wrapper.cc"
-#include "../include/async_libgit2_queue_worker.h"
 
   #include "../include/oid.h"
   #include "../include/signature.h"
@@ -33,50 +32,51 @@ using namespace node;
     // way of knowing to free these values.
                                                                                                                                                        }
 
-  void GitCommit::InitializeComponent(v8::Local<v8::Object> target) {
+  void GitCommit::InitializeComponent(v8::Local<v8::Object> target, nodegit::Context *nodegitContext) {
     Nan::HandleScope scope;
 
-    v8::Local<FunctionTemplate> tpl = Nan::New<FunctionTemplate>(JSNewFunction);
+    v8::Local<v8::External> nodegitExternal = Nan::New<v8::External>(nodegitContext);
+    v8::Local<FunctionTemplate> tpl = Nan::New<FunctionTemplate>(JSNewFunction, nodegitExternal);
 
     tpl->InstanceTemplate()->SetInternalFieldCount(1);
     tpl->SetClassName(Nan::New("Commit").ToLocalChecked());
 
-          Nan::SetPrototypeMethod(tpl, "amend", Amend);
-            Nan::SetPrototypeMethod(tpl, "author", Author);
-            Nan::SetPrototypeMethod(tpl, "authorWithMailmap", AuthorWithMailmap);
-            Nan::SetPrototypeMethod(tpl, "body", Body);
-            Nan::SetPrototypeMethod(tpl, "committer", Committer);
-            Nan::SetPrototypeMethod(tpl, "committerWithMailmap", CommitterWithMailmap);
-             Nan::SetMethod(tpl, "create", Create);
-             Nan::SetMethod(tpl, "createBuffer", CreateBuffer);
-             Nan::SetMethod(tpl, "createV", CreateV);
-             Nan::SetMethod(tpl, "createWithSignature", CreateWithSignature);
-            Nan::SetPrototypeMethod(tpl, "dup", Dup);
-             Nan::SetMethod(tpl, "extractSignature", ExtractSignature);
-            Nan::SetPrototypeMethod(tpl, "headerField", HeaderField);
-            Nan::SetPrototypeMethod(tpl, "id", Id);
-             Nan::SetMethod(tpl, "lookup", Lookup);
-             Nan::SetMethod(tpl, "lookupPrefix", LookupPrefix);
-            Nan::SetPrototypeMethod(tpl, "message", Message);
-            Nan::SetPrototypeMethod(tpl, "messageEncoding", MessageEncoding);
-            Nan::SetPrototypeMethod(tpl, "messageRaw", MessageRaw);
-            Nan::SetPrototypeMethod(tpl, "nthGenAncestor", NthGenAncestor);
-            Nan::SetPrototypeMethod(tpl, "owner", Owner);
-            Nan::SetPrototypeMethod(tpl, "parent", Parent);
-            Nan::SetPrototypeMethod(tpl, "parentId", ParentId);
-            Nan::SetPrototypeMethod(tpl, "parentcount", Parentcount);
-            Nan::SetPrototypeMethod(tpl, "rawHeader", RawHeader);
-            Nan::SetPrototypeMethod(tpl, "summary", Summary);
-            Nan::SetPrototypeMethod(tpl, "time", Time);
-            Nan::SetPrototypeMethod(tpl, "timeOffset", TimeOffset);
-            Nan::SetPrototypeMethod(tpl, "tree", Tree);
-            Nan::SetPrototypeMethod(tpl, "treeId", TreeId);
+          Nan::SetPrototypeMethod(tpl, "amend", Amend, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "author", Author, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "authorWithMailmap", AuthorWithMailmap, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "body", Body, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "committer", Committer, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "committerWithMailmap", CommitterWithMailmap, nodegitExternal);
+             Nan::SetMethod(tpl, "create", Create, nodegitExternal);
+             Nan::SetMethod(tpl, "createBuffer", CreateBuffer, nodegitExternal);
+             Nan::SetMethod(tpl, "createV", CreateV, nodegitExternal);
+             Nan::SetMethod(tpl, "createWithSignature", CreateWithSignature, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "dup", Dup, nodegitExternal);
+             Nan::SetMethod(tpl, "extractSignature", ExtractSignature, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "headerField", HeaderField, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "id", Id, nodegitExternal);
+             Nan::SetMethod(tpl, "lookup", Lookup, nodegitExternal);
+             Nan::SetMethod(tpl, "lookupPrefix", LookupPrefix, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "message", Message, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "messageEncoding", MessageEncoding, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "messageRaw", MessageRaw, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "nthGenAncestor", NthGenAncestor, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "owner", Owner, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "parent", Parent, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "parentId", ParentId, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "parentcount", Parentcount, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "rawHeader", RawHeader, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "summary", Summary, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "time", Time, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "timeOffset", TimeOffset, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "tree", Tree, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "treeId", TreeId, nodegitExternal);
     
     InitializeTemplate(tpl);
 
-    v8::Local<Function> _constructor_template = Nan::GetFunction(tpl).ToLocalChecked();
-    constructor_template.Reset(_constructor_template);
-    Nan::Set(target, Nan::New("Commit").ToLocalChecked(), _constructor_template);
+    v8::Local<Function> constructor_template = Nan::GetFunction(tpl).ToLocalChecked();
+    nodegitContext->SaveToPersistent("GitCommit::Template", constructor_template);
+    Nan::Set(target, Nan::New("Commit").ToLocalChecked(), constructor_template);
   }
 
  
@@ -91,20 +91,24 @@ using namespace node;
    */
 NAN_METHOD(GitCommit::Amend) {
 
-  if (info.Length() == 6 || !info[6]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  AmendBaton* baton = new AmendBaton;
+  AmendBaton* baton = new AmendBaton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
 
+
+  nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
+  std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
+
       baton->id = (git_oid *)malloc(sizeof(git_oid ));
         baton->commit_to_amend = Nan::ObjectWrap::Unwrap<GitCommit>(info.This())->GetValue();
 // start convert_from_v8 block
   const char * from_update_ref = NULL;
-    if (info[0]->IsString()) {
+    if ((info.Length() - 1) > 0 && info[0]->IsString()) {
 
   Nan::Utf8String update_ref(Nan::To<v8::String>(info[0]).ToLocalChecked());
   // malloc with one extra byte so we can add the terminating null character C-strings expect:
@@ -123,7 +127,7 @@ NAN_METHOD(GitCommit::Amend) {
           baton->update_ref = from_update_ref;
 // start convert_from_v8 block
   const git_signature * from_author = NULL;
-    if (info[1]->IsObject()) {
+    if ((info.Length() - 1) > 1 && info[1]->IsObject()) {
 from_author = Nan::ObjectWrap::Unwrap<GitSignature>(Nan::To<v8::Object>(info[1]).ToLocalChecked())->GetValue();
   }
   else {
@@ -133,7 +137,7 @@ from_author = Nan::ObjectWrap::Unwrap<GitSignature>(Nan::To<v8::Object>(info[1])
           baton->author = from_author;
 // start convert_from_v8 block
   const git_signature * from_committer = NULL;
-    if (info[2]->IsObject()) {
+    if ((info.Length() - 1) > 2 && info[2]->IsObject()) {
 from_committer = Nan::ObjectWrap::Unwrap<GitSignature>(Nan::To<v8::Object>(info[2]).ToLocalChecked())->GetValue();
   }
   else {
@@ -143,7 +147,7 @@ from_committer = Nan::ObjectWrap::Unwrap<GitSignature>(Nan::To<v8::Object>(info[
           baton->committer = from_committer;
 // start convert_from_v8 block
   const char * from_message_encoding = NULL;
-    if (info[3]->IsString()) {
+    if ((info.Length() - 1) > 3 && info[3]->IsString()) {
 
   Nan::Utf8String message_encoding(Nan::To<v8::String>(info[3]).ToLocalChecked());
   // malloc with one extra byte so we can add the terminating null character C-strings expect:
@@ -162,7 +166,7 @@ from_committer = Nan::ObjectWrap::Unwrap<GitSignature>(Nan::To<v8::Object>(info[
           baton->message_encoding = from_message_encoding;
 // start convert_from_v8 block
   const char * from_message = NULL;
-    if (info[4]->IsString()) {
+    if ((info.Length() - 1) > 4 && info[4]->IsString()) {
 
   Nan::Utf8String message(Nan::To<v8::String>(info[4]).ToLocalChecked());
   // malloc with one extra byte so we can add the terminating null character C-strings expect:
@@ -181,7 +185,7 @@ from_committer = Nan::ObjectWrap::Unwrap<GitSignature>(Nan::To<v8::Object>(info[
           baton->message = from_message;
 // start convert_from_v8 block
   const git_tree * from_tree = NULL;
-    if (info[5]->IsObject()) {
+    if ((info.Length() - 1) > 5 && info[5]->IsObject()) {
 from_tree = Nan::ObjectWrap::Unwrap<GitTree>(Nan::To<v8::Object>(info[5]).ToLocalChecked())->GetValue();
   }
   else {
@@ -190,43 +194,40 @@ from_tree = Nan::ObjectWrap::Unwrap<GitTree>(Nan::To<v8::Object>(info[5]).ToLoca
 // end convert_from_v8 block
           baton->tree = from_tree;
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[6]));
-  AmendWorker *worker = new AmendWorker(baton, callback);
-
-        worker->SaveToPersistent("commit_to_amend", info.This());
-        if (!info[0]->IsUndefined() && !info[0]->IsNull())
-          worker->SaveToPersistent("update_ref", Nan::To<v8::Object>(info[0]).ToLocalChecked());
-        if (!info[1]->IsUndefined() && !info[1]->IsNull())
-          worker->SaveToPersistent("author", Nan::To<v8::Object>(info[1]).ToLocalChecked());
-        if (!info[2]->IsUndefined() && !info[2]->IsNull())
-          worker->SaveToPersistent("committer", Nan::To<v8::Object>(info[2]).ToLocalChecked());
-        if (!info[3]->IsUndefined() && !info[3]->IsNull())
-          worker->SaveToPersistent("message_encoding", Nan::To<v8::Object>(info[3]).ToLocalChecked());
-        if (!info[4]->IsUndefined() && !info[4]->IsNull())
-          worker->SaveToPersistent("message", Nan::To<v8::Object>(info[4]).ToLocalChecked());
-        if (!info[5]->IsUndefined() && !info[5]->IsNull())
-          worker->SaveToPersistent("tree", Nan::To<v8::Object>(info[5]).ToLocalChecked());
-
-  AsyncLibgit2QueueWorker(worker);
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  AmendWorker *worker = new AmendWorker(baton, callback, cleanupHandles);
+
+        worker->Reference<GitCommit>("commit_to_amend", info.This());
+           worker->Reference("update_ref", info[0]);
+              worker->Reference<GitSignature>("author", info[1]);
+               worker->Reference<GitSignature>("committer", info[2]);
+             worker->Reference("message_encoding", info[3]);
+            worker->Reference("message", info[4]);
+              worker->Reference<GitTree>("tree", info[5]);
+  
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitCommit::AmendWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->id
+          ,baton->commit_to_amend
+          ,baton->update_ref
+          ,baton->author
+          ,baton->committer
+          ,baton->message_encoding
+          ,baton->message
+          ,baton->tree
+  );
+
+  return lockMaster;
+}
+
 void GitCommit::AmendWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->id
-            ,baton->commit_to_amend
-            ,baton->update_ref
-            ,baton->author
-            ,baton->committer
-            ,baton->message_encoding
-            ,baton->message
-            ,baton->tree
-    );
-
     int result = git_commit_amend(
 baton->id,baton->commit_to_amend,baton->update_ref,baton->author,baton->committer,baton->message_encoding,baton->message,baton->tree  );
 
@@ -236,25 +237,46 @@ baton->id,baton->commit_to_amend,baton->update_ref,baton->author,baton->committe
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitCommit::AmendWorker::HandleErrorCallback() {
+  if (!GetIsCancelled()) {
+    v8::Local<v8::Object> err = Nan::To<v8::Object>(Nan::Error(ErrorMessage())).ToLocalChecked();
+    Nan::Set(err, Nan::New("errorFunction").ToLocalChecked(), Nan::New("Commit.amend").ToLocalChecked());
+    v8::Local<v8::Value> argv[1] = {
+      err
+    };
+    callback->Call(1, argv, async_resource);
+  }
+
+  if (baton->error) {
+    if (baton->error->message) {
+      free((void *)baton->error->message);
+    }
+
+    free((void *)baton->error);
   }
+
+
+  delete baton;
 }
 
 void GitCommit::AmendWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
-    v8::Local<v8::Value> to;
+    v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
     if (baton->id != NULL) {
-        to = GitOid::New(
+        v8ConversionSlot = GitOid::New(
         baton->id,
         true
        );
    }
   else {
-    to = Nan::Null();
+    v8ConversionSlot = Nan::Null();
   }
   // end convert_to_v8 block
-      v8::Local<v8::Value> result = to;
-
+      v8::Local<v8::Value> result = v8ConversionSlot;
+                 
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -278,50 +300,15 @@ void GitCommit::AmendWorker::HandleOKCallback() {
         free((void *)baton->error->message);
       free((void *)baton->error);
     } else if (baton->error_code < 0) {
-      std::queue< v8::Local<v8::Value> > workerArguments;
-              workerArguments.push(GetFromPersistent("update_ref"));
-              workerArguments.push(GetFromPersistent("author"));
-              workerArguments.push(GetFromPersistent("committer"));
-              workerArguments.push(GetFromPersistent("message_encoding"));
-              workerArguments.push(GetFromPersistent("message"));
-              workerArguments.push(GetFromPersistent("tree"));
       bool callbackFired = false;
-      while(!workerArguments.empty()) {
-        v8::Local<v8::Value> node = workerArguments.front();
-        workerArguments.pop();
-
-        if (
-          !node->IsObject()
-          || node->IsArray()
-          || node->IsBooleanObject()
-          || node->IsDate()
-          || node->IsFunction()
-          || node->IsNumberObject()
-          || node->IsRegExp()
-          || node->IsStringObject()
-        ) {
-          continue;
-        }
-
-        v8::Local<v8::Object> nodeObj = Nan::To<v8::Object>(node).ToLocalChecked();
-        v8::Local<v8::Value> checkValue = GetPrivate(nodeObj, Nan::New("NodeGitPromiseError").ToLocalChecked());
-
-        if (!checkValue.IsEmpty() && !checkValue->IsNull() && !checkValue->IsUndefined()) {
+      if (!callbackErrorHandle.IsEmpty()) {
+        v8::Local<v8::Value> maybeError = Nan::New(callbackErrorHandle);
+        if (!maybeError->IsNull() && !maybeError->IsUndefined()) {
           v8::Local<v8::Value> argv[1] = {
-            Nan::To<v8::Object>(checkValue).ToLocalChecked()
+            maybeError
           };
           callback->Call(1, argv, async_resource);
           callbackFired = true;
-          break;
-        }
-
-        v8::Local<v8::Array> properties = Nan::GetPropertyNames(nodeObj).ToLocalChecked();
-        for (unsigned int propIndex = 0; propIndex < properties->Length(); ++propIndex) {
-          v8::Local<v8::String> propName = Nan::To<v8::String>(Nan::Get(properties, propIndex).ToLocalChecked()).ToLocalChecked();
-          v8::Local<v8::Value> nodeToQueue = Nan::Get(nodeObj, propName).ToLocalChecked();
-          if (!nodeToQueue->IsUndefined()) {
-            workerArguments.push(nodeToQueue);
-          }
         }
       }
 
@@ -354,7 +341,7 @@ NAN_METHOD(GitCommit::Author) {
   git_error_clear();
 
   { // lock master scope start
-    LockMaster lockMaster(
+    nodegit::LockMaster lockMaster(
       /*asyncAction: */false
             ,
               Nan::ObjectWrap::Unwrap<GitCommit>(info.This())->GetValue()
@@ -369,22 +356,22 @@ NAN_METHOD(GitCommit::Author) {
           return info.GetReturnValue().Set(scope.Escape(Nan::Undefined()));
         }
 
-      v8::Local<v8::Value> to;
+      v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
     if (result != NULL) {
       v8::Local<v8::Array> owners = Nan::New<Array>(0);
             Nan::Set(owners, owners->Length(), info.This());
-          to = GitSignature::New(
+          v8ConversionSlot = GitSignature::New(
         result,
         true
           , owners
        );
    }
   else {
-    to = Nan::Null();
+    v8ConversionSlot = Nan::Null();
   }
   // end convert_to_v8 block
-        return info.GetReturnValue().Set(scope.Escape(to));
+        return info.GetReturnValue().Set(scope.Escape(v8ConversionSlot));
   }
 }
   
@@ -398,15 +385,19 @@ NAN_METHOD(GitCommit::AuthorWithMailmap) {
     return Nan::ThrowError("Mailmap mailmap is required.");
   }
 
-  if (info.Length() == 1 || !info[1]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  AuthorWithMailmapBaton* baton = new AuthorWithMailmapBaton;
+  AuthorWithMailmapBaton* baton = new AuthorWithMailmapBaton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
 
+
+  nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
+  std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
+
         baton->commit = Nan::ObjectWrap::Unwrap<GitCommit>(info.This())->GetValue();
 // start convert_from_v8 block
   const git_mailmap * from_mailmap = NULL;
@@ -414,27 +405,29 @@ from_mailmap = Nan::ObjectWrap::Unwrap<GitMailmap>(Nan::To<v8::Object>(info[0]).
 // end convert_from_v8 block
           baton->mailmap = from_mailmap;
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[1]));
-  AuthorWithMailmapWorker *worker = new AuthorWithMailmapWorker(baton, callback);
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  AuthorWithMailmapWorker *worker = new AuthorWithMailmapWorker(baton, callback, cleanupHandles);
 
-        worker->SaveToPersistent("commit", info.This());
-        if (!info[0]->IsUndefined() && !info[0]->IsNull())
-          worker->SaveToPersistent("mailmap", Nan::To<v8::Object>(info[0]).ToLocalChecked());
-
-  AsyncLibgit2QueueWorker(worker);
+        worker->Reference<GitCommit>("commit", info.This());
+             worker->Reference<GitMailmap>("mailmap", info[0]);
+  
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitCommit::AuthorWithMailmapWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->commit
+          ,baton->mailmap
+  );
+
+  return lockMaster;
+}
+
 void GitCommit::AuthorWithMailmapWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->commit
-            ,baton->mailmap
-    );
-
     int result = git_commit_author_with_mailmap(
 &baton->out,baton->commit,baton->mailmap  );
 
@@ -444,25 +437,46 @@ void GitCommit::AuthorWithMailmapWorker::Execute() {
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitCommit::AuthorWithMailmapWorker::HandleErrorCallback() {
+  if (!GetIsCancelled()) {
+    v8::Local<v8::Object> err = Nan::To<v8::Object>(Nan::Error(ErrorMessage())).ToLocalChecked();
+    Nan::Set(err, Nan::New("errorFunction").ToLocalChecked(), Nan::New("Commit.authorWithMailmap").ToLocalChecked());
+    v8::Local<v8::Value> argv[1] = {
+      err
+    };
+    callback->Call(1, argv, async_resource);
   }
+
+  if (baton->error) {
+    if (baton->error->message) {
+      free((void *)baton->error->message);
+    }
+
+    free((void *)baton->error);
+  }
+
+
+  delete baton;
 }
 
 void GitCommit::AuthorWithMailmapWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
-    v8::Local<v8::Value> to;
+    v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
     if (baton->out != NULL) {
-        to = GitSignature::New(
+        v8ConversionSlot = GitSignature::New(
         baton->out,
         true
        );
    }
   else {
-    to = Nan::Null();
+    v8ConversionSlot = Nan::Null();
   }
   // end convert_to_v8 block
-      v8::Local<v8::Value> result = to;
-
+      v8::Local<v8::Value> result = v8ConversionSlot;
+       
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -486,45 +500,15 @@ void GitCommit::AuthorWithMailmapWorker::HandleOKCallback() {
         free((void *)baton->error->message);
       free((void *)baton->error);
     } else if (baton->error_code < 0) {
-      std::queue< v8::Local<v8::Value> > workerArguments;
-              workerArguments.push(GetFromPersistent("mailmap"));
       bool callbackFired = false;
-      while(!workerArguments.empty()) {
-        v8::Local<v8::Value> node = workerArguments.front();
-        workerArguments.pop();
-
-        if (
-          !node->IsObject()
-          || node->IsArray()
-          || node->IsBooleanObject()
-          || node->IsDate()
-          || node->IsFunction()
-          || node->IsNumberObject()
-          || node->IsRegExp()
-          || node->IsStringObject()
-        ) {
-          continue;
-        }
-
-        v8::Local<v8::Object> nodeObj = Nan::To<v8::Object>(node).ToLocalChecked();
-        v8::Local<v8::Value> checkValue = GetPrivate(nodeObj, Nan::New("NodeGitPromiseError").ToLocalChecked());
-
-        if (!checkValue.IsEmpty() && !checkValue->IsNull() && !checkValue->IsUndefined()) {
+      if (!callbackErrorHandle.IsEmpty()) {
+        v8::Local<v8::Value> maybeError = Nan::New(callbackErrorHandle);
+        if (!maybeError->IsNull() && !maybeError->IsUndefined()) {
           v8::Local<v8::Value> argv[1] = {
-            Nan::To<v8::Object>(checkValue).ToLocalChecked()
+            maybeError
           };
           callback->Call(1, argv, async_resource);
           callbackFired = true;
-          break;
-        }
-
-        v8::Local<v8::Array> properties = Nan::GetPropertyNames(nodeObj).ToLocalChecked();
-        for (unsigned int propIndex = 0; propIndex < properties->Length(); ++propIndex) {
-          v8::Local<v8::String> propName = Nan::To<v8::String>(Nan::Get(properties, propIndex).ToLocalChecked()).ToLocalChecked();
-          v8::Local<v8::Value> nodeToQueue = Nan::Get(nodeObj, propName).ToLocalChecked();
-          if (!nodeToQueue->IsUndefined()) {
-            workerArguments.push(nodeToQueue);
-          }
         }
       }
 
@@ -557,7 +541,7 @@ NAN_METHOD(GitCommit::Body) {
   git_error_clear();
 
   { // lock master scope start
-    LockMaster lockMaster(
+    nodegit::LockMaster lockMaster(
       /*asyncAction: */false
             ,
               Nan::ObjectWrap::Unwrap<GitCommit>(info.This())->GetValue()
@@ -572,17 +556,17 @@ NAN_METHOD(GitCommit::Body) {
           return info.GetReturnValue().Set(scope.Escape(Nan::Undefined()));
         }
 
-      v8::Local<v8::Value> to;
+      v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
   if (result){
-       to = Nan::New<v8::String>(result).ToLocalChecked();
+       v8ConversionSlot = Nan::New<v8::String>(result).ToLocalChecked();
    }
   else {
-    to = Nan::Null();
+    v8ConversionSlot = Nan::Null();
   }
 
   // end convert_to_v8 block
-        return info.GetReturnValue().Set(scope.Escape(to));
+        return info.GetReturnValue().Set(scope.Escape(v8ConversionSlot));
   }
 }
    
@@ -595,7 +579,7 @@ NAN_METHOD(GitCommit::Committer) {
   git_error_clear();
 
   { // lock master scope start
-    LockMaster lockMaster(
+    nodegit::LockMaster lockMaster(
       /*asyncAction: */false
             ,
               Nan::ObjectWrap::Unwrap<GitCommit>(info.This())->GetValue()
@@ -610,22 +594,22 @@ NAN_METHOD(GitCommit::Committer) {
           return info.GetReturnValue().Set(scope.Escape(Nan::Undefined()));
         }
 
-      v8::Local<v8::Value> to;
+      v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
     if (result != NULL) {
       v8::Local<v8::Array> owners = Nan::New<Array>(0);
             Nan::Set(owners, owners->Length(), info.This());
-          to = GitSignature::New(
+          v8ConversionSlot = GitSignature::New(
         result,
         true
           , owners
        );
    }
   else {
-    to = Nan::Null();
+    v8ConversionSlot = Nan::Null();
   }
   // end convert_to_v8 block
-        return info.GetReturnValue().Set(scope.Escape(to));
+        return info.GetReturnValue().Set(scope.Escape(v8ConversionSlot));
   }
 }
   
@@ -639,15 +623,19 @@ NAN_METHOD(GitCommit::CommitterWithMailmap) {
     return Nan::ThrowError("Mailmap mailmap is required.");
   }
 
-  if (info.Length() == 1 || !info[1]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  CommitterWithMailmapBaton* baton = new CommitterWithMailmapBaton;
+  CommitterWithMailmapBaton* baton = new CommitterWithMailmapBaton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
 
+
+  nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
+  std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
+
         baton->commit = Nan::ObjectWrap::Unwrap<GitCommit>(info.This())->GetValue();
 // start convert_from_v8 block
   const git_mailmap * from_mailmap = NULL;
@@ -655,27 +643,29 @@ from_mailmap = Nan::ObjectWrap::Unwrap<GitMailmap>(Nan::To<v8::Object>(info[0]).
 // end convert_from_v8 block
           baton->mailmap = from_mailmap;
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[1]));
-  CommitterWithMailmapWorker *worker = new CommitterWithMailmapWorker(baton, callback);
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  CommitterWithMailmapWorker *worker = new CommitterWithMailmapWorker(baton, callback, cleanupHandles);
 
-        worker->SaveToPersistent("commit", info.This());
-        if (!info[0]->IsUndefined() && !info[0]->IsNull())
-          worker->SaveToPersistent("mailmap", Nan::To<v8::Object>(info[0]).ToLocalChecked());
-
-  AsyncLibgit2QueueWorker(worker);
+        worker->Reference<GitCommit>("commit", info.This());
+             worker->Reference<GitMailmap>("mailmap", info[0]);
+  
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitCommit::CommitterWithMailmapWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->commit
+          ,baton->mailmap
+  );
+
+  return lockMaster;
+}
+
 void GitCommit::CommitterWithMailmapWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->commit
-            ,baton->mailmap
-    );
-
     int result = git_commit_committer_with_mailmap(
 &baton->out,baton->commit,baton->mailmap  );
 
@@ -685,25 +675,46 @@ void GitCommit::CommitterWithMailmapWorker::Execute() {
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitCommit::CommitterWithMailmapWorker::HandleErrorCallback() {
+  if (!GetIsCancelled()) {
+    v8::Local<v8::Object> err = Nan::To<v8::Object>(Nan::Error(ErrorMessage())).ToLocalChecked();
+    Nan::Set(err, Nan::New("errorFunction").ToLocalChecked(), Nan::New("Commit.committerWithMailmap").ToLocalChecked());
+    v8::Local<v8::Value> argv[1] = {
+      err
+    };
+    callback->Call(1, argv, async_resource);
+  }
+
+  if (baton->error) {
+    if (baton->error->message) {
+      free((void *)baton->error->message);
+    }
+
+    free((void *)baton->error);
   }
+
+
+  delete baton;
 }
 
 void GitCommit::CommitterWithMailmapWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
-    v8::Local<v8::Value> to;
+    v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
     if (baton->out != NULL) {
-        to = GitSignature::New(
+        v8ConversionSlot = GitSignature::New(
         baton->out,
         true
        );
    }
   else {
-    to = Nan::Null();
+    v8ConversionSlot = Nan::Null();
   }
   // end convert_to_v8 block
-      v8::Local<v8::Value> result = to;
-
+      v8::Local<v8::Value> result = v8ConversionSlot;
+       
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -727,45 +738,15 @@ void GitCommit::CommitterWithMailmapWorker::HandleOKCallback() {
         free((void *)baton->error->message);
       free((void *)baton->error);
     } else if (baton->error_code < 0) {
-      std::queue< v8::Local<v8::Value> > workerArguments;
-              workerArguments.push(GetFromPersistent("mailmap"));
       bool callbackFired = false;
-      while(!workerArguments.empty()) {
-        v8::Local<v8::Value> node = workerArguments.front();
-        workerArguments.pop();
-
-        if (
-          !node->IsObject()
-          || node->IsArray()
-          || node->IsBooleanObject()
-          || node->IsDate()
-          || node->IsFunction()
-          || node->IsNumberObject()
-          || node->IsRegExp()
-          || node->IsStringObject()
-        ) {
-          continue;
-        }
-
-        v8::Local<v8::Object> nodeObj = Nan::To<v8::Object>(node).ToLocalChecked();
-        v8::Local<v8::Value> checkValue = GetPrivate(nodeObj, Nan::New("NodeGitPromiseError").ToLocalChecked());
-
-        if (!checkValue.IsEmpty() && !checkValue->IsNull() && !checkValue->IsUndefined()) {
+      if (!callbackErrorHandle.IsEmpty()) {
+        v8::Local<v8::Value> maybeError = Nan::New(callbackErrorHandle);
+        if (!maybeError->IsNull() && !maybeError->IsUndefined()) {
           v8::Local<v8::Value> argv[1] = {
-            Nan::To<v8::Object>(checkValue).ToLocalChecked()
+            maybeError
           };
           callback->Call(1, argv, async_resource);
           callbackFired = true;
-          break;
-        }
-
-        v8::Local<v8::Array> properties = Nan::GetPropertyNames(nodeObj).ToLocalChecked();
-        for (unsigned int propIndex = 0; propIndex < properties->Length(); ++propIndex) {
-          v8::Local<v8::String> propName = Nan::To<v8::String>(Nan::Get(properties, propIndex).ToLocalChecked()).ToLocalChecked();
-          v8::Local<v8::Value> nodeToQueue = Nan::Get(nodeObj, propName).ToLocalChecked();
-          if (!nodeToQueue->IsUndefined()) {
-            workerArguments.push(nodeToQueue);
-          }
         }
       }
 
@@ -831,15 +812,19 @@ NAN_METHOD(GitCommit::Create) {
     return Nan::ThrowError("Array parents is required.");
   }
 
-  if (info.Length() == 9 || !info[9]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  CreateBaton* baton = new CreateBaton;
+  CreateBaton* baton = new CreateBaton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
 
+
+  nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
+  std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
+
       baton->id = (git_oid *)malloc(sizeof(git_oid ));
 // start convert_from_v8 block
   git_repository * from_repo = NULL;
@@ -848,7 +833,7 @@ from_repo = Nan::ObjectWrap::Unwrap<GitRepository>(Nan::To<v8::Object>(info[0]).
           baton->repo = from_repo;
 // start convert_from_v8 block
   const char * from_update_ref = NULL;
-    if (info[1]->IsString()) {
+    if ((info.Length() - 1) > 1 && info[1]->IsString()) {
 
   Nan::Utf8String update_ref(Nan::To<v8::String>(info[1]).ToLocalChecked());
   // malloc with one extra byte so we can add the terminating null character C-strings expect:
@@ -877,7 +862,7 @@ from_committer = Nan::ObjectWrap::Unwrap<GitSignature>(Nan::To<v8::Object>(info[
           baton->committer = from_committer;
 // start convert_from_v8 block
   const char * from_message_encoding = NULL;
-    if (info[4]->IsString()) {
+    if ((info.Length() - 1) > 4 && info[4]->IsString()) {
 
   Nan::Utf8String message_encoding(Nan::To<v8::String>(info[4]).ToLocalChecked());
   // malloc with one extra byte so we can add the terminating null character C-strings expect:
@@ -929,48 +914,44 @@ from_tree = Nan::ObjectWrap::Unwrap<GitTree>(Nan::To<v8::Object>(info[6]).ToLoca
 // end convert_from_v8 block
           baton->parents = from_parents;
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[9]));
-  CreateWorker *worker = new CreateWorker(baton, callback);
-
-        if (!info[0]->IsUndefined() && !info[0]->IsNull())
-          worker->SaveToPersistent("repo", Nan::To<v8::Object>(info[0]).ToLocalChecked());
-        if (!info[1]->IsUndefined() && !info[1]->IsNull())
-          worker->SaveToPersistent("update_ref", Nan::To<v8::Object>(info[1]).ToLocalChecked());
-        if (!info[2]->IsUndefined() && !info[2]->IsNull())
-          worker->SaveToPersistent("author", Nan::To<v8::Object>(info[2]).ToLocalChecked());
-        if (!info[3]->IsUndefined() && !info[3]->IsNull())
-          worker->SaveToPersistent("committer", Nan::To<v8::Object>(info[3]).ToLocalChecked());
-        if (!info[4]->IsUndefined() && !info[4]->IsNull())
-          worker->SaveToPersistent("message_encoding", Nan::To<v8::Object>(info[4]).ToLocalChecked());
-        if (!info[5]->IsUndefined() && !info[5]->IsNull())
-          worker->SaveToPersistent("message", Nan::To<v8::Object>(info[5]).ToLocalChecked());
-        if (!info[6]->IsUndefined() && !info[6]->IsNull())
-          worker->SaveToPersistent("tree", Nan::To<v8::Object>(info[6]).ToLocalChecked());
-        if (!info[7]->IsUndefined() && !info[7]->IsNull())
-          worker->SaveToPersistent("parent_count", Nan::To<v8::Object>(info[7]).ToLocalChecked());
-        if (!info[8]->IsUndefined() && !info[8]->IsNull())
-          worker->SaveToPersistent("parents", Nan::To<v8::Object>(info[8]).ToLocalChecked());
-
-  AsyncLibgit2QueueWorker(worker);
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  CreateWorker *worker = new CreateWorker(baton, callback, cleanupHandles);
+
+             worker->Reference<GitRepository>("repo", info[0]);
+             worker->Reference("update_ref", info[1]);
+              worker->Reference<GitSignature>("author", info[2]);
+               worker->Reference<GitSignature>("committer", info[3]);
+             worker->Reference("message_encoding", info[4]);
+            worker->Reference("message", info[5]);
+              worker->Reference<GitTree>("tree", info[6]);
+             worker->Reference("parent_count", info[7]);
+             if (info[8]->IsArray()) {
+              worker->Reference<GitCommit>("parents", info[8].As<v8::Array>());
+            }
+  
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitCommit::CreateWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->id
+          ,baton->repo
+          ,baton->update_ref
+          ,baton->author
+          ,baton->committer
+          ,baton->message_encoding
+          ,baton->message
+          ,baton->tree
+  );
+
+  return lockMaster;
+}
+
 void GitCommit::CreateWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->id
-            ,baton->repo
-            ,baton->update_ref
-            ,baton->author
-            ,baton->committer
-            ,baton->message_encoding
-            ,baton->message
-            ,baton->tree
-    );
-
     int result = git_commit_create(
 baton->id,baton->repo,baton->update_ref,baton->author,baton->committer,baton->message_encoding,baton->message,baton->tree,baton->parent_count,baton->parents  );
 
@@ -980,25 +961,46 @@ baton->id,baton->repo,baton->update_ref,baton->author,baton->committer,baton->me
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitCommit::CreateWorker::HandleErrorCallback() {
+  if (!GetIsCancelled()) {
+    v8::Local<v8::Object> err = Nan::To<v8::Object>(Nan::Error(ErrorMessage())).ToLocalChecked();
+    Nan::Set(err, Nan::New("errorFunction").ToLocalChecked(), Nan::New("Commit.create").ToLocalChecked());
+    v8::Local<v8::Value> argv[1] = {
+      err
+    };
+    callback->Call(1, argv, async_resource);
   }
+
+  if (baton->error) {
+    if (baton->error->message) {
+      free((void *)baton->error->message);
+    }
+
+    free((void *)baton->error);
+  }
+
+
+  delete baton;
 }
 
 void GitCommit::CreateWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
-    v8::Local<v8::Value> to;
+    v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
     if (baton->id != NULL) {
-        to = GitOid::New(
+        v8ConversionSlot = GitOid::New(
         baton->id,
         true
        );
    }
   else {
-    to = Nan::Null();
+    v8ConversionSlot = Nan::Null();
   }
   // end convert_to_v8 block
-      v8::Local<v8::Value> result = to;
-
+      v8::Local<v8::Value> result = v8ConversionSlot;
+                     
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -1022,53 +1024,15 @@ void GitCommit::CreateWorker::HandleOKCallback() {
         free((void *)baton->error->message);
       free((void *)baton->error);
     } else if (baton->error_code < 0) {
-      std::queue< v8::Local<v8::Value> > workerArguments;
-              workerArguments.push(GetFromPersistent("repo"));
-              workerArguments.push(GetFromPersistent("update_ref"));
-              workerArguments.push(GetFromPersistent("author"));
-              workerArguments.push(GetFromPersistent("committer"));
-              workerArguments.push(GetFromPersistent("message_encoding"));
-              workerArguments.push(GetFromPersistent("message"));
-              workerArguments.push(GetFromPersistent("tree"));
-              workerArguments.push(GetFromPersistent("parent_count"));
-              workerArguments.push(GetFromPersistent("parents"));
       bool callbackFired = false;
-      while(!workerArguments.empty()) {
-        v8::Local<v8::Value> node = workerArguments.front();
-        workerArguments.pop();
-
-        if (
-          !node->IsObject()
-          || node->IsArray()
-          || node->IsBooleanObject()
-          || node->IsDate()
-          || node->IsFunction()
-          || node->IsNumberObject()
-          || node->IsRegExp()
-          || node->IsStringObject()
-        ) {
-          continue;
-        }
-
-        v8::Local<v8::Object> nodeObj = Nan::To<v8::Object>(node).ToLocalChecked();
-        v8::Local<v8::Value> checkValue = GetPrivate(nodeObj, Nan::New("NodeGitPromiseError").ToLocalChecked());
-
-        if (!checkValue.IsEmpty() && !checkValue->IsNull() && !checkValue->IsUndefined()) {
+      if (!callbackErrorHandle.IsEmpty()) {
+        v8::Local<v8::Value> maybeError = Nan::New(callbackErrorHandle);
+        if (!maybeError->IsNull() && !maybeError->IsUndefined()) {
           v8::Local<v8::Value> argv[1] = {
-            Nan::To<v8::Object>(checkValue).ToLocalChecked()
+            maybeError
           };
           callback->Call(1, argv, async_resource);
           callbackFired = true;
-          break;
-        }
-
-        v8::Local<v8::Array> properties = Nan::GetPropertyNames(nodeObj).ToLocalChecked();
-        for (unsigned int propIndex = 0; propIndex < properties->Length(); ++propIndex) {
-          v8::Local<v8::String> propName = Nan::To<v8::String>(Nan::Get(properties, propIndex).ToLocalChecked()).ToLocalChecked();
-          v8::Local<v8::Value> nodeToQueue = Nan::Get(nodeObj, propName).ToLocalChecked();
-          if (!nodeToQueue->IsUndefined()) {
-            workerArguments.push(nodeToQueue);
-          }
         }
       }
 
@@ -1133,15 +1097,19 @@ NAN_METHOD(GitCommit::CreateBuffer) {
     return Nan::ThrowError("Array parents is required.");
   }
 
-  if (info.Length() == 8 || !info[8]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  CreateBufferBaton* baton = new CreateBufferBaton;
+  CreateBufferBaton* baton = new CreateBufferBaton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
 
+
+  nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
+  std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
+
       baton->out = (git_buf *)malloc(sizeof(git_buf ));
         baton->out->ptr = NULL;
         baton->out->size = baton->out->asize = 0;
@@ -1162,7 +1130,7 @@ from_committer = Nan::ObjectWrap::Unwrap<GitSignature>(Nan::To<v8::Object>(info[
           baton->committer = from_committer;
 // start convert_from_v8 block
   const char * from_message_encoding = NULL;
-    if (info[3]->IsString()) {
+    if ((info.Length() - 1) > 3 && info[3]->IsString()) {
 
   Nan::Utf8String message_encoding(Nan::To<v8::String>(info[3]).ToLocalChecked());
   // malloc with one extra byte so we can add the terminating null character C-strings expect:
@@ -1214,45 +1182,42 @@ from_tree = Nan::ObjectWrap::Unwrap<GitTree>(Nan::To<v8::Object>(info[5]).ToLoca
 // end convert_from_v8 block
           baton->parents = from_parents;
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[8]));
-  CreateBufferWorker *worker = new CreateBufferWorker(baton, callback);
-
-        if (!info[0]->IsUndefined() && !info[0]->IsNull())
-          worker->SaveToPersistent("repo", Nan::To<v8::Object>(info[0]).ToLocalChecked());
-        if (!info[1]->IsUndefined() && !info[1]->IsNull())
-          worker->SaveToPersistent("author", Nan::To<v8::Object>(info[1]).ToLocalChecked());
-        if (!info[2]->IsUndefined() && !info[2]->IsNull())
-          worker->SaveToPersistent("committer", Nan::To<v8::Object>(info[2]).ToLocalChecked());
-        if (!info[3]->IsUndefined() && !info[3]->IsNull())
-          worker->SaveToPersistent("message_encoding", Nan::To<v8::Object>(info[3]).ToLocalChecked());
-        if (!info[4]->IsUndefined() && !info[4]->IsNull())
-          worker->SaveToPersistent("message", Nan::To<v8::Object>(info[4]).ToLocalChecked());
-        if (!info[5]->IsUndefined() && !info[5]->IsNull())
-          worker->SaveToPersistent("tree", Nan::To<v8::Object>(info[5]).ToLocalChecked());
-        if (!info[6]->IsUndefined() && !info[6]->IsNull())
-          worker->SaveToPersistent("parent_count", Nan::To<v8::Object>(info[6]).ToLocalChecked());
-        if (!info[7]->IsUndefined() && !info[7]->IsNull())
-          worker->SaveToPersistent("parents", Nan::To<v8::Object>(info[7]).ToLocalChecked());
-
-  AsyncLibgit2QueueWorker(worker);
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  CreateBufferWorker *worker = new CreateBufferWorker(baton, callback, cleanupHandles);
+
+             worker->Reference<GitRepository>("repo", info[0]);
+               worker->Reference<GitSignature>("author", info[1]);
+               worker->Reference<GitSignature>("committer", info[2]);
+             worker->Reference("message_encoding", info[3]);
+            worker->Reference("message", info[4]);
+              worker->Reference<GitTree>("tree", info[5]);
+             worker->Reference("parent_count", info[6]);
+             if (info[7]->IsArray()) {
+              worker->Reference<GitCommit>("parents", info[7].As<v8::Array>());
+            }
+  
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitCommit::CreateBufferWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->out
+          ,baton->repo
+          ,baton->author
+          ,baton->committer
+          ,baton->message_encoding
+          ,baton->message
+          ,baton->tree
+  );
+
+  return lockMaster;
+}
+
 void GitCommit::CreateBufferWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->out
-            ,baton->repo
-            ,baton->author
-            ,baton->committer
-            ,baton->message_encoding
-            ,baton->message
-            ,baton->tree
-    );
-
     int result = git_commit_create_buffer(
 baton->out,baton->repo,baton->author,baton->committer,baton->message_encoding,baton->message,baton->tree,baton->parent_count,baton->parents  );
 
@@ -1262,22 +1227,45 @@ baton->out,baton->repo,baton->author,baton->committer,baton->message_encoding,ba
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitCommit::CreateBufferWorker::HandleErrorCallback() {
+  if (!GetIsCancelled()) {
+    v8::Local<v8::Object> err = Nan::To<v8::Object>(Nan::Error(ErrorMessage())).ToLocalChecked();
+    Nan::Set(err, Nan::New("errorFunction").ToLocalChecked(), Nan::New("Commit.createBuffer").ToLocalChecked());
+    v8::Local<v8::Value> argv[1] = {
+      err
+    };
+    callback->Call(1, argv, async_resource);
+  }
+
+  if (baton->error) {
+    if (baton->error->message) {
+      free((void *)baton->error->message);
+    }
+
+    free((void *)baton->error);
   }
+
+        git_buf_dispose(baton->out);
+        free((void *)baton->out);
+
+  delete baton;
 }
 
 void GitCommit::CreateBufferWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
-    v8::Local<v8::Value> to;
+    v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
    if (baton->out) {
-    to = Nan::New<v8::String>(baton->out->ptr, baton->out->size).ToLocalChecked();
+    v8ConversionSlot = Nan::New<v8::String>(baton->out->ptr, baton->out->size).ToLocalChecked();
   }
   else {
-    to = Nan::Null();
+    v8ConversionSlot = Nan::Null();
   }
   // end convert_to_v8 block
-      v8::Local<v8::Value> result = to;
-
+      v8::Local<v8::Value> result = v8ConversionSlot;
+                   
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -1301,52 +1289,15 @@ void GitCommit::CreateBufferWorker::HandleOKCallback() {
         free((void *)baton->error->message);
       free((void *)baton->error);
     } else if (baton->error_code < 0) {
-      std::queue< v8::Local<v8::Value> > workerArguments;
-              workerArguments.push(GetFromPersistent("repo"));
-              workerArguments.push(GetFromPersistent("author"));
-              workerArguments.push(GetFromPersistent("committer"));
-              workerArguments.push(GetFromPersistent("message_encoding"));
-              workerArguments.push(GetFromPersistent("message"));
-              workerArguments.push(GetFromPersistent("tree"));
-              workerArguments.push(GetFromPersistent("parent_count"));
-              workerArguments.push(GetFromPersistent("parents"));
       bool callbackFired = false;
-      while(!workerArguments.empty()) {
-        v8::Local<v8::Value> node = workerArguments.front();
-        workerArguments.pop();
-
-        if (
-          !node->IsObject()
-          || node->IsArray()
-          || node->IsBooleanObject()
-          || node->IsDate()
-          || node->IsFunction()
-          || node->IsNumberObject()
-          || node->IsRegExp()
-          || node->IsStringObject()
-        ) {
-          continue;
-        }
-
-        v8::Local<v8::Object> nodeObj = Nan::To<v8::Object>(node).ToLocalChecked();
-        v8::Local<v8::Value> checkValue = GetPrivate(nodeObj, Nan::New("NodeGitPromiseError").ToLocalChecked());
-
-        if (!checkValue.IsEmpty() && !checkValue->IsNull() && !checkValue->IsUndefined()) {
+      if (!callbackErrorHandle.IsEmpty()) {
+        v8::Local<v8::Value> maybeError = Nan::New(callbackErrorHandle);
+        if (!maybeError->IsNull() && !maybeError->IsUndefined()) {
           v8::Local<v8::Value> argv[1] = {
-            Nan::To<v8::Object>(checkValue).ToLocalChecked()
+            maybeError
           };
           callback->Call(1, argv, async_resource);
           callbackFired = true;
-          break;
-        }
-
-        v8::Local<v8::Array> properties = Nan::GetPropertyNames(nodeObj).ToLocalChecked();
-        for (unsigned int propIndex = 0; propIndex < properties->Length(); ++propIndex) {
-          v8::Local<v8::String> propName = Nan::To<v8::String>(Nan::Get(properties, propIndex).ToLocalChecked()).ToLocalChecked();
-          v8::Local<v8::Value> nodeToQueue = Nan::Get(nodeObj, propName).ToLocalChecked();
-          if (!nodeToQueue->IsUndefined()) {
-            workerArguments.push(nodeToQueue);
-          }
         }
       }
 
@@ -1508,7 +1459,7 @@ from_tree = Nan::ObjectWrap::Unwrap<GitTree>(Nan::To<v8::Object>(info[7]).ToLoca
   git_error_clear();
 
   { // lock master scope start
-    LockMaster lockMaster(
+    nodegit::LockMaster lockMaster(
       /*asyncAction: */false
             ,
               from_id
@@ -1544,11 +1495,11 @@ from_tree = Nan::ObjectWrap::Unwrap<GitTree>(Nan::To<v8::Object>(info[7]).ToLoca
         free((void *)from_id);
       }
 
-      v8::Local<v8::Value> to;
+      v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
-     to = Nan::New<Number>( result);
+     v8ConversionSlot = Nan::New<Number>( result);
   // end convert_to_v8 block
-        return info.GetReturnValue().Set(scope.Escape(to));
+        return info.GetReturnValue().Set(scope.Escape(v8ConversionSlot));
   }
 }
   
@@ -1577,15 +1528,19 @@ NAN_METHOD(GitCommit::CreateWithSignature) {
     return Nan::ThrowError("String signature_field is required.");
   }
 
-  if (info.Length() == 4 || !info[4]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  CreateWithSignatureBaton* baton = new CreateWithSignatureBaton;
+  CreateWithSignatureBaton* baton = new CreateWithSignatureBaton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
 
+
+  nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
+  std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
+
       baton->out = (git_oid *)malloc(sizeof(git_oid ));
 // start convert_from_v8 block
   git_repository * from_repo = NULL;
@@ -1635,35 +1590,34 @@ from_repo = Nan::ObjectWrap::Unwrap<GitRepository>(Nan::To<v8::Object>(info[0]).
 // end convert_from_v8 block
           baton->signature_field = from_signature_field;
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[4]));
-  CreateWithSignatureWorker *worker = new CreateWithSignatureWorker(baton, callback);
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  CreateWithSignatureWorker *worker = new CreateWithSignatureWorker(baton, callback, cleanupHandles);
 
-        if (!info[0]->IsUndefined() && !info[0]->IsNull())
-          worker->SaveToPersistent("repo", Nan::To<v8::Object>(info[0]).ToLocalChecked());
-        if (!info[1]->IsUndefined() && !info[1]->IsNull())
-          worker->SaveToPersistent("commit_content", Nan::To<v8::Object>(info[1]).ToLocalChecked());
-        if (!info[2]->IsUndefined() && !info[2]->IsNull())
-          worker->SaveToPersistent("signature", Nan::To<v8::Object>(info[2]).ToLocalChecked());
-        if (!info[3]->IsUndefined() && !info[3]->IsNull())
-          worker->SaveToPersistent("signature_field", Nan::To<v8::Object>(info[3]).ToLocalChecked());
-
-  AsyncLibgit2QueueWorker(worker);
+             worker->Reference<GitRepository>("repo", info[0]);
+             worker->Reference("commit_content", info[1]);
+            worker->Reference("signature", info[2]);
+            worker->Reference("signature_field", info[3]);
+ 
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitCommit::CreateWithSignatureWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->out
+          ,baton->repo
+          ,baton->commit_content
+          ,baton->signature
+          ,baton->signature_field
+  );
+
+  return lockMaster;
+}
+
 void GitCommit::CreateWithSignatureWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->out
-            ,baton->repo
-            ,baton->commit_content
-            ,baton->signature
-            ,baton->signature_field
-    );
-
     int result = git_commit_create_with_signature(
 baton->out,baton->repo,baton->commit_content,baton->signature,baton->signature_field  );
 
@@ -1673,25 +1627,46 @@ baton->out,baton->repo,baton->commit_content,baton->signature,baton->signature_f
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitCommit::CreateWithSignatureWorker::HandleErrorCallback() {
+  if (!GetIsCancelled()) {
+    v8::Local<v8::Object> err = Nan::To<v8::Object>(Nan::Error(ErrorMessage())).ToLocalChecked();
+    Nan::Set(err, Nan::New("errorFunction").ToLocalChecked(), Nan::New("Commit.createWithSignature").ToLocalChecked());
+    v8::Local<v8::Value> argv[1] = {
+      err
+    };
+    callback->Call(1, argv, async_resource);
+  }
+
+  if (baton->error) {
+    if (baton->error->message) {
+      free((void *)baton->error->message);
+    }
+
+    free((void *)baton->error);
   }
+
+
+  delete baton;
 }
 
 void GitCommit::CreateWithSignatureWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
-    v8::Local<v8::Value> to;
+    v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
     if (baton->out != NULL) {
-        to = GitOid::New(
+        v8ConversionSlot = GitOid::New(
         baton->out,
         true
        );
    }
   else {
-    to = Nan::Null();
+    v8ConversionSlot = Nan::Null();
   }
   // end convert_to_v8 block
-      v8::Local<v8::Value> result = to;
-
+      v8::Local<v8::Value> result = v8ConversionSlot;
+           
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -1715,48 +1690,15 @@ void GitCommit::CreateWithSignatureWorker::HandleOKCallback() {
         free((void *)baton->error->message);
       free((void *)baton->error);
     } else if (baton->error_code < 0) {
-      std::queue< v8::Local<v8::Value> > workerArguments;
-              workerArguments.push(GetFromPersistent("repo"));
-              workerArguments.push(GetFromPersistent("commit_content"));
-              workerArguments.push(GetFromPersistent("signature"));
-              workerArguments.push(GetFromPersistent("signature_field"));
       bool callbackFired = false;
-      while(!workerArguments.empty()) {
-        v8::Local<v8::Value> node = workerArguments.front();
-        workerArguments.pop();
-
-        if (
-          !node->IsObject()
-          || node->IsArray()
-          || node->IsBooleanObject()
-          || node->IsDate()
-          || node->IsFunction()
-          || node->IsNumberObject()
-          || node->IsRegExp()
-          || node->IsStringObject()
-        ) {
-          continue;
-        }
-
-        v8::Local<v8::Object> nodeObj = Nan::To<v8::Object>(node).ToLocalChecked();
-        v8::Local<v8::Value> checkValue = GetPrivate(nodeObj, Nan::New("NodeGitPromiseError").ToLocalChecked());
-
-        if (!checkValue.IsEmpty() && !checkValue->IsNull() && !checkValue->IsUndefined()) {
+      if (!callbackErrorHandle.IsEmpty()) {
+        v8::Local<v8::Value> maybeError = Nan::New(callbackErrorHandle);
+        if (!maybeError->IsNull() && !maybeError->IsUndefined()) {
           v8::Local<v8::Value> argv[1] = {
-            Nan::To<v8::Object>(checkValue).ToLocalChecked()
+            maybeError
           };
           callback->Call(1, argv, async_resource);
           callbackFired = true;
-          break;
-        }
-
-        v8::Local<v8::Array> properties = Nan::GetPropertyNames(nodeObj).ToLocalChecked();
-        for (unsigned int propIndex = 0; propIndex < properties->Length(); ++propIndex) {
-          v8::Local<v8::String> propName = Nan::To<v8::String>(Nan::Get(properties, propIndex).ToLocalChecked()).ToLocalChecked();
-          v8::Local<v8::Value> nodeToQueue = Nan::Get(nodeObj, propName).ToLocalChecked();
-          if (!nodeToQueue->IsUndefined()) {
-            workerArguments.push(nodeToQueue);
-          }
         }
       }
 
@@ -1785,35 +1727,42 @@ void GitCommit::CreateWithSignatureWorker::HandleOKCallback() {
    */
 NAN_METHOD(GitCommit::Dup) {
 
-  if (info.Length() == 0 || !info[0]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  DupBaton* baton = new DupBaton;
+  DupBaton* baton = new DupBaton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
 
+
+  nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
+  std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
+
         baton->source = Nan::ObjectWrap::Unwrap<GitCommit>(info.This())->GetValue();
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[0]));
-  DupWorker *worker = new DupWorker(baton, callback);
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  DupWorker *worker = new DupWorker(baton, callback, cleanupHandles);
 
-        worker->SaveToPersistent("source", info.This());
+        worker->Reference<GitCommit>("source", info.This());
 
-  AsyncLibgit2QueueWorker(worker);
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitCommit::DupWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->source
+  );
+
+  return lockMaster;
+}
+
 void GitCommit::DupWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->source
-    );
-
     int result = git_commit_dup(
 &baton->out,baton->source  );
 
@@ -1823,12 +1772,34 @@ void GitCommit::DupWorker::Execute() {
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitCommit::DupWorker::HandleErrorCallback() {
+  if (!GetIsCancelled()) {
+    v8::Local<v8::Object> err = Nan::To<v8::Object>(Nan::Error(ErrorMessage())).ToLocalChecked();
+    Nan::Set(err, Nan::New("errorFunction").ToLocalChecked(), Nan::New("Commit.dup").ToLocalChecked());
+    v8::Local<v8::Value> argv[1] = {
+      err
+    };
+    callback->Call(1, argv, async_resource);
   }
+
+  if (baton->error) {
+    if (baton->error->message) {
+      free((void *)baton->error->message);
+    }
+
+    free((void *)baton->error);
+  }
+
+      free(baton->out);
+
+  delete baton;
 }
 
 void GitCommit::DupWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
-    v8::Local<v8::Value> to;
+    v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
     if (baton->out != NULL) {
       v8::Local<v8::Array> owners = Nan::New<Array>(0);
@@ -1840,18 +1811,18 @@ void GitCommit::DupWorker::HandleOKCallback() {
             true
           )).ToLocalChecked()
         );
-         to = GitCommit::New(
+         v8ConversionSlot = GitCommit::New(
         baton->out,
         true
           , owners
        );
    }
   else {
-    to = Nan::Null();
+    v8ConversionSlot = Nan::Null();
   }
   // end convert_to_v8 block
-      v8::Local<v8::Value> result = to;
-
+      v8::Local<v8::Value> result = v8ConversionSlot;
+     
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -1875,44 +1846,15 @@ void GitCommit::DupWorker::HandleOKCallback() {
         free((void *)baton->error->message);
       free((void *)baton->error);
     } else if (baton->error_code < 0) {
-      std::queue< v8::Local<v8::Value> > workerArguments;
       bool callbackFired = false;
-      while(!workerArguments.empty()) {
-        v8::Local<v8::Value> node = workerArguments.front();
-        workerArguments.pop();
-
-        if (
-          !node->IsObject()
-          || node->IsArray()
-          || node->IsBooleanObject()
-          || node->IsDate()
-          || node->IsFunction()
-          || node->IsNumberObject()
-          || node->IsRegExp()
-          || node->IsStringObject()
-        ) {
-          continue;
-        }
-
-        v8::Local<v8::Object> nodeObj = Nan::To<v8::Object>(node).ToLocalChecked();
-        v8::Local<v8::Value> checkValue = GetPrivate(nodeObj, Nan::New("NodeGitPromiseError").ToLocalChecked());
-
-        if (!checkValue.IsEmpty() && !checkValue->IsNull() && !checkValue->IsUndefined()) {
+      if (!callbackErrorHandle.IsEmpty()) {
+        v8::Local<v8::Value> maybeError = Nan::New(callbackErrorHandle);
+        if (!maybeError->IsNull() && !maybeError->IsUndefined()) {
           v8::Local<v8::Value> argv[1] = {
-            Nan::To<v8::Object>(checkValue).ToLocalChecked()
+            maybeError
           };
           callback->Call(1, argv, async_resource);
           callbackFired = true;
-          break;
-        }
-
-        v8::Local<v8::Array> properties = Nan::GetPropertyNames(nodeObj).ToLocalChecked();
-        for (unsigned int propIndex = 0; propIndex < properties->Length(); ++propIndex) {
-          v8::Local<v8::String> propName = Nan::To<v8::String>(Nan::Get(properties, propIndex).ToLocalChecked()).ToLocalChecked();
-          v8::Local<v8::Value> nodeToQueue = Nan::Get(nodeObj, propName).ToLocalChecked();
-          if (!nodeToQueue->IsUndefined()) {
-            workerArguments.push(nodeToQueue);
-          }
         }
       }
 
@@ -1929,6 +1871,7 @@ void GitCommit::DupWorker::HandleOKCallback() {
       callback->Call(0, NULL, async_resource);
     }
 
+        free(baton->out);
   }
 
 
@@ -1945,21 +1888,15 @@ void GitCommit::DupWorker::HandleOKCallback() {
     return Nan::ThrowError("Oid commit_id is required.");
   }
 
-  if (info.Length() == 2 || (info.Length() == 3 && !info[2]->IsFunction())) {
-    return Nan::ThrowError("Callback is required and must be a Function.");
+  if (info.Length() >= 4 && !info[2]->IsString() && !info[2]->IsUndefined() && !info[2]->IsNull()) {
+    return Nan::ThrowError("String signature_field must be a string or undefined/null.");
   }
 
-  if (info.Length() >= 4) {
-    if (!info[2]->IsString() && !info[2]->IsUndefined() && !info[2]->IsNull()) {
-      return Nan::ThrowError("String signature_field must be a string or undefined/null.");
-    }
-
-    if (!info[3]->IsFunction()) {
-      return Nan::ThrowError("Callback is required and must be a Function.");
-    }
+  if (!info[info.Length() - 1]->IsFunction()) {
+    return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  ExtractSignatureBaton* baton = new ExtractSignatureBaton;
+  ExtractSignatureBaton* baton = new ExtractSignatureBaton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
@@ -1994,42 +1931,54 @@ void GitCommit::DupWorker::HandleOKCallback() {
     baton->field = NULL;
   }
 
-  Nan::Callback *callback;
-  if (info[2]->IsFunction()) {
-    callback = new Nan::Callback(Local<Function>::Cast(info[2]));
-  } else {
-    callback = new Nan::Callback(Local<Function>::Cast(info[3]));
-  }
+  Nan::Callback *callback = new Nan::Callback(Local<Function>::Cast(info[info.Length() - 1]));
 
-  ExtractSignatureWorker *worker = new ExtractSignatureWorker(baton, callback);
-  worker->SaveToPersistent("repo", Nan::To<v8::Object>(info[0]).ToLocalChecked());
-  worker->SaveToPersistent("commit_id", Nan::To<v8::Object>(info[1]).ToLocalChecked());
-  Nan::AsyncQueueWorker(worker);
+  std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
+  ExtractSignatureWorker *worker = new ExtractSignatureWorker(baton, callback, cleanupHandles);
+  worker->Reference<GitRepository>("repo", info[0]);
+  worker->Reference<GitOid>("commit_id", info[1]);
+  nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitCommit::ExtractSignatureWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(true, baton->repo);
+  return lockMaster;
+}
+
 void GitCommit::ExtractSignatureWorker::Execute()
 {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true,
-      baton->repo
-    );
+  baton->error_code = git_commit_extract_signature(
+    &baton->signature,
+    &baton->signed_data,
+    baton->repo,
+    baton->commit_id,
+    (const char *)baton->field
+  );
 
-    baton->error_code = git_commit_extract_signature(
-      &baton->signature,
-      &baton->signed_data,
-      baton->repo,
-      baton->commit_id,
-      (const char *)baton->field
-    );
+  if (baton->error_code != GIT_OK && git_error_last() != NULL) {
+    baton->error = git_error_dup(git_error_last());
+  }
+}
 
-    if (baton->error_code != GIT_OK && git_error_last() != NULL) {
-      baton->error = git_error_dup(git_error_last());
+void GitCommit::ExtractSignatureWorker::HandleErrorCallback() {
+  if (baton->error) {
+    if (baton->error->message) {
+      free((void *)baton->error->message);
     }
+
+    free((void *)baton->error);
   }
+
+  git_buf_dispose(&baton->signature);
+  git_buf_dispose(&baton->signed_data);
+
+  free(baton->field);
+
+  delete baton;
 }
 
 void GitCommit::ExtractSignatureWorker::HandleOKCallback()
@@ -2103,15 +2052,19 @@ NAN_METHOD(GitCommit::HeaderField) {
     return Nan::ThrowError("String field is required.");
   }
 
-  if (info.Length() == 1 || !info[1]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  HeaderFieldBaton* baton = new HeaderFieldBaton;
+  HeaderFieldBaton* baton = new HeaderFieldBaton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
 
+
+  nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
+  std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
+
       baton->out = (git_buf *)malloc(sizeof(git_buf ));
         baton->out->ptr = NULL;
         baton->out->size = baton->out->asize = 0;
@@ -2131,28 +2084,30 @@ NAN_METHOD(GitCommit::HeaderField) {
 // end convert_from_v8 block
           baton->field = from_field;
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[1]));
-  HeaderFieldWorker *worker = new HeaderFieldWorker(baton, callback);
-
-        worker->SaveToPersistent("commit", info.This());
-        if (!info[0]->IsUndefined() && !info[0]->IsNull())
-          worker->SaveToPersistent("field", Nan::To<v8::Object>(info[0]).ToLocalChecked());
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  HeaderFieldWorker *worker = new HeaderFieldWorker(baton, callback, cleanupHandles);
 
-  AsyncLibgit2QueueWorker(worker);
+        worker->Reference<GitCommit>("commit", info.This());
+           worker->Reference("field", info[0]);
+ 
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitCommit::HeaderFieldWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->out
+          ,baton->commit
+          ,baton->field
+  );
+
+  return lockMaster;
+}
+
 void GitCommit::HeaderFieldWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->out
-            ,baton->commit
-            ,baton->field
-    );
-
     int result = git_commit_header_field(
 baton->out,baton->commit,baton->field  );
 
@@ -2162,22 +2117,45 @@ baton->out,baton->commit,baton->field  );
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitCommit::HeaderFieldWorker::HandleErrorCallback() {
+  if (!GetIsCancelled()) {
+    v8::Local<v8::Object> err = Nan::To<v8::Object>(Nan::Error(ErrorMessage())).ToLocalChecked();
+    Nan::Set(err, Nan::New("errorFunction").ToLocalChecked(), Nan::New("Commit.headerField").ToLocalChecked());
+    v8::Local<v8::Value> argv[1] = {
+      err
+    };
+    callback->Call(1, argv, async_resource);
   }
+
+  if (baton->error) {
+    if (baton->error->message) {
+      free((void *)baton->error->message);
+    }
+
+    free((void *)baton->error);
+  }
+
+        git_buf_dispose(baton->out);
+        free((void *)baton->out);
+
+  delete baton;
 }
 
 void GitCommit::HeaderFieldWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
-    v8::Local<v8::Value> to;
+    v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
    if (baton->out) {
-    to = Nan::New<v8::String>(baton->out->ptr, baton->out->size).ToLocalChecked();
+    v8ConversionSlot = Nan::New<v8::String>(baton->out->ptr, baton->out->size).ToLocalChecked();
   }
   else {
-    to = Nan::Null();
+    v8ConversionSlot = Nan::Null();
   }
   // end convert_to_v8 block
-      v8::Local<v8::Value> result = to;
-
+      v8::Local<v8::Value> result = v8ConversionSlot;
+       
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -2201,45 +2179,15 @@ void GitCommit::HeaderFieldWorker::HandleOKCallback() {
         free((void *)baton->error->message);
       free((void *)baton->error);
     } else if (baton->error_code < 0) {
-      std::queue< v8::Local<v8::Value> > workerArguments;
-              workerArguments.push(GetFromPersistent("field"));
       bool callbackFired = false;
-      while(!workerArguments.empty()) {
-        v8::Local<v8::Value> node = workerArguments.front();
-        workerArguments.pop();
-
-        if (
-          !node->IsObject()
-          || node->IsArray()
-          || node->IsBooleanObject()
-          || node->IsDate()
-          || node->IsFunction()
-          || node->IsNumberObject()
-          || node->IsRegExp()
-          || node->IsStringObject()
-        ) {
-          continue;
-        }
-
-        v8::Local<v8::Object> nodeObj = Nan::To<v8::Object>(node).ToLocalChecked();
-        v8::Local<v8::Value> checkValue = GetPrivate(nodeObj, Nan::New("NodeGitPromiseError").ToLocalChecked());
-
-        if (!checkValue.IsEmpty() && !checkValue->IsNull() && !checkValue->IsUndefined()) {
+      if (!callbackErrorHandle.IsEmpty()) {
+        v8::Local<v8::Value> maybeError = Nan::New(callbackErrorHandle);
+        if (!maybeError->IsNull() && !maybeError->IsUndefined()) {
           v8::Local<v8::Value> argv[1] = {
-            Nan::To<v8::Object>(checkValue).ToLocalChecked()
+            maybeError
           };
           callback->Call(1, argv, async_resource);
           callbackFired = true;
-          break;
-        }
-
-        v8::Local<v8::Array> properties = Nan::GetPropertyNames(nodeObj).ToLocalChecked();
-        for (unsigned int propIndex = 0; propIndex < properties->Length(); ++propIndex) {
-          v8::Local<v8::String> propName = Nan::To<v8::String>(Nan::Get(properties, propIndex).ToLocalChecked()).ToLocalChecked();
-          v8::Local<v8::Value> nodeToQueue = Nan::Get(nodeObj, propName).ToLocalChecked();
-          if (!nodeToQueue->IsUndefined()) {
-            workerArguments.push(nodeToQueue);
-          }
         }
       }
 
@@ -2274,7 +2222,7 @@ NAN_METHOD(GitCommit::Id) {
   git_error_clear();
 
   { // lock master scope start
-    LockMaster lockMaster(
+    nodegit::LockMaster lockMaster(
       /*asyncAction: */false
             ,
               Nan::ObjectWrap::Unwrap<GitCommit>(info.This())->GetValue()
@@ -2289,22 +2237,22 @@ NAN_METHOD(GitCommit::Id) {
           return info.GetReturnValue().Set(scope.Escape(Nan::Undefined()));
         }
 
-      v8::Local<v8::Value> to;
+      v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
     if (result != NULL) {
       v8::Local<v8::Array> owners = Nan::New<Array>(0);
             Nan::Set(owners, owners->Length(), info.This());
-          to = GitOid::New(
+          v8ConversionSlot = GitOid::New(
         result,
         true
           , owners
        );
    }
   else {
-    to = Nan::Null();
+    v8ConversionSlot = Nan::Null();
   }
   // end convert_to_v8 block
-        return info.GetReturnValue().Set(scope.Escape(to));
+        return info.GetReturnValue().Set(scope.Escape(v8ConversionSlot));
   }
 }
   
@@ -2323,15 +2271,19 @@ NAN_METHOD(GitCommit::Lookup) {
     || (!info[1]->IsObject() && !info[1]->IsString())) {
     return Nan::ThrowError("Oid id is required.");
   }
-  if (info.Length() == 2 || !info[2]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  LookupBaton* baton = new LookupBaton;
+  LookupBaton* baton = new LookupBaton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
 
+
+  nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
+  std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
+
 // start convert_from_v8 block
   git_repository * from_repo = NULL;
 from_repo = Nan::ObjectWrap::Unwrap<GitRepository>(Nan::To<v8::Object>(info[0]).ToLocalChecked())->GetValue();
@@ -2363,28 +2315,29 @@ from_id = Nan::ObjectWrap::Unwrap<GitOid>(Nan::To<v8::Object>(info[1]).ToLocalCh
           baton->id = from_id;
             baton->idNeedsFree = info[1]->IsString();
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[2]));
-  LookupWorker *worker = new LookupWorker(baton, callback);
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  LookupWorker *worker = new LookupWorker(baton, callback, cleanupHandles);
 
-        if (!info[0]->IsUndefined() && !info[0]->IsNull())
-          worker->SaveToPersistent("repo", Nan::To<v8::Object>(info[0]).ToLocalChecked());
-        if (!info[1]->IsUndefined() && !info[1]->IsNull())
-          worker->SaveToPersistent("id", Nan::To<v8::Object>(info[1]).ToLocalChecked());
-
-  AsyncLibgit2QueueWorker(worker);
+             worker->Reference<GitRepository>("repo", info[0]);
+               worker->Reference<GitOid>("id", info[1]);
+  
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitCommit::LookupWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->repo
+          ,baton->id
+  );
+
+  return lockMaster;
+}
+
 void GitCommit::LookupWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->repo
-            ,baton->id
-    );
-
     int result = git_commit_lookup(
 &baton->commit,baton->repo,baton->id  );
 
@@ -2394,12 +2347,38 @@ void GitCommit::LookupWorker::Execute() {
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitCommit::LookupWorker::HandleErrorCallback() {
+  if (!GetIsCancelled()) {
+    v8::Local<v8::Object> err = Nan::To<v8::Object>(Nan::Error(ErrorMessage())).ToLocalChecked();
+    Nan::Set(err, Nan::New("errorFunction").ToLocalChecked(), Nan::New("Commit.lookup").ToLocalChecked());
+    v8::Local<v8::Value> argv[1] = {
+      err
+    };
+    callback->Call(1, argv, async_resource);
+  }
+
+  if (baton->error) {
+    if (baton->error->message) {
+      free((void *)baton->error->message);
+    }
+
+    free((void *)baton->error);
   }
+
+      git_commit_free(baton->commit);
+      if (baton->idNeedsFree) {
+        baton->idNeedsFree = false;
+        free((void *)baton->id);
+      }
+
+  delete baton;
 }
 
 void GitCommit::LookupWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
-    v8::Local<v8::Value> to;
+    v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
     if (baton->commit != NULL) {
       v8::Local<v8::Array> owners = Nan::New<Array>(0);
@@ -2411,18 +2390,18 @@ void GitCommit::LookupWorker::HandleOKCallback() {
             true
           )).ToLocalChecked()
         );
-         to = GitCommit::New(
+         v8ConversionSlot = GitCommit::New(
         baton->commit,
         true
           , owners
        );
    }
   else {
-    to = Nan::Null();
+    v8ConversionSlot = Nan::Null();
   }
   // end convert_to_v8 block
-      v8::Local<v8::Value> result = to;
-
+      v8::Local<v8::Value> result = v8ConversionSlot;
+       
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -2446,46 +2425,15 @@ void GitCommit::LookupWorker::HandleOKCallback() {
         free((void *)baton->error->message);
       free((void *)baton->error);
     } else if (baton->error_code < 0) {
-      std::queue< v8::Local<v8::Value> > workerArguments;
-              workerArguments.push(GetFromPersistent("repo"));
-              workerArguments.push(GetFromPersistent("id"));
       bool callbackFired = false;
-      while(!workerArguments.empty()) {
-        v8::Local<v8::Value> node = workerArguments.front();
-        workerArguments.pop();
-
-        if (
-          !node->IsObject()
-          || node->IsArray()
-          || node->IsBooleanObject()
-          || node->IsDate()
-          || node->IsFunction()
-          || node->IsNumberObject()
-          || node->IsRegExp()
-          || node->IsStringObject()
-        ) {
-          continue;
-        }
-
-        v8::Local<v8::Object> nodeObj = Nan::To<v8::Object>(node).ToLocalChecked();
-        v8::Local<v8::Value> checkValue = GetPrivate(nodeObj, Nan::New("NodeGitPromiseError").ToLocalChecked());
-
-        if (!checkValue.IsEmpty() && !checkValue->IsNull() && !checkValue->IsUndefined()) {
+      if (!callbackErrorHandle.IsEmpty()) {
+        v8::Local<v8::Value> maybeError = Nan::New(callbackErrorHandle);
+        if (!maybeError->IsNull() && !maybeError->IsUndefined()) {
           v8::Local<v8::Value> argv[1] = {
-            Nan::To<v8::Object>(checkValue).ToLocalChecked()
+            maybeError
           };
           callback->Call(1, argv, async_resource);
           callbackFired = true;
-          break;
-        }
-
-        v8::Local<v8::Array> properties = Nan::GetPropertyNames(nodeObj).ToLocalChecked();
-        for (unsigned int propIndex = 0; propIndex < properties->Length(); ++propIndex) {
-          v8::Local<v8::String> propName = Nan::To<v8::String>(Nan::Get(properties, propIndex).ToLocalChecked()).ToLocalChecked();
-          v8::Local<v8::Value> nodeToQueue = Nan::Get(nodeObj, propName).ToLocalChecked();
-          if (!nodeToQueue->IsUndefined()) {
-            workerArguments.push(nodeToQueue);
-          }
         }
       }
 
@@ -2502,6 +2450,7 @@ void GitCommit::LookupWorker::HandleOKCallback() {
       callback->Call(0, NULL, async_resource);
     }
 
+        git_commit_free(baton->commit);
   }
 
       if (baton->idNeedsFree) {
@@ -2533,15 +2482,19 @@ NAN_METHOD(GitCommit::LookupPrefix) {
     return Nan::ThrowError("Number len is required.");
   }
 
-  if (info.Length() == 3 || !info[3]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  LookupPrefixBaton* baton = new LookupPrefixBaton;
+  LookupPrefixBaton* baton = new LookupPrefixBaton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
 
+
+  nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
+  std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
+
 // start convert_from_v8 block
   git_repository * from_repo = NULL;
 from_repo = Nan::ObjectWrap::Unwrap<GitRepository>(Nan::To<v8::Object>(info[0]).ToLocalChecked())->GetValue();
@@ -2578,30 +2531,30 @@ from_id = Nan::ObjectWrap::Unwrap<GitOid>(Nan::To<v8::Object>(info[1]).ToLocalCh
 // end convert_from_v8 block
           baton->len = from_len;
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[3]));
-  LookupPrefixWorker *worker = new LookupPrefixWorker(baton, callback);
-
-        if (!info[0]->IsUndefined() && !info[0]->IsNull())
-          worker->SaveToPersistent("repo", Nan::To<v8::Object>(info[0]).ToLocalChecked());
-        if (!info[1]->IsUndefined() && !info[1]->IsNull())
-          worker->SaveToPersistent("id", Nan::To<v8::Object>(info[1]).ToLocalChecked());
-        if (!info[2]->IsUndefined() && !info[2]->IsNull())
-          worker->SaveToPersistent("len", Nan::To<v8::Object>(info[2]).ToLocalChecked());
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  LookupPrefixWorker *worker = new LookupPrefixWorker(baton, callback, cleanupHandles);
 
-  AsyncLibgit2QueueWorker(worker);
+             worker->Reference<GitRepository>("repo", info[0]);
+               worker->Reference<GitOid>("id", info[1]);
+             worker->Reference("len", info[2]);
+ 
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitCommit::LookupPrefixWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->repo
+          ,baton->id
+  );
+
+  return lockMaster;
+}
+
 void GitCommit::LookupPrefixWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->repo
-            ,baton->id
-    );
-
     int result = git_commit_lookup_prefix(
 &baton->commit,baton->repo,baton->id,baton->len  );
 
@@ -2611,12 +2564,38 @@ void GitCommit::LookupPrefixWorker::Execute() {
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitCommit::LookupPrefixWorker::HandleErrorCallback() {
+  if (!GetIsCancelled()) {
+    v8::Local<v8::Object> err = Nan::To<v8::Object>(Nan::Error(ErrorMessage())).ToLocalChecked();
+    Nan::Set(err, Nan::New("errorFunction").ToLocalChecked(), Nan::New("Commit.lookupPrefix").ToLocalChecked());
+    v8::Local<v8::Value> argv[1] = {
+      err
+    };
+    callback->Call(1, argv, async_resource);
+  }
+
+  if (baton->error) {
+    if (baton->error->message) {
+      free((void *)baton->error->message);
+    }
+
+    free((void *)baton->error);
   }
+
+      git_commit_free(baton->commit);
+      if (baton->idNeedsFree) {
+        baton->idNeedsFree = false;
+        free((void *)baton->id);
+      }
+
+  delete baton;
 }
 
 void GitCommit::LookupPrefixWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
-    v8::Local<v8::Value> to;
+    v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
     if (baton->commit != NULL) {
       v8::Local<v8::Array> owners = Nan::New<Array>(0);
@@ -2628,18 +2607,18 @@ void GitCommit::LookupPrefixWorker::HandleOKCallback() {
             true
           )).ToLocalChecked()
         );
-         to = GitCommit::New(
+         v8ConversionSlot = GitCommit::New(
         baton->commit,
         true
           , owners
        );
    }
   else {
-    to = Nan::Null();
+    v8ConversionSlot = Nan::Null();
   }
   // end convert_to_v8 block
-      v8::Local<v8::Value> result = to;
-
+      v8::Local<v8::Value> result = v8ConversionSlot;
+         
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -2663,47 +2642,15 @@ void GitCommit::LookupPrefixWorker::HandleOKCallback() {
         free((void *)baton->error->message);
       free((void *)baton->error);
     } else if (baton->error_code < 0) {
-      std::queue< v8::Local<v8::Value> > workerArguments;
-              workerArguments.push(GetFromPersistent("repo"));
-              workerArguments.push(GetFromPersistent("id"));
-              workerArguments.push(GetFromPersistent("len"));
       bool callbackFired = false;
-      while(!workerArguments.empty()) {
-        v8::Local<v8::Value> node = workerArguments.front();
-        workerArguments.pop();
-
-        if (
-          !node->IsObject()
-          || node->IsArray()
-          || node->IsBooleanObject()
-          || node->IsDate()
-          || node->IsFunction()
-          || node->IsNumberObject()
-          || node->IsRegExp()
-          || node->IsStringObject()
-        ) {
-          continue;
-        }
-
-        v8::Local<v8::Object> nodeObj = Nan::To<v8::Object>(node).ToLocalChecked();
-        v8::Local<v8::Value> checkValue = GetPrivate(nodeObj, Nan::New("NodeGitPromiseError").ToLocalChecked());
-
-        if (!checkValue.IsEmpty() && !checkValue->IsNull() && !checkValue->IsUndefined()) {
+      if (!callbackErrorHandle.IsEmpty()) {
+        v8::Local<v8::Value> maybeError = Nan::New(callbackErrorHandle);
+        if (!maybeError->IsNull() && !maybeError->IsUndefined()) {
           v8::Local<v8::Value> argv[1] = {
-            Nan::To<v8::Object>(checkValue).ToLocalChecked()
+            maybeError
           };
           callback->Call(1, argv, async_resource);
           callbackFired = true;
-          break;
-        }
-
-        v8::Local<v8::Array> properties = Nan::GetPropertyNames(nodeObj).ToLocalChecked();
-        for (unsigned int propIndex = 0; propIndex < properties->Length(); ++propIndex) {
-          v8::Local<v8::String> propName = Nan::To<v8::String>(Nan::Get(properties, propIndex).ToLocalChecked()).ToLocalChecked();
-          v8::Local<v8::Value> nodeToQueue = Nan::Get(nodeObj, propName).ToLocalChecked();
-          if (!nodeToQueue->IsUndefined()) {
-            workerArguments.push(nodeToQueue);
-          }
         }
       }
 
@@ -2720,6 +2667,7 @@ void GitCommit::LookupPrefixWorker::HandleOKCallback() {
       callback->Call(0, NULL, async_resource);
     }
 
+        git_commit_free(baton->commit);
   }
 
       if (baton->idNeedsFree) {
@@ -2740,7 +2688,7 @@ NAN_METHOD(GitCommit::Message) {
   git_error_clear();
 
   { // lock master scope start
-    LockMaster lockMaster(
+    nodegit::LockMaster lockMaster(
       /*asyncAction: */false
             ,
               Nan::ObjectWrap::Unwrap<GitCommit>(info.This())->GetValue()
@@ -2755,17 +2703,17 @@ NAN_METHOD(GitCommit::Message) {
           return info.GetReturnValue().Set(scope.Escape(Nan::Undefined()));
         }
 
-      v8::Local<v8::Value> to;
+      v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
   if (result){
-       to = Nan::New<v8::String>(result).ToLocalChecked();
+       v8ConversionSlot = Nan::New<v8::String>(result).ToLocalChecked();
    }
   else {
-    to = Nan::Null();
+    v8ConversionSlot = Nan::Null();
   }
 
   // end convert_to_v8 block
-        return info.GetReturnValue().Set(scope.Escape(to));
+        return info.GetReturnValue().Set(scope.Escape(v8ConversionSlot));
   }
 }
    
@@ -2778,7 +2726,7 @@ NAN_METHOD(GitCommit::MessageEncoding) {
   git_error_clear();
 
   { // lock master scope start
-    LockMaster lockMaster(
+    nodegit::LockMaster lockMaster(
       /*asyncAction: */false
             ,
               Nan::ObjectWrap::Unwrap<GitCommit>(info.This())->GetValue()
@@ -2793,17 +2741,17 @@ NAN_METHOD(GitCommit::MessageEncoding) {
           return info.GetReturnValue().Set(scope.Escape(Nan::Undefined()));
         }
 
-      v8::Local<v8::Value> to;
+      v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
   if (result){
-       to = Nan::New<v8::String>(result).ToLocalChecked();
+       v8ConversionSlot = Nan::New<v8::String>(result).ToLocalChecked();
    }
   else {
-    to = Nan::Null();
+    v8ConversionSlot = Nan::Null();
   }
 
   // end convert_to_v8 block
-        return info.GetReturnValue().Set(scope.Escape(to));
+        return info.GetReturnValue().Set(scope.Escape(v8ConversionSlot));
   }
 }
    
@@ -2816,7 +2764,7 @@ NAN_METHOD(GitCommit::MessageRaw) {
   git_error_clear();
 
   { // lock master scope start
-    LockMaster lockMaster(
+    nodegit::LockMaster lockMaster(
       /*asyncAction: */false
             ,
               Nan::ObjectWrap::Unwrap<GitCommit>(info.This())->GetValue()
@@ -2831,17 +2779,17 @@ NAN_METHOD(GitCommit::MessageRaw) {
           return info.GetReturnValue().Set(scope.Escape(Nan::Undefined()));
         }
 
-      v8::Local<v8::Value> to;
+      v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
   if (result){
-       to = Nan::New<v8::String>(result).ToLocalChecked();
+       v8ConversionSlot = Nan::New<v8::String>(result).ToLocalChecked();
    }
   else {
-    to = Nan::Null();
+    v8ConversionSlot = Nan::Null();
   }
 
   // end convert_to_v8 block
-        return info.GetReturnValue().Set(scope.Escape(to));
+        return info.GetReturnValue().Set(scope.Escape(v8ConversionSlot));
   }
 }
   
@@ -2855,15 +2803,19 @@ NAN_METHOD(GitCommit::NthGenAncestor) {
     return Nan::ThrowError("Number n is required.");
   }
 
-  if (info.Length() == 1 || !info[1]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  NthGenAncestorBaton* baton = new NthGenAncestorBaton;
+  NthGenAncestorBaton* baton = new NthGenAncestorBaton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
 
+
+  nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
+  std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
+
         baton->commit = Nan::ObjectWrap::Unwrap<GitCommit>(info.This())->GetValue();
 // start convert_from_v8 block
   unsigned int from_n;
@@ -2871,26 +2823,28 @@ NAN_METHOD(GitCommit::NthGenAncestor) {
 // end convert_from_v8 block
           baton->n = from_n;
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[1]));
-  NthGenAncestorWorker *worker = new NthGenAncestorWorker(baton, callback);
-
-        worker->SaveToPersistent("commit", info.This());
-        if (!info[0]->IsUndefined() && !info[0]->IsNull())
-          worker->SaveToPersistent("n", Nan::To<v8::Object>(info[0]).ToLocalChecked());
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  NthGenAncestorWorker *worker = new NthGenAncestorWorker(baton, callback, cleanupHandles);
 
-  AsyncLibgit2QueueWorker(worker);
+        worker->Reference<GitCommit>("commit", info.This());
+           worker->Reference("n", info[0]);
+ 
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitCommit::NthGenAncestorWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->commit
+  );
+
+  return lockMaster;
+}
+
 void GitCommit::NthGenAncestorWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->commit
-    );
-
     int result = git_commit_nth_gen_ancestor(
 &baton->ancestor,baton->commit,baton->n  );
 
@@ -2900,12 +2854,34 @@ void GitCommit::NthGenAncestorWorker::Execute() {
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitCommit::NthGenAncestorWorker::HandleErrorCallback() {
+  if (!GetIsCancelled()) {
+    v8::Local<v8::Object> err = Nan::To<v8::Object>(Nan::Error(ErrorMessage())).ToLocalChecked();
+    Nan::Set(err, Nan::New("errorFunction").ToLocalChecked(), Nan::New("Commit.nthGenAncestor").ToLocalChecked());
+    v8::Local<v8::Value> argv[1] = {
+      err
+    };
+    callback->Call(1, argv, async_resource);
+  }
+
+  if (baton->error) {
+    if (baton->error->message) {
+      free((void *)baton->error->message);
+    }
+
+    free((void *)baton->error);
   }
+
+      git_commit_free(baton->ancestor);
+
+  delete baton;
 }
 
 void GitCommit::NthGenAncestorWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
-    v8::Local<v8::Value> to;
+    v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
     if (baton->ancestor != NULL) {
       v8::Local<v8::Array> owners = Nan::New<Array>(0);
@@ -2917,18 +2893,18 @@ void GitCommit::NthGenAncestorWorker::HandleOKCallback() {
             true
           )).ToLocalChecked()
         );
-         to = GitCommit::New(
+         v8ConversionSlot = GitCommit::New(
         baton->ancestor,
         true
           , owners
        );
    }
   else {
-    to = Nan::Null();
+    v8ConversionSlot = Nan::Null();
   }
   // end convert_to_v8 block
-      v8::Local<v8::Value> result = to;
-
+      v8::Local<v8::Value> result = v8ConversionSlot;
+       
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -2952,45 +2928,15 @@ void GitCommit::NthGenAncestorWorker::HandleOKCallback() {
         free((void *)baton->error->message);
       free((void *)baton->error);
     } else if (baton->error_code < 0) {
-      std::queue< v8::Local<v8::Value> > workerArguments;
-              workerArguments.push(GetFromPersistent("n"));
       bool callbackFired = false;
-      while(!workerArguments.empty()) {
-        v8::Local<v8::Value> node = workerArguments.front();
-        workerArguments.pop();
-
-        if (
-          !node->IsObject()
-          || node->IsArray()
-          || node->IsBooleanObject()
-          || node->IsDate()
-          || node->IsFunction()
-          || node->IsNumberObject()
-          || node->IsRegExp()
-          || node->IsStringObject()
-        ) {
-          continue;
-        }
-
-        v8::Local<v8::Object> nodeObj = Nan::To<v8::Object>(node).ToLocalChecked();
-        v8::Local<v8::Value> checkValue = GetPrivate(nodeObj, Nan::New("NodeGitPromiseError").ToLocalChecked());
-
-        if (!checkValue.IsEmpty() && !checkValue->IsNull() && !checkValue->IsUndefined()) {
+      if (!callbackErrorHandle.IsEmpty()) {
+        v8::Local<v8::Value> maybeError = Nan::New(callbackErrorHandle);
+        if (!maybeError->IsNull() && !maybeError->IsUndefined()) {
           v8::Local<v8::Value> argv[1] = {
-            Nan::To<v8::Object>(checkValue).ToLocalChecked()
+            maybeError
           };
           callback->Call(1, argv, async_resource);
           callbackFired = true;
-          break;
-        }
-
-        v8::Local<v8::Array> properties = Nan::GetPropertyNames(nodeObj).ToLocalChecked();
-        for (unsigned int propIndex = 0; propIndex < properties->Length(); ++propIndex) {
-          v8::Local<v8::String> propName = Nan::To<v8::String>(Nan::Get(properties, propIndex).ToLocalChecked()).ToLocalChecked();
-          v8::Local<v8::Value> nodeToQueue = Nan::Get(nodeObj, propName).ToLocalChecked();
-          if (!nodeToQueue->IsUndefined()) {
-            workerArguments.push(nodeToQueue);
-          }
         }
       }
 
@@ -3007,6 +2953,7 @@ void GitCommit::NthGenAncestorWorker::HandleOKCallback() {
       callback->Call(0, NULL, async_resource);
     }
 
+        git_commit_free(baton->ancestor);
   }
 
 
@@ -3023,7 +2970,7 @@ NAN_METHOD(GitCommit::Owner) {
   git_error_clear();
 
   { // lock master scope start
-    LockMaster lockMaster(
+    nodegit::LockMaster lockMaster(
       /*asyncAction: */false
             ,
               Nan::ObjectWrap::Unwrap<GitCommit>(info.This())->GetValue()
@@ -3038,19 +2985,19 @@ NAN_METHOD(GitCommit::Owner) {
           return info.GetReturnValue().Set(scope.Escape(Nan::Undefined()));
         }
 
-      v8::Local<v8::Value> to;
+      v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
     if (result != NULL) {
-        to = GitRepository::New(
+        v8ConversionSlot = GitRepository::New(
         result,
         true
        );
    }
   else {
-    to = Nan::Null();
+    v8ConversionSlot = Nan::Null();
   }
   // end convert_to_v8 block
-        return info.GetReturnValue().Set(scope.Escape(to));
+        return info.GetReturnValue().Set(scope.Escape(v8ConversionSlot));
   }
 }
   
@@ -3064,15 +3011,19 @@ NAN_METHOD(GitCommit::Parent) {
     return Nan::ThrowError("Number n is required.");
   }
 
-  if (info.Length() == 1 || !info[1]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  ParentBaton* baton = new ParentBaton;
+  ParentBaton* baton = new ParentBaton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
 
+
+  nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
+  std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
+
         baton->commit = Nan::ObjectWrap::Unwrap<GitCommit>(info.This())->GetValue();
 // start convert_from_v8 block
   unsigned int from_n;
@@ -3080,26 +3031,28 @@ NAN_METHOD(GitCommit::Parent) {
 // end convert_from_v8 block
           baton->n = from_n;
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[1]));
-  ParentWorker *worker = new ParentWorker(baton, callback);
-
-        worker->SaveToPersistent("commit", info.This());
-        if (!info[0]->IsUndefined() && !info[0]->IsNull())
-          worker->SaveToPersistent("n", Nan::To<v8::Object>(info[0]).ToLocalChecked());
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  ParentWorker *worker = new ParentWorker(baton, callback, cleanupHandles);
 
-  AsyncLibgit2QueueWorker(worker);
+        worker->Reference<GitCommit>("commit", info.This());
+           worker->Reference("n", info[0]);
+ 
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitCommit::ParentWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->commit
+  );
+
+  return lockMaster;
+}
+
 void GitCommit::ParentWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->commit
-    );
-
     int result = git_commit_parent(
 &baton->out,baton->commit,baton->n  );
 
@@ -3109,12 +3062,34 @@ void GitCommit::ParentWorker::Execute() {
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitCommit::ParentWorker::HandleErrorCallback() {
+  if (!GetIsCancelled()) {
+    v8::Local<v8::Object> err = Nan::To<v8::Object>(Nan::Error(ErrorMessage())).ToLocalChecked();
+    Nan::Set(err, Nan::New("errorFunction").ToLocalChecked(), Nan::New("Commit.parent").ToLocalChecked());
+    v8::Local<v8::Value> argv[1] = {
+      err
+    };
+    callback->Call(1, argv, async_resource);
+  }
+
+  if (baton->error) {
+    if (baton->error->message) {
+      free((void *)baton->error->message);
+    }
+
+    free((void *)baton->error);
   }
+
+      git_commit_free(baton->out);
+
+  delete baton;
 }
 
 void GitCommit::ParentWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
-    v8::Local<v8::Value> to;
+    v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
     if (baton->out != NULL) {
       v8::Local<v8::Array> owners = Nan::New<Array>(0);
@@ -3126,18 +3101,18 @@ void GitCommit::ParentWorker::HandleOKCallback() {
             true
           )).ToLocalChecked()
         );
-         to = GitCommit::New(
+         v8ConversionSlot = GitCommit::New(
         baton->out,
         true
           , owners
        );
    }
   else {
-    to = Nan::Null();
+    v8ConversionSlot = Nan::Null();
   }
   // end convert_to_v8 block
-      v8::Local<v8::Value> result = to;
-
+      v8::Local<v8::Value> result = v8ConversionSlot;
+       
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -3161,45 +3136,15 @@ void GitCommit::ParentWorker::HandleOKCallback() {
         free((void *)baton->error->message);
       free((void *)baton->error);
     } else if (baton->error_code < 0) {
-      std::queue< v8::Local<v8::Value> > workerArguments;
-              workerArguments.push(GetFromPersistent("n"));
       bool callbackFired = false;
-      while(!workerArguments.empty()) {
-        v8::Local<v8::Value> node = workerArguments.front();
-        workerArguments.pop();
-
-        if (
-          !node->IsObject()
-          || node->IsArray()
-          || node->IsBooleanObject()
-          || node->IsDate()
-          || node->IsFunction()
-          || node->IsNumberObject()
-          || node->IsRegExp()
-          || node->IsStringObject()
-        ) {
-          continue;
-        }
-
-        v8::Local<v8::Object> nodeObj = Nan::To<v8::Object>(node).ToLocalChecked();
-        v8::Local<v8::Value> checkValue = GetPrivate(nodeObj, Nan::New("NodeGitPromiseError").ToLocalChecked());
-
-        if (!checkValue.IsEmpty() && !checkValue->IsNull() && !checkValue->IsUndefined()) {
+      if (!callbackErrorHandle.IsEmpty()) {
+        v8::Local<v8::Value> maybeError = Nan::New(callbackErrorHandle);
+        if (!maybeError->IsNull() && !maybeError->IsUndefined()) {
           v8::Local<v8::Value> argv[1] = {
-            Nan::To<v8::Object>(checkValue).ToLocalChecked()
+            maybeError
           };
           callback->Call(1, argv, async_resource);
           callbackFired = true;
-          break;
-        }
-
-        v8::Local<v8::Array> properties = Nan::GetPropertyNames(nodeObj).ToLocalChecked();
-        for (unsigned int propIndex = 0; propIndex < properties->Length(); ++propIndex) {
-          v8::Local<v8::String> propName = Nan::To<v8::String>(Nan::Get(properties, propIndex).ToLocalChecked()).ToLocalChecked();
-          v8::Local<v8::Value> nodeToQueue = Nan::Get(nodeObj, propName).ToLocalChecked();
-          if (!nodeToQueue->IsUndefined()) {
-            workerArguments.push(nodeToQueue);
-          }
         }
       }
 
@@ -3216,6 +3161,7 @@ void GitCommit::ParentWorker::HandleOKCallback() {
       callback->Call(0, NULL, async_resource);
     }
 
+        git_commit_free(baton->out);
   }
 
 
@@ -3241,7 +3187,7 @@ NAN_METHOD(GitCommit::ParentId) {
   git_error_clear();
 
   { // lock master scope start
-    LockMaster lockMaster(
+    nodegit::LockMaster lockMaster(
       /*asyncAction: */false
             ,
               Nan::ObjectWrap::Unwrap<GitCommit>(info.This())->GetValue()
@@ -3257,22 +3203,22 @@ NAN_METHOD(GitCommit::ParentId) {
           return info.GetReturnValue().Set(scope.Escape(Nan::Undefined()));
         }
 
-      v8::Local<v8::Value> to;
+      v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
     if (result != NULL) {
       v8::Local<v8::Array> owners = Nan::New<Array>(0);
             Nan::Set(owners, owners->Length(), info.This());
-          to = GitOid::New(
+          v8ConversionSlot = GitOid::New(
         result,
         true
           , owners
        );
    }
   else {
-    to = Nan::Null();
+    v8ConversionSlot = Nan::Null();
   }
   // end convert_to_v8 block
-        return info.GetReturnValue().Set(scope.Escape(to));
+        return info.GetReturnValue().Set(scope.Escape(v8ConversionSlot));
   }
 }
    
@@ -3285,7 +3231,7 @@ NAN_METHOD(GitCommit::Parentcount) {
   git_error_clear();
 
   { // lock master scope start
-    LockMaster lockMaster(
+    nodegit::LockMaster lockMaster(
       /*asyncAction: */false
             ,
               Nan::ObjectWrap::Unwrap<GitCommit>(info.This())->GetValue()
@@ -3296,11 +3242,11 @@ NAN_METHOD(GitCommit::Parentcount) {
     );
 
 
-      v8::Local<v8::Value> to;
+      v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
-     to = Nan::New<Number>( result);
+     v8ConversionSlot = Nan::New<Number>( result);
   // end convert_to_v8 block
-        return info.GetReturnValue().Set(scope.Escape(to));
+        return info.GetReturnValue().Set(scope.Escape(v8ConversionSlot));
   }
 }
    
@@ -3313,7 +3259,7 @@ NAN_METHOD(GitCommit::RawHeader) {
   git_error_clear();
 
   { // lock master scope start
-    LockMaster lockMaster(
+    nodegit::LockMaster lockMaster(
       /*asyncAction: */false
             ,
               Nan::ObjectWrap::Unwrap<GitCommit>(info.This())->GetValue()
@@ -3328,17 +3274,17 @@ NAN_METHOD(GitCommit::RawHeader) {
           return info.GetReturnValue().Set(scope.Escape(Nan::Undefined()));
         }
 
-      v8::Local<v8::Value> to;
+      v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
   if (result){
-       to = Nan::New<v8::String>(result).ToLocalChecked();
+       v8ConversionSlot = Nan::New<v8::String>(result).ToLocalChecked();
    }
   else {
-    to = Nan::Null();
+    v8ConversionSlot = Nan::Null();
   }
 
   // end convert_to_v8 block
-        return info.GetReturnValue().Set(scope.Escape(to));
+        return info.GetReturnValue().Set(scope.Escape(v8ConversionSlot));
   }
 }
    
@@ -3351,7 +3297,7 @@ NAN_METHOD(GitCommit::Summary) {
   git_error_clear();
 
   { // lock master scope start
-    LockMaster lockMaster(
+    nodegit::LockMaster lockMaster(
       /*asyncAction: */false
             ,
               Nan::ObjectWrap::Unwrap<GitCommit>(info.This())->GetValue()
@@ -3366,17 +3312,17 @@ NAN_METHOD(GitCommit::Summary) {
           return info.GetReturnValue().Set(scope.Escape(Nan::Undefined()));
         }
 
-      v8::Local<v8::Value> to;
+      v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
   if (result){
-       to = Nan::New<v8::String>(result).ToLocalChecked();
+       v8ConversionSlot = Nan::New<v8::String>(result).ToLocalChecked();
    }
   else {
-    to = Nan::Null();
+    v8ConversionSlot = Nan::Null();
   }
 
   // end convert_to_v8 block
-        return info.GetReturnValue().Set(scope.Escape(to));
+        return info.GetReturnValue().Set(scope.Escape(v8ConversionSlot));
   }
 }
    
@@ -3389,7 +3335,7 @@ NAN_METHOD(GitCommit::Time) {
   git_error_clear();
 
   { // lock master scope start
-    LockMaster lockMaster(
+    nodegit::LockMaster lockMaster(
       /*asyncAction: */false
             ,
               Nan::ObjectWrap::Unwrap<GitCommit>(info.This())->GetValue()
@@ -3400,11 +3346,11 @@ NAN_METHOD(GitCommit::Time) {
     );
 
 
-      v8::Local<v8::Value> to;
+      v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
-     to = Nan::New<Number>( result);
+     v8ConversionSlot = Nan::New<Number>( result);
   // end convert_to_v8 block
-        return info.GetReturnValue().Set(scope.Escape(to));
+        return info.GetReturnValue().Set(scope.Escape(v8ConversionSlot));
   }
 }
    
@@ -3417,7 +3363,7 @@ NAN_METHOD(GitCommit::TimeOffset) {
   git_error_clear();
 
   { // lock master scope start
-    LockMaster lockMaster(
+    nodegit::LockMaster lockMaster(
       /*asyncAction: */false
             ,
               Nan::ObjectWrap::Unwrap<GitCommit>(info.This())->GetValue()
@@ -3428,11 +3374,11 @@ NAN_METHOD(GitCommit::TimeOffset) {
     );
 
 
-      v8::Local<v8::Value> to;
+      v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
-     to = Nan::New<Number>( result);
+     v8ConversionSlot = Nan::New<Number>( result);
   // end convert_to_v8 block
-        return info.GetReturnValue().Set(scope.Escape(to));
+        return info.GetReturnValue().Set(scope.Escape(v8ConversionSlot));
   }
 }
    
@@ -3454,7 +3400,7 @@ NAN_METHOD(GitCommit::Tree) {
   git_error_clear();
 
   { // lock master scope start
-    LockMaster lockMaster(
+    nodegit::LockMaster lockMaster(
       /*asyncAction: */false
             ,
               from_tree_out
@@ -3468,11 +3414,11 @@ NAN_METHOD(GitCommit::Tree) {
     );
 
 
-      v8::Local<v8::Value> to;
+      v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
-     to = Nan::New<Number>( result);
+     v8ConversionSlot = Nan::New<Number>( result);
   // end convert_to_v8 block
-        return info.GetReturnValue().Set(scope.Escape(to));
+        return info.GetReturnValue().Set(scope.Escape(v8ConversionSlot));
   }
 }
    
@@ -3485,7 +3431,7 @@ NAN_METHOD(GitCommit::TreeId) {
   git_error_clear();
 
   { // lock master scope start
-    LockMaster lockMaster(
+    nodegit::LockMaster lockMaster(
       /*asyncAction: */false
             ,
               Nan::ObjectWrap::Unwrap<GitCommit>(info.This())->GetValue()
@@ -3500,22 +3446,22 @@ NAN_METHOD(GitCommit::TreeId) {
           return info.GetReturnValue().Set(scope.Escape(Nan::Undefined()));
         }
 
-      v8::Local<v8::Value> to;
+      v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
     if (result != NULL) {
       v8::Local<v8::Array> owners = Nan::New<Array>(0);
             Nan::Set(owners, owners->Length(), info.This());
-          to = GitOid::New(
+          v8ConversionSlot = GitOid::New(
         result,
         true
           , owners
        );
    }
   else {
-    to = Nan::Null();
+    v8ConversionSlot = Nan::Null();
   }
   // end convert_to_v8 block
-        return info.GetReturnValue().Set(scope.Escape(to));
+        return info.GetReturnValue().Set(scope.Escape(v8ConversionSlot));
   }
 }
     // force base class template instantiation, to make sure we get all the