pj-nodegit 0.27.1 → 0.28.2

package/src/diff.cc

@@ -13,7 +13,6 @@ extern "C" {
 #include "../include/functions/copy.h"
 #include "../include/diff.h"
 #include "nodegit_wrapper.cc"
-#include "../include/async_libgit2_queue_worker.h"
 
   #include "../include/blob.h"
   #include "../include/diff_options.h"
@@ -43,37 +42,38 @@ using namespace node;
     // way of knowing to free these values.
                                                                                                 }
 
-  void GitDiff::InitializeComponent(v8::Local<v8::Object> target) {
+  void GitDiff::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("Diff").ToLocalChecked());
 
-           Nan::SetMethod(tpl, "blobToBuffer", BlobToBuffer);
-            Nan::SetPrototypeMethod(tpl, "findSimilar", FindSimilar);
-             Nan::SetMethod(tpl, "fromBuffer", FromBuffer);
-            Nan::SetPrototypeMethod(tpl, "getDelta", GetDelta);
-            Nan::SetPrototypeMethod(tpl, "getStats", GetStats);
-             Nan::SetMethod(tpl, "indexToIndex", IndexToIndex);
-             Nan::SetMethod(tpl, "indexToWorkdir", IndexToWorkdir);
-            Nan::SetPrototypeMethod(tpl, "isSortedIcase", IsSortedIcase);
-            Nan::SetPrototypeMethod(tpl, "merge", Merge);
-            Nan::SetPrototypeMethod(tpl, "numDeltas", NumDeltas);
-            Nan::SetPrototypeMethod(tpl, "patchid", Patchid);
-            Nan::SetPrototypeMethod(tpl, "toBuf", ToBuf);
-             Nan::SetMethod(tpl, "treeToIndex", TreeToIndex);
-             Nan::SetMethod(tpl, "treeToTree", TreeToTree);
-             Nan::SetMethod(tpl, "treeToWorkdir", TreeToWorkdir);
-             Nan::SetMethod(tpl, "treeToWorkdirWithIndex", TreeToWorkdirWithIndex);
-            Nan::SetPrototypeMethod(tpl, "getPerfdata", GetPerfdata);
+           Nan::SetMethod(tpl, "blobToBuffer", BlobToBuffer, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "findSimilar", FindSimilar, nodegitExternal);
+             Nan::SetMethod(tpl, "fromBuffer", FromBuffer, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "getDelta", GetDelta, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "getStats", GetStats, nodegitExternal);
+             Nan::SetMethod(tpl, "indexToIndex", IndexToIndex, nodegitExternal);
+             Nan::SetMethod(tpl, "indexToWorkdir", IndexToWorkdir, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "isSortedIcase", IsSortedIcase, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "merge", Merge, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "numDeltas", NumDeltas, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "patchid", Patchid, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "toBuf", ToBuf, nodegitExternal);
+             Nan::SetMethod(tpl, "treeToIndex", TreeToIndex, nodegitExternal);
+             Nan::SetMethod(tpl, "treeToTree", TreeToTree, nodegitExternal);
+             Nan::SetMethod(tpl, "treeToWorkdir", TreeToWorkdir, nodegitExternal);
+             Nan::SetMethod(tpl, "treeToWorkdirWithIndex", TreeToWorkdirWithIndex, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "getPerfdata", GetPerfdata, nodegitExternal);
     
     InitializeTemplate(tpl);
 
-    v8::Local<Function> _constructor_template = Nan::GetFunction(tpl).ToLocalChecked();
-    constructor_template.Reset(_constructor_template);
-    Nan::Set(target, Nan::New("Diff").ToLocalChecked(), _constructor_template);
+    v8::Local<Function> constructor_template = Nan::GetFunction(tpl).ToLocalChecked();
+    nodegitContext->SaveToPersistent("GitDiff::Template", constructor_template);
+    Nan::Set(target, Nan::New("Diff").ToLocalChecked(), constructor_template);
   }
 
  
@@ -92,19 +92,23 @@ using namespace node;
      */
 NAN_METHOD(GitDiff::BlobToBuffer) {
 
-  if (info.Length() == 11 || !info[11]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  BlobToBufferBaton* baton = new BlobToBufferBaton;
+  BlobToBufferBaton* baton = new BlobToBufferBaton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
 
       BlobToBuffer_globalPayload* globalPayload = new BlobToBuffer_globalPayload;
+
+  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
   const git_blob * from_old_blob = NULL;
-    if (info[0]->IsObject()) {
+    if ((info.Length() - 1) > 0 && info[0]->IsObject()) {
 from_old_blob = Nan::ObjectWrap::Unwrap<GitBlob>(Nan::To<v8::Object>(info[0]).ToLocalChecked())->GetValue();
   }
   else {
@@ -114,7 +118,7 @@ from_old_blob = Nan::ObjectWrap::Unwrap<GitBlob>(Nan::To<v8::Object>(info[0]).To
           baton->old_blob = from_old_blob;
 // start convert_from_v8 block
   const char * from_old_as_path = NULL;
-    if (info[1]->IsString()) {
+    if ((info.Length() - 1) > 1 && info[1]->IsString()) {
 
   Nan::Utf8String old_as_path(Nan::To<v8::String>(info[1]).ToLocalChecked());
   // malloc with one extra byte so we can add the terminating null character C-strings expect:
@@ -133,7 +137,7 @@ from_old_blob = Nan::ObjectWrap::Unwrap<GitBlob>(Nan::To<v8::Object>(info[0]).To
           baton->old_as_path = from_old_as_path;
 // start convert_from_v8 block
   const char * from_buffer = NULL;
-    if (info[2]->IsString()) {
+    if ((info.Length() - 1) > 2 && info[2]->IsString()) {
 
   Nan::Utf8String buffer(Nan::To<v8::String>(info[2]).ToLocalChecked());
   // malloc with one extra byte so we can add the terminating null character C-strings expect:
@@ -152,7 +156,7 @@ from_old_blob = Nan::ObjectWrap::Unwrap<GitBlob>(Nan::To<v8::Object>(info[0]).To
           baton->buffer = from_buffer;
 // start convert_from_v8 block
   size_t from_buffer_len;
-    if (info[3]->IsNumber()) {
+    if ((info.Length() - 1) > 3 && info[3]->IsNumber()) {
       from_buffer_len = (size_t)   info[3].As<v8::Number>()->Value();
   }
   else {
@@ -162,7 +166,7 @@ from_old_blob = Nan::ObjectWrap::Unwrap<GitBlob>(Nan::To<v8::Object>(info[0]).To
           baton->buffer_len = from_buffer_len;
 // start convert_from_v8 block
   const char * from_buffer_as_path = NULL;
-    if (info[4]->IsString()) {
+    if ((info.Length() - 1) > 4 && info[4]->IsString()) {
 
   Nan::Utf8String buffer_as_path(Nan::To<v8::String>(info[4]).ToLocalChecked());
   // malloc with one extra byte so we can add the terminating null character C-strings expect:
@@ -179,17 +183,20 @@ from_old_blob = Nan::ObjectWrap::Unwrap<GitBlob>(Nan::To<v8::Object>(info[0]).To
   }
 // end convert_from_v8 block
           baton->buffer_as_path = from_buffer_as_path;
-// start convert_from_v8 block
-  const git_diff_options * from_options = NULL;
-    if (info[5]->IsObject()) {
-from_options = Nan::ObjectWrap::Unwrap<GitDiffOptions>(Nan::To<v8::Object>(info[5]).ToLocalChecked())->GetValue();
-  }
-  else {
-    from_options = 0;
-  }
-// end convert_from_v8 block
-          baton->options = from_options;
-        if (!info[6]->IsFunction()) {
+          if (info[5]->IsNull() || info[5]->IsUndefined()) {
+            baton->options = nullptr;
+          } else
+            {
+            auto conversionResult = ConfigurableGitDiffOptions::fromJavascript(nodegitContext, info[5]);
+            if (!conversionResult.result) {
+              return Nan::ThrowError(Nan::New(conversionResult.error).ToLocalChecked());
+            }
+
+            auto convertedObject = conversionResult.result;
+            cleanupHandles["options"] = convertedObject;
+            baton->options = convertedObject->GetValue();
+          }
+         if (!info[6]->IsFunction()) {
           baton->file_cb = NULL;
           globalPayload->file_cb = NULL;
         }
@@ -223,42 +230,38 @@ from_options = Nan::ObjectWrap::Unwrap<GitDiffOptions>(Nan::To<v8::Object>(info[
         }
           baton->payload = globalPayload;
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[11]));
-  BlobToBufferWorker *worker = new BlobToBufferWorker(baton, callback);
-
-        if (!info[0]->IsUndefined() && !info[0]->IsNull())
-          worker->SaveToPersistent("old_blob", Nan::To<v8::Object>(info[0]).ToLocalChecked());
-        if (!info[1]->IsUndefined() && !info[1]->IsNull())
-          worker->SaveToPersistent("old_as_path", Nan::To<v8::Object>(info[1]).ToLocalChecked());
-        if (!info[2]->IsUndefined() && !info[2]->IsNull())
-          worker->SaveToPersistent("buffer", Nan::To<v8::Object>(info[2]).ToLocalChecked());
-        if (!info[3]->IsUndefined() && !info[3]->IsNull())
-          worker->SaveToPersistent("buffer_len", Nan::To<v8::Object>(info[3]).ToLocalChecked());
-        if (!info[4]->IsUndefined() && !info[4]->IsNull())
-          worker->SaveToPersistent("buffer_as_path", Nan::To<v8::Object>(info[4]).ToLocalChecked());
-        if (!info[5]->IsUndefined() && !info[5]->IsNull())
-          worker->SaveToPersistent("options", Nan::To<v8::Object>(info[5]).ToLocalChecked());
-        if (!info[10]->IsUndefined() && !info[10]->IsNull())
-          worker->SaveToPersistent("payload", Nan::To<v8::Object>(info[10]).ToLocalChecked());
-
-  AsyncLibgit2QueueWorker(worker);
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  BlobToBufferWorker *worker = new BlobToBufferWorker(baton, callback, cleanupHandles);
+
+             worker->Reference<GitBlob>("old_blob", info[0]);
+             worker->Reference("old_as_path", info[1]);
+            worker->Reference("buffer", info[2]);
+            worker->Reference("buffer_len", info[3]);
+            worker->Reference("buffer_as_path", info[4]);
+            worker->Reference("options", info[5]);
+            worker->Reference("payload", info[10]);
+ 
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitDiff::BlobToBufferWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->old_blob
+          ,baton->old_as_path
+          ,baton->buffer
+          ,baton->buffer_as_path
+          ,baton->options
+          ,baton->payload
+  );
+
+  return lockMaster;
+}
+
 void GitDiff::BlobToBufferWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->old_blob
-            ,baton->old_as_path
-            ,baton->buffer
-            ,baton->buffer_as_path
-            ,baton->options
-            ,baton->payload
-    );
-
     int result = git_diff_blob_to_buffer(
 baton->old_blob,baton->old_as_path,baton->buffer,baton->buffer_len,baton->buffer_as_path,baton->options,baton->file_cb,baton->binary_cb,baton->hunk_cb,baton->line_cb,baton->payload  );
 
@@ -268,13 +271,35 @@ baton->old_blob,baton->old_as_path,baton->buffer,baton->buffer_len,baton->buffer
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitDiff::BlobToBufferWorker::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("Diff.blobToBuffer").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 (BlobToBuffer_globalPayload*)baton->payload;
+
+  delete baton;
 }
 
 void GitDiff::BlobToBufferWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
     v8::Local<v8::Value> result = Nan::Undefined();
-
+                        
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -298,51 +323,15 @@ void GitDiff::BlobToBufferWorker::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("old_blob"));
-              workerArguments.push(GetFromPersistent("old_as_path"));
-              workerArguments.push(GetFromPersistent("buffer"));
-              workerArguments.push(GetFromPersistent("buffer_len"));
-              workerArguments.push(GetFromPersistent("buffer_as_path"));
-              workerArguments.push(GetFromPersistent("options"));
-              workerArguments.push(GetFromPersistent("payload"));
       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);
-          }
         }
       }
 
@@ -375,7 +364,13 @@ int GitDiff::BlobToBuffer_file_cb_cppCallback (
     baton.progress = progress;
     baton.payload = payload;
  
-  return baton.ExecuteAsync(BlobToBuffer_file_cb_async);
+  return baton.ExecuteAsync(BlobToBuffer_file_cb_async, BlobToBuffer_file_cb_cancelAsync);
+}
+
+void GitDiff::BlobToBuffer_file_cb_cancelAsync(void *untypedBaton) {
+  BlobToBuffer_FileCbBaton* baton = static_cast<BlobToBuffer_FileCbBaton*>(untypedBaton);
+  baton->result = -1;
+  baton->Done();
 }
 
 void GitDiff::BlobToBuffer_file_cb_async(void *untypedBaton) {
@@ -391,8 +386,8 @@ void GitDiff::BlobToBuffer_file_cb_async(void *untypedBaton) {
     };
 
   Nan::TryCatch tryCatch;
-  // TODO This should take an async_resource, but we will need to figure out how to pipe the correct context into this
-  Nan::MaybeLocal<v8::Value> maybeResult = Nan::Call(*callback, 2, argv);
+  Nan::MaybeLocal<v8::Value> maybeResult = (*callback)(baton->GetAsyncResource(), 2, argv);
+
   v8::Local<v8::Value> result;
   if (!maybeResult.IsEmpty()) {
     result = maybeResult.ToLocalChecked();
@@ -420,7 +415,7 @@ void GitDiff::BlobToBuffer_file_cb_async(void *untypedBaton) {
   baton->Done();
 }
 
-void GitDiff::BlobToBuffer_file_cb_promiseCompleted(bool isFulfilled, AsyncBaton *_baton, v8::Local<v8::Value> result) {
+void GitDiff::BlobToBuffer_file_cb_promiseCompleted(bool isFulfilled, nodegit::AsyncBaton *_baton, v8::Local<v8::Value> result) {
   Nan::HandleScope scope;
 
   BlobToBuffer_FileCbBaton* baton = static_cast<BlobToBuffer_FileCbBaton*>(_baton);
@@ -460,7 +455,13 @@ int GitDiff::BlobToBuffer_binary_cb_cppCallback (
     baton.binary = binary;
     baton.payload = payload;
  
-  return baton.ExecuteAsync(BlobToBuffer_binary_cb_async);
+  return baton.ExecuteAsync(BlobToBuffer_binary_cb_async, BlobToBuffer_binary_cb_cancelAsync);
+}
+
+void GitDiff::BlobToBuffer_binary_cb_cancelAsync(void *untypedBaton) {
+  BlobToBuffer_BinaryCbBaton* baton = static_cast<BlobToBuffer_BinaryCbBaton*>(untypedBaton);
+  baton->result = -1;
+  baton->Done();
 }
 
 void GitDiff::BlobToBuffer_binary_cb_async(void *untypedBaton) {
@@ -476,8 +477,8 @@ void GitDiff::BlobToBuffer_binary_cb_async(void *untypedBaton) {
     };
 
   Nan::TryCatch tryCatch;
-  // TODO This should take an async_resource, but we will need to figure out how to pipe the correct context into this
-  Nan::MaybeLocal<v8::Value> maybeResult = Nan::Call(*callback, 2, argv);
+  Nan::MaybeLocal<v8::Value> maybeResult = (*callback)(baton->GetAsyncResource(), 2, argv);
+
   v8::Local<v8::Value> result;
   if (!maybeResult.IsEmpty()) {
     result = maybeResult.ToLocalChecked();
@@ -505,7 +506,7 @@ void GitDiff::BlobToBuffer_binary_cb_async(void *untypedBaton) {
   baton->Done();
 }
 
-void GitDiff::BlobToBuffer_binary_cb_promiseCompleted(bool isFulfilled, AsyncBaton *_baton, v8::Local<v8::Value> result) {
+void GitDiff::BlobToBuffer_binary_cb_promiseCompleted(bool isFulfilled, nodegit::AsyncBaton *_baton, v8::Local<v8::Value> result) {
   Nan::HandleScope scope;
 
   BlobToBuffer_BinaryCbBaton* baton = static_cast<BlobToBuffer_BinaryCbBaton*>(_baton);
@@ -545,7 +546,13 @@ int GitDiff::BlobToBuffer_hunk_cb_cppCallback (
     baton.hunk = hunk;
     baton.payload = payload;
  
-  return baton.ExecuteAsync(BlobToBuffer_hunk_cb_async);
+  return baton.ExecuteAsync(BlobToBuffer_hunk_cb_async, BlobToBuffer_hunk_cb_cancelAsync);
+}
+
+void GitDiff::BlobToBuffer_hunk_cb_cancelAsync(void *untypedBaton) {
+  BlobToBuffer_HunkCbBaton* baton = static_cast<BlobToBuffer_HunkCbBaton*>(untypedBaton);
+  baton->result = -1;
+  baton->Done();
 }
 
 void GitDiff::BlobToBuffer_hunk_cb_async(void *untypedBaton) {
@@ -561,8 +568,8 @@ void GitDiff::BlobToBuffer_hunk_cb_async(void *untypedBaton) {
     };
 
   Nan::TryCatch tryCatch;
-  // TODO This should take an async_resource, but we will need to figure out how to pipe the correct context into this
-  Nan::MaybeLocal<v8::Value> maybeResult = Nan::Call(*callback, 2, argv);
+  Nan::MaybeLocal<v8::Value> maybeResult = (*callback)(baton->GetAsyncResource(), 2, argv);
+
   v8::Local<v8::Value> result;
   if (!maybeResult.IsEmpty()) {
     result = maybeResult.ToLocalChecked();
@@ -590,7 +597,7 @@ void GitDiff::BlobToBuffer_hunk_cb_async(void *untypedBaton) {
   baton->Done();
 }
 
-void GitDiff::BlobToBuffer_hunk_cb_promiseCompleted(bool isFulfilled, AsyncBaton *_baton, v8::Local<v8::Value> result) {
+void GitDiff::BlobToBuffer_hunk_cb_promiseCompleted(bool isFulfilled, nodegit::AsyncBaton *_baton, v8::Local<v8::Value> result) {
   Nan::HandleScope scope;
 
   BlobToBuffer_HunkCbBaton* baton = static_cast<BlobToBuffer_HunkCbBaton*>(_baton);
@@ -631,7 +638,13 @@ int GitDiff::BlobToBuffer_line_cb_cppCallback (
     baton.line = line;
     baton.payload = payload;
  
-  return baton.ExecuteAsync(BlobToBuffer_line_cb_async);
+  return baton.ExecuteAsync(BlobToBuffer_line_cb_async, BlobToBuffer_line_cb_cancelAsync);
+}
+
+void GitDiff::BlobToBuffer_line_cb_cancelAsync(void *untypedBaton) {
+  BlobToBuffer_LineCbBaton* baton = static_cast<BlobToBuffer_LineCbBaton*>(untypedBaton);
+  baton->result = -1;
+  baton->Done();
 }
 
 void GitDiff::BlobToBuffer_line_cb_async(void *untypedBaton) {
@@ -648,8 +661,8 @@ void GitDiff::BlobToBuffer_line_cb_async(void *untypedBaton) {
     };
 
   Nan::TryCatch tryCatch;
-  // TODO This should take an async_resource, but we will need to figure out how to pipe the correct context into this
-  Nan::MaybeLocal<v8::Value> maybeResult = Nan::Call(*callback, 3, argv);
+  Nan::MaybeLocal<v8::Value> maybeResult = (*callback)(baton->GetAsyncResource(), 3, argv);
+
   v8::Local<v8::Value> result;
   if (!maybeResult.IsEmpty()) {
     result = maybeResult.ToLocalChecked();
@@ -677,7 +690,7 @@ void GitDiff::BlobToBuffer_line_cb_async(void *untypedBaton) {
   baton->Done();
 }
 
-void GitDiff::BlobToBuffer_line_cb_promiseCompleted(bool isFulfilled, AsyncBaton *_baton, v8::Local<v8::Value> result) {
+void GitDiff::BlobToBuffer_line_cb_promiseCompleted(bool isFulfilled, nodegit::AsyncBaton *_baton, v8::Local<v8::Value> result) {
   Nan::HandleScope scope;
 
   BlobToBuffer_LineCbBaton* baton = static_cast<BlobToBuffer_LineCbBaton*>(_baton);
@@ -714,48 +727,57 @@ void GitDiff::BlobToBuffer_line_cb_promiseCompleted(bool isFulfilled, AsyncBaton
      */
 NAN_METHOD(GitDiff::FindSimilar) {
 
-  if (info.Length() == 1 || !info[1]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  FindSimilarBaton* baton = new FindSimilarBaton;
+  FindSimilarBaton* baton = new FindSimilarBaton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
 
-        baton->diff = Nan::ObjectWrap::Unwrap<GitDiff>(info.This())->GetValue();
-// start convert_from_v8 block
-  const git_diff_find_options * from_options = NULL;
-    if (info[0]->IsObject()) {
-from_options = Nan::ObjectWrap::Unwrap<GitDiffFindOptions>(Nan::To<v8::Object>(info[0]).ToLocalChecked())->GetValue();
-  }
-  else {
-    from_options = 0;
-  }
-// end convert_from_v8 block
-          baton->options = from_options;
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[1]));
-  FindSimilarWorker *worker = new FindSimilarWorker(baton, callback);
+  nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
+  std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
 
-        worker->SaveToPersistent("diff", info.This());
-        if (!info[0]->IsUndefined() && !info[0]->IsNull())
-          worker->SaveToPersistent("options", Nan::To<v8::Object>(info[0]).ToLocalChecked());
+        baton->diff = Nan::ObjectWrap::Unwrap<GitDiff>(info.This())->GetValue();
+          if (info[0]->IsNull() || info[0]->IsUndefined()) {
+            baton->options = nullptr;
+          } else
+            {
+            auto conversionResult = ConfigurableGitDiffFindOptions::fromJavascript(nodegitContext, info[0]);
+            if (!conversionResult.result) {
+              return Nan::ThrowError(Nan::New(conversionResult.error).ToLocalChecked());
+            }
+
+            auto convertedObject = conversionResult.result;
+            cleanupHandles["options"] = convertedObject;
+            baton->options = convertedObject->GetValue();
+          }
+ 
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  FindSimilarWorker *worker = new FindSimilarWorker(baton, callback, cleanupHandles);
 
-  AsyncLibgit2QueueWorker(worker);
+        worker->Reference<GitDiff>("diff", info.This());
+           worker->Reference("options", info[0]);
+ 
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitDiff::FindSimilarWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->diff
+          ,baton->options
+  );
+
+  return lockMaster;
+}
+
 void GitDiff::FindSimilarWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->diff
-            ,baton->options
-    );
-
     int result = git_diff_find_similar(
 baton->diff,baton->options  );
 
@@ -765,13 +787,34 @@ baton->diff,baton->options  );
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitDiff::FindSimilarWorker::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("Diff.findSimilar").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 GitDiff::FindSimilarWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
     v8::Local<v8::Value> result = Nan::Undefined();
-
+      
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -795,45 +838,15 @@ void GitDiff::FindSimilarWorker::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("options"));
       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);
-          }
         }
       }
 
@@ -872,15 +885,19 @@ NAN_METHOD(GitDiff::FromBuffer) {
     return Nan::ThrowError("Number content_len 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.");
   }
 
-  FromBufferBaton* baton = new FromBufferBaton;
+  FromBufferBaton* baton = new FromBufferBaton();
 
   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
   const char * from_content = NULL;
 
@@ -901,27 +918,28 @@ NAN_METHOD(GitDiff::FromBuffer) {
 // end convert_from_v8 block
           baton->content_len = from_content_len;
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[2]));
-  FromBufferWorker *worker = new FromBufferWorker(baton, callback);
-
-        if (!info[0]->IsUndefined() && !info[0]->IsNull())
-          worker->SaveToPersistent("content", Nan::To<v8::Object>(info[0]).ToLocalChecked());
-        if (!info[1]->IsUndefined() && !info[1]->IsNull())
-          worker->SaveToPersistent("content_len", Nan::To<v8::Object>(info[1]).ToLocalChecked());
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  FromBufferWorker *worker = new FromBufferWorker(baton, callback, cleanupHandles);
 
-  AsyncLibgit2QueueWorker(worker);
+           worker->Reference("content", info[0]);
+            worker->Reference("content_len", info[1]);
+ 
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitDiff::FromBufferWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->content
+  );
+
+  return lockMaster;
+}
+
 void GitDiff::FromBufferWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->content
-    );
-
     int result = git_diff_from_buffer(
 &baton->out,baton->content,baton->content_len  );
 
@@ -931,25 +949,47 @@ void GitDiff::FromBufferWorker::Execute() {
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitDiff::FromBufferWorker::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("Diff.fromBuffer").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_diff_free(baton->out);
+
+  delete baton;
 }
 
 void GitDiff::FromBufferWorker::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 = GitDiff::New(
+        v8ConversionSlot = GitDiff::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
@@ -973,46 +1013,15 @@ void GitDiff::FromBufferWorker::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("content"));
-              workerArguments.push(GetFromPersistent("content_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);
-          }
         }
       }
 
@@ -1029,6 +1038,7 @@ void GitDiff::FromBufferWorker::HandleOKCallback() {
       callback->Call(0, NULL, async_resource);
     }
 
+        git_diff_free(baton->out);
   }
 
 
@@ -1054,7 +1064,7 @@ NAN_METHOD(GitDiff::GetDelta) {
   git_error_clear();
 
   { // lock master scope start
-    LockMaster lockMaster(
+    nodegit::LockMaster lockMaster(
       /*asyncAction: */false
             ,
               Nan::ObjectWrap::Unwrap<GitDiff>(info.This())->GetValue()
@@ -1070,19 +1080,19 @@ NAN_METHOD(GitDiff::GetDelta) {
           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 = GitDiffDelta::New(
+        v8ConversionSlot = GitDiffDelta::New(
         result,
         false
        );
    }
   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));
   }
 }
   
@@ -1091,35 +1101,42 @@ NAN_METHOD(GitDiff::GetDelta) {
    */
 NAN_METHOD(GitDiff::GetStats) {
 
-  if (info.Length() == 0 || !info[0]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  GetStatsBaton* baton = new GetStatsBaton;
+  GetStatsBaton* baton = new GetStatsBaton();
 
   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->diff = Nan::ObjectWrap::Unwrap<GitDiff>(info.This())->GetValue();
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[0]));
-  GetStatsWorker *worker = new GetStatsWorker(baton, callback);
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  GetStatsWorker *worker = new GetStatsWorker(baton, callback, cleanupHandles);
 
-        worker->SaveToPersistent("diff", info.This());
+        worker->Reference<GitDiff>("diff", info.This());
 
-  AsyncLibgit2QueueWorker(worker);
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitDiff::GetStatsWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->diff
+  );
+
+  return lockMaster;
+}
+
 void GitDiff::GetStatsWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->diff
-    );
-
     int result = git_diff_get_stats(
 &baton->out,baton->diff  );
 
@@ -1129,28 +1146,49 @@ void GitDiff::GetStatsWorker::Execute() {
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitDiff::GetStatsWorker::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("Diff.getStats").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 GitDiff::GetStatsWorker::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);
             Nan::Set(owners, Nan::New<v8::Number>(owners->Length()), Nan::To<v8::Object>(this->GetFromPersistent("diff")).ToLocalChecked());
-             to = GitDiffStats::New(
+             v8ConversionSlot = GitDiffStats::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
@@ -1174,44 +1212,15 @@ void GitDiff::GetStatsWorker::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);
-          }
         }
       }
 
@@ -1260,15 +1269,19 @@ NAN_METHOD(GitDiff::IndexToIndex) {
     return Nan::ThrowError("DiffOptions opts 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.");
   }
 
-  IndexToIndexBaton* baton = new IndexToIndexBaton;
+  IndexToIndexBaton* baton = new IndexToIndexBaton();
 
   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();
@@ -1284,40 +1297,44 @@ from_old_index = Nan::ObjectWrap::Unwrap<GitIndex>(Nan::To<v8::Object>(info[1]).
 from_new_index = Nan::ObjectWrap::Unwrap<GitIndex>(Nan::To<v8::Object>(info[2]).ToLocalChecked())->GetValue();
 // end convert_from_v8 block
           baton->new_index = from_new_index;
-// start convert_from_v8 block
-  const git_diff_options * from_opts = NULL;
-from_opts = Nan::ObjectWrap::Unwrap<GitDiffOptions>(Nan::To<v8::Object>(info[3]).ToLocalChecked())->GetValue();
-// end convert_from_v8 block
-          baton->opts = from_opts;
+            {
+            auto conversionResult = ConfigurableGitDiffOptions::fromJavascript(nodegitContext, info[3]);
+            if (!conversionResult.result) {
+              return Nan::ThrowError(Nan::New(conversionResult.error).ToLocalChecked());
+            }
+
+            auto convertedObject = conversionResult.result;
+            cleanupHandles["opts"] = convertedObject;
+            baton->opts = convertedObject->GetValue();
+          }
+ 
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  IndexToIndexWorker *worker = new IndexToIndexWorker(baton, callback, cleanupHandles);
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[4]));
-  IndexToIndexWorker *worker = new IndexToIndexWorker(baton, callback);
+             worker->Reference<GitRepository>("repo", info[0]);
+               worker->Reference<GitIndex>("old_index", info[1]);
+               worker->Reference<GitIndex>("new_index", info[2]);
+             worker->Reference("opts", info[3]);
+ 
+  nodegitContext->QueueWorker(worker);
+  return;
+}
 
-        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("old_index", Nan::To<v8::Object>(info[1]).ToLocalChecked());
-        if (!info[2]->IsUndefined() && !info[2]->IsNull())
-          worker->SaveToPersistent("new_index", Nan::To<v8::Object>(info[2]).ToLocalChecked());
-        if (!info[3]->IsUndefined() && !info[3]->IsNull())
-          worker->SaveToPersistent("opts", Nan::To<v8::Object>(info[3]).ToLocalChecked());
+nodegit::LockMaster GitDiff::IndexToIndexWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->repo
+          ,baton->old_index
+          ,baton->new_index
+          ,baton->opts
+  );
 
-  AsyncLibgit2QueueWorker(worker);
-  return;
+  return lockMaster;
 }
 
 void GitDiff::IndexToIndexWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->repo
-            ,baton->old_index
-            ,baton->new_index
-            ,baton->opts
-    );
-
     int result = git_diff_index_to_index(
 &baton->diff,baton->repo,baton->old_index,baton->new_index,baton->opts  );
 
@@ -1327,28 +1344,50 @@ void GitDiff::IndexToIndexWorker::Execute() {
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitDiff::IndexToIndexWorker::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("Diff.indexToIndex").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_diff_free(baton->diff);
+
+  delete baton;
 }
 
 void GitDiff::IndexToIndexWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
-    v8::Local<v8::Value> to;
+    v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
     if (baton->diff != NULL) {
       v8::Local<v8::Array> owners = Nan::New<Array>(0);
             Nan::Set(owners, Nan::New<v8::Number>(owners->Length()), Nan::To<v8::Object>(this->GetFromPersistent("repo")).ToLocalChecked());
-             to = GitDiff::New(
+             v8ConversionSlot = GitDiff::New(
         baton->diff,
         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
@@ -1372,48 +1411,15 @@ void GitDiff::IndexToIndexWorker::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("old_index"));
-              workerArguments.push(GetFromPersistent("new_index"));
-              workerArguments.push(GetFromPersistent("opts"));
       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);
-          }
         }
       }
 
@@ -1430,6 +1436,7 @@ void GitDiff::IndexToIndexWorker::HandleOKCallback() {
       callback->Call(0, NULL, async_resource);
     }
 
+        git_diff_free(baton->diff);
   }
 
 
@@ -1449,15 +1456,19 @@ NAN_METHOD(GitDiff::IndexToWorkdir) {
     return Nan::ThrowError("Repository repo 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.");
   }
 
-  IndexToWorkdirBaton* baton = new IndexToWorkdirBaton;
+  IndexToWorkdirBaton* baton = new IndexToWorkdirBaton();
 
   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();
@@ -1465,7 +1476,7 @@ from_repo = Nan::ObjectWrap::Unwrap<GitRepository>(Nan::To<v8::Object>(info[0]).
           baton->repo = from_repo;
 // start convert_from_v8 block
   git_index * from_index = NULL;
-    if (info[1]->IsObject()) {
+    if ((info.Length() - 1) > 1 && info[1]->IsObject()) {
 from_index = Nan::ObjectWrap::Unwrap<GitIndex>(Nan::To<v8::Object>(info[1]).ToLocalChecked())->GetValue();
   }
   else {
@@ -1473,42 +1484,45 @@ from_index = Nan::ObjectWrap::Unwrap<GitIndex>(Nan::To<v8::Object>(info[1]).ToLo
   }
 // end convert_from_v8 block
           baton->index = from_index;
-// start convert_from_v8 block
-  const git_diff_options * from_opts = NULL;
-    if (info[2]->IsObject()) {
-from_opts = Nan::ObjectWrap::Unwrap<GitDiffOptions>(Nan::To<v8::Object>(info[2]).ToLocalChecked())->GetValue();
-  }
-  else {
-    from_opts = 0;
-  }
-// end convert_from_v8 block
-          baton->opts = from_opts;
+          if (info[2]->IsNull() || info[2]->IsUndefined()) {
+            baton->opts = nullptr;
+          } else
+            {
+            auto conversionResult = ConfigurableGitDiffOptions::fromJavascript(nodegitContext, info[2]);
+            if (!conversionResult.result) {
+              return Nan::ThrowError(Nan::New(conversionResult.error).ToLocalChecked());
+            }
+
+            auto convertedObject = conversionResult.result;
+            cleanupHandles["opts"] = convertedObject;
+            baton->opts = convertedObject->GetValue();
+          }
+ 
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  IndexToWorkdirWorker *worker = new IndexToWorkdirWorker(baton, callback, cleanupHandles);
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[3]));
-  IndexToWorkdirWorker *worker = new IndexToWorkdirWorker(baton, callback);
+             worker->Reference<GitRepository>("repo", info[0]);
+               worker->Reference<GitIndex>("index", info[1]);
+             worker->Reference("opts", info[2]);
+ 
+  nodegitContext->QueueWorker(worker);
+  return;
+}
 
-        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("index", Nan::To<v8::Object>(info[1]).ToLocalChecked());
-        if (!info[2]->IsUndefined() && !info[2]->IsNull())
-          worker->SaveToPersistent("opts", Nan::To<v8::Object>(info[2]).ToLocalChecked());
+nodegit::LockMaster GitDiff::IndexToWorkdirWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->repo
+          ,baton->index
+          ,baton->opts
+  );
 
-  AsyncLibgit2QueueWorker(worker);
-  return;
+  return lockMaster;
 }
 
 void GitDiff::IndexToWorkdirWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->repo
-            ,baton->index
-            ,baton->opts
-    );
-
     int result = git_diff_index_to_workdir(
 &baton->diff,baton->repo,baton->index,baton->opts  );
 
@@ -1518,28 +1532,50 @@ void GitDiff::IndexToWorkdirWorker::Execute() {
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitDiff::IndexToWorkdirWorker::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("Diff.indexToWorkdir").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_diff_free(baton->diff);
+
+  delete baton;
 }
 
 void GitDiff::IndexToWorkdirWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
-    v8::Local<v8::Value> to;
+    v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
     if (baton->diff != NULL) {
       v8::Local<v8::Array> owners = Nan::New<Array>(0);
             Nan::Set(owners, Nan::New<v8::Number>(owners->Length()), Nan::To<v8::Object>(this->GetFromPersistent("repo")).ToLocalChecked());
-             to = GitDiff::New(
+             v8ConversionSlot = GitDiff::New(
         baton->diff,
         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
@@ -1563,47 +1599,15 @@ void GitDiff::IndexToWorkdirWorker::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("index"));
-              workerArguments.push(GetFromPersistent("opts"));
       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);
-          }
         }
       }
 
@@ -1620,6 +1624,7 @@ void GitDiff::IndexToWorkdirWorker::HandleOKCallback() {
       callback->Call(0, NULL, async_resource);
     }
 
+        git_diff_free(baton->diff);
   }
 
 
@@ -1636,7 +1641,7 @@ NAN_METHOD(GitDiff::IsSortedIcase) {
   git_error_clear();
 
   { // lock master scope start
-    LockMaster lockMaster(
+    nodegit::LockMaster lockMaster(
       /*asyncAction: */false
             ,
               Nan::ObjectWrap::Unwrap<GitDiff>(info.This())->GetValue()
@@ -1647,11 +1652,11 @@ NAN_METHOD(GitDiff::IsSortedIcase) {
     );
 
 
-      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));
   }
 }
   
@@ -1664,15 +1669,19 @@ NAN_METHOD(GitDiff::Merge) {
     return Nan::ThrowError("Diff from 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.");
   }
 
-  MergeBaton* baton = new MergeBaton;
+  MergeBaton* baton = new MergeBaton();
 
   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->onto = Nan::ObjectWrap::Unwrap<GitDiff>(info.This())->GetValue();
 // start convert_from_v8 block
   const git_diff * from_from = NULL;
@@ -1680,27 +1689,29 @@ from_from = Nan::ObjectWrap::Unwrap<GitDiff>(Nan::To<v8::Object>(info[0]).ToLoca
 // end convert_from_v8 block
           baton->from = from_from;
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[1]));
-  MergeWorker *worker = new MergeWorker(baton, callback);
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  MergeWorker *worker = new MergeWorker(baton, callback, cleanupHandles);
 
-        worker->SaveToPersistent("onto", info.This());
-        if (!info[0]->IsUndefined() && !info[0]->IsNull())
-          worker->SaveToPersistent("from", Nan::To<v8::Object>(info[0]).ToLocalChecked());
-
-  AsyncLibgit2QueueWorker(worker);
+        worker->Reference<GitDiff>("onto", info.This());
+             worker->Reference<GitDiff>("from", info[0]);
+  
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitDiff::MergeWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->onto
+          ,baton->from
+  );
+
+  return lockMaster;
+}
+
 void GitDiff::MergeWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->onto
-            ,baton->from
-    );
-
     int result = git_diff_merge(
 baton->onto,baton->from  );
 
@@ -1710,13 +1721,34 @@ baton->onto,baton->from  );
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitDiff::MergeWorker::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("Diff.merge").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 GitDiff::MergeWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
     v8::Local<v8::Value> result = Nan::Undefined();
-
+     
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -1740,45 +1772,15 @@ void GitDiff::MergeWorker::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("from"));
       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);
-          }
         }
       }
 
@@ -1811,7 +1813,7 @@ NAN_METHOD(GitDiff::NumDeltas) {
   git_error_clear();
 
   { // lock master scope start
-    LockMaster lockMaster(
+    nodegit::LockMaster lockMaster(
       /*asyncAction: */false
             ,
               Nan::ObjectWrap::Unwrap<GitDiff>(info.This())->GetValue()
@@ -1822,11 +1824,11 @@ NAN_METHOD(GitDiff::NumDeltas) {
     );
 
 
-      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));
   }
 }
   
@@ -1840,45 +1842,56 @@ NAN_METHOD(GitDiff::Patchid) {
     return Nan::ThrowError("DiffPatchidOptions opts 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.");
   }
 
-  PatchidBaton* baton = new PatchidBaton;
+  PatchidBaton* baton = new PatchidBaton();
 
   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 ));
         baton->diff = Nan::ObjectWrap::Unwrap<GitDiff>(info.This())->GetValue();
-// start convert_from_v8 block
-  git_diff_patchid_options * from_opts = NULL;
-from_opts = Nan::ObjectWrap::Unwrap<GitDiffPatchidOptions>(Nan::To<v8::Object>(info[0]).ToLocalChecked())->GetValue();
-// end convert_from_v8 block
-          baton->opts = from_opts;
+            {
+            auto conversionResult = ConfigurableGitDiffPatchidOptions::fromJavascript(nodegitContext, info[0]);
+            if (!conversionResult.result) {
+              return Nan::ThrowError(Nan::New(conversionResult.error).ToLocalChecked());
+            }
+
+            auto convertedObject = conversionResult.result;
+            cleanupHandles["opts"] = convertedObject;
+            baton->opts = convertedObject->GetValue();
+          }
+ 
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  PatchidWorker *worker = new PatchidWorker(baton, callback, cleanupHandles);
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[1]));
-  PatchidWorker *worker = new PatchidWorker(baton, callback);
+        worker->Reference<GitDiff>("diff", info.This());
+           worker->Reference("opts", info[0]);
+ 
+  nodegitContext->QueueWorker(worker);
+  return;
+}
 
-        worker->SaveToPersistent("diff", info.This());
-        if (!info[0]->IsUndefined() && !info[0]->IsNull())
-          worker->SaveToPersistent("opts", Nan::To<v8::Object>(info[0]).ToLocalChecked());
+nodegit::LockMaster GitDiff::PatchidWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->out
+          ,baton->diff
+          ,baton->opts
+  );
 
-  AsyncLibgit2QueueWorker(worker);
-  return;
+  return lockMaster;
 }
 
 void GitDiff::PatchidWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->out
-            ,baton->diff
-            ,baton->opts
-    );
-
     int result = git_diff_patchid(
 baton->out,baton->diff,baton->opts  );
 
@@ -1888,25 +1901,46 @@ baton->out,baton->diff,baton->opts  );
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitDiff::PatchidWorker::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("Diff.patchid").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 GitDiff::PatchidWorker::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
@@ -1930,45 +1964,15 @@ void GitDiff::PatchidWorker::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("opts"));
       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);
-          }
         }
       }
 
@@ -2002,15 +2006,19 @@ NAN_METHOD(GitDiff::ToBuf) {
     return Nan::ThrowError("Number format 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.");
   }
 
-  ToBufBaton* baton = new ToBufBaton;
+  ToBufBaton* baton = new ToBufBaton();
 
   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;
@@ -2021,27 +2029,29 @@ NAN_METHOD(GitDiff::ToBuf) {
 // end convert_from_v8 block
           baton->format = from_format;
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[1]));
-  ToBufWorker *worker = new ToBufWorker(baton, callback);
-
-        worker->SaveToPersistent("diff", info.This());
-        if (!info[0]->IsUndefined() && !info[0]->IsNull())
-          worker->SaveToPersistent("format", Nan::To<v8::Object>(info[0]).ToLocalChecked());
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  ToBufWorker *worker = new ToBufWorker(baton, callback, cleanupHandles);
 
-  AsyncLibgit2QueueWorker(worker);
+        worker->Reference<GitDiff>("diff", info.This());
+           worker->Reference("format", info[0]);
+ 
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitDiff::ToBufWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->out
+          ,baton->diff
+  );
+
+  return lockMaster;
+}
+
 void GitDiff::ToBufWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->out
-            ,baton->diff
-    );
-
     int result = git_diff_to_buf(
 baton->out,baton->diff,baton->format  );
 
@@ -2051,22 +2061,45 @@ baton->out,baton->diff,baton->format  );
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitDiff::ToBufWorker::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("Diff.toBuf").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 GitDiff::ToBufWorker::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
@@ -2090,45 +2123,15 @@ void GitDiff::ToBufWorker::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("format"));
       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);
-          }
         }
       }
 
@@ -2167,15 +2170,19 @@ NAN_METHOD(GitDiff::TreeToIndex) {
     return Nan::ThrowError("Repository repo 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.");
   }
 
-  TreeToIndexBaton* baton = new TreeToIndexBaton;
+  TreeToIndexBaton* baton = new TreeToIndexBaton();
 
   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();
@@ -2183,7 +2190,7 @@ from_repo = Nan::ObjectWrap::Unwrap<GitRepository>(Nan::To<v8::Object>(info[0]).
           baton->repo = from_repo;
 // start convert_from_v8 block
   git_tree * from_old_tree = NULL;
-    if (info[1]->IsObject()) {
+    if ((info.Length() - 1) > 1 && info[1]->IsObject()) {
 from_old_tree = Nan::ObjectWrap::Unwrap<GitTree>(Nan::To<v8::Object>(info[1]).ToLocalChecked())->GetValue();
   }
   else {
@@ -2193,7 +2200,7 @@ from_old_tree = Nan::ObjectWrap::Unwrap<GitTree>(Nan::To<v8::Object>(info[1]).To
           baton->old_tree = from_old_tree;
 // start convert_from_v8 block
   git_index * from_index = NULL;
-    if (info[2]->IsObject()) {
+    if ((info.Length() - 1) > 2 && info[2]->IsObject()) {
 from_index = Nan::ObjectWrap::Unwrap<GitIndex>(Nan::To<v8::Object>(info[2]).ToLocalChecked())->GetValue();
   }
   else {
@@ -2201,45 +2208,47 @@ from_index = Nan::ObjectWrap::Unwrap<GitIndex>(Nan::To<v8::Object>(info[2]).ToLo
   }
 // end convert_from_v8 block
           baton->index = from_index;
-// start convert_from_v8 block
-  const git_diff_options * from_opts = NULL;
-    if (info[3]->IsObject()) {
-from_opts = Nan::ObjectWrap::Unwrap<GitDiffOptions>(Nan::To<v8::Object>(info[3]).ToLocalChecked())->GetValue();
-  }
-  else {
-    from_opts = 0;
-  }
-// end convert_from_v8 block
-          baton->opts = from_opts;
+          if (info[3]->IsNull() || info[3]->IsUndefined()) {
+            baton->opts = nullptr;
+          } else
+            {
+            auto conversionResult = ConfigurableGitDiffOptions::fromJavascript(nodegitContext, info[3]);
+            if (!conversionResult.result) {
+              return Nan::ThrowError(Nan::New(conversionResult.error).ToLocalChecked());
+            }
+
+            auto convertedObject = conversionResult.result;
+            cleanupHandles["opts"] = convertedObject;
+            baton->opts = convertedObject->GetValue();
+          }
+ 
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  TreeToIndexWorker *worker = new TreeToIndexWorker(baton, callback, cleanupHandles);
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[4]));
-  TreeToIndexWorker *worker = new TreeToIndexWorker(baton, callback);
+             worker->Reference<GitRepository>("repo", info[0]);
+               worker->Reference<GitTree>("old_tree", info[1]);
+               worker->Reference<GitIndex>("index", info[2]);
+             worker->Reference("opts", info[3]);
+ 
+  nodegitContext->QueueWorker(worker);
+  return;
+}
 
-        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("old_tree", Nan::To<v8::Object>(info[1]).ToLocalChecked());
-        if (!info[2]->IsUndefined() && !info[2]->IsNull())
-          worker->SaveToPersistent("index", Nan::To<v8::Object>(info[2]).ToLocalChecked());
-        if (!info[3]->IsUndefined() && !info[3]->IsNull())
-          worker->SaveToPersistent("opts", Nan::To<v8::Object>(info[3]).ToLocalChecked());
+nodegit::LockMaster GitDiff::TreeToIndexWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->repo
+          ,baton->old_tree
+          ,baton->index
+          ,baton->opts
+  );
 
-  AsyncLibgit2QueueWorker(worker);
-  return;
+  return lockMaster;
 }
 
 void GitDiff::TreeToIndexWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->repo
-            ,baton->old_tree
-            ,baton->index
-            ,baton->opts
-    );
-
     int result = git_diff_tree_to_index(
 &baton->diff,baton->repo,baton->old_tree,baton->index,baton->opts  );
 
@@ -2249,28 +2258,50 @@ void GitDiff::TreeToIndexWorker::Execute() {
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitDiff::TreeToIndexWorker::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("Diff.treeToIndex").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_diff_free(baton->diff);
+
+  delete baton;
 }
 
 void GitDiff::TreeToIndexWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
-    v8::Local<v8::Value> to;
+    v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
     if (baton->diff != NULL) {
       v8::Local<v8::Array> owners = Nan::New<Array>(0);
             Nan::Set(owners, Nan::New<v8::Number>(owners->Length()), Nan::To<v8::Object>(this->GetFromPersistent("repo")).ToLocalChecked());
-             to = GitDiff::New(
+             v8ConversionSlot = GitDiff::New(
         baton->diff,
         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
@@ -2294,48 +2325,15 @@ void GitDiff::TreeToIndexWorker::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("old_tree"));
-              workerArguments.push(GetFromPersistent("index"));
-              workerArguments.push(GetFromPersistent("opts"));
       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);
-          }
         }
       }
 
@@ -2352,6 +2350,7 @@ void GitDiff::TreeToIndexWorker::HandleOKCallback() {
       callback->Call(0, NULL, async_resource);
     }
 
+        git_diff_free(baton->diff);
   }
 
 
@@ -2372,15 +2371,19 @@ NAN_METHOD(GitDiff::TreeToTree) {
     return Nan::ThrowError("Repository repo 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.");
   }
 
-  TreeToTreeBaton* baton = new TreeToTreeBaton;
+  TreeToTreeBaton* baton = new TreeToTreeBaton();
 
   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();
@@ -2388,7 +2391,7 @@ from_repo = Nan::ObjectWrap::Unwrap<GitRepository>(Nan::To<v8::Object>(info[0]).
           baton->repo = from_repo;
 // start convert_from_v8 block
   git_tree * from_old_tree = NULL;
-    if (info[1]->IsObject()) {
+    if ((info.Length() - 1) > 1 && info[1]->IsObject()) {
 from_old_tree = Nan::ObjectWrap::Unwrap<GitTree>(Nan::To<v8::Object>(info[1]).ToLocalChecked())->GetValue();
   }
   else {
@@ -2398,7 +2401,7 @@ from_old_tree = Nan::ObjectWrap::Unwrap<GitTree>(Nan::To<v8::Object>(info[1]).To
           baton->old_tree = from_old_tree;
 // start convert_from_v8 block
   git_tree * from_new_tree = NULL;
-    if (info[2]->IsObject()) {
+    if ((info.Length() - 1) > 2 && info[2]->IsObject()) {
 from_new_tree = Nan::ObjectWrap::Unwrap<GitTree>(Nan::To<v8::Object>(info[2]).ToLocalChecked())->GetValue();
   }
   else {
@@ -2406,45 +2409,47 @@ from_new_tree = Nan::ObjectWrap::Unwrap<GitTree>(Nan::To<v8::Object>(info[2]).To
   }
 // end convert_from_v8 block
           baton->new_tree = from_new_tree;
-// start convert_from_v8 block
-  const git_diff_options * from_opts = NULL;
-    if (info[3]->IsObject()) {
-from_opts = Nan::ObjectWrap::Unwrap<GitDiffOptions>(Nan::To<v8::Object>(info[3]).ToLocalChecked())->GetValue();
-  }
-  else {
-    from_opts = 0;
-  }
-// end convert_from_v8 block
-          baton->opts = from_opts;
+          if (info[3]->IsNull() || info[3]->IsUndefined()) {
+            baton->opts = nullptr;
+          } else
+            {
+            auto conversionResult = ConfigurableGitDiffOptions::fromJavascript(nodegitContext, info[3]);
+            if (!conversionResult.result) {
+              return Nan::ThrowError(Nan::New(conversionResult.error).ToLocalChecked());
+            }
+
+            auto convertedObject = conversionResult.result;
+            cleanupHandles["opts"] = convertedObject;
+            baton->opts = convertedObject->GetValue();
+          }
+ 
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  TreeToTreeWorker *worker = new TreeToTreeWorker(baton, callback, cleanupHandles);
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[4]));
-  TreeToTreeWorker *worker = new TreeToTreeWorker(baton, callback);
+             worker->Reference<GitRepository>("repo", info[0]);
+               worker->Reference<GitTree>("old_tree", info[1]);
+               worker->Reference<GitTree>("new_tree", info[2]);
+             worker->Reference("opts", info[3]);
+ 
+  nodegitContext->QueueWorker(worker);
+  return;
+}
 
-        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("old_tree", Nan::To<v8::Object>(info[1]).ToLocalChecked());
-        if (!info[2]->IsUndefined() && !info[2]->IsNull())
-          worker->SaveToPersistent("new_tree", Nan::To<v8::Object>(info[2]).ToLocalChecked());
-        if (!info[3]->IsUndefined() && !info[3]->IsNull())
-          worker->SaveToPersistent("opts", Nan::To<v8::Object>(info[3]).ToLocalChecked());
+nodegit::LockMaster GitDiff::TreeToTreeWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->repo
+          ,baton->old_tree
+          ,baton->new_tree
+          ,baton->opts
+  );
 
-  AsyncLibgit2QueueWorker(worker);
-  return;
+  return lockMaster;
 }
 
 void GitDiff::TreeToTreeWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->repo
-            ,baton->old_tree
-            ,baton->new_tree
-            ,baton->opts
-    );
-
     int result = git_diff_tree_to_tree(
 &baton->diff,baton->repo,baton->old_tree,baton->new_tree,baton->opts  );
 
@@ -2454,28 +2459,50 @@ void GitDiff::TreeToTreeWorker::Execute() {
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitDiff::TreeToTreeWorker::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("Diff.treeToTree").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_diff_free(baton->diff);
+
+  delete baton;
 }
 
 void GitDiff::TreeToTreeWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
-    v8::Local<v8::Value> to;
+    v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
     if (baton->diff != NULL) {
       v8::Local<v8::Array> owners = Nan::New<Array>(0);
             Nan::Set(owners, Nan::New<v8::Number>(owners->Length()), Nan::To<v8::Object>(this->GetFromPersistent("repo")).ToLocalChecked());
-             to = GitDiff::New(
+             v8ConversionSlot = GitDiff::New(
         baton->diff,
         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
@@ -2499,48 +2526,15 @@ void GitDiff::TreeToTreeWorker::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("old_tree"));
-              workerArguments.push(GetFromPersistent("new_tree"));
-              workerArguments.push(GetFromPersistent("opts"));
       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);
-          }
         }
       }
 
@@ -2557,6 +2551,7 @@ void GitDiff::TreeToTreeWorker::HandleOKCallback() {
       callback->Call(0, NULL, async_resource);
     }
 
+        git_diff_free(baton->diff);
   }
 
 
@@ -2576,15 +2571,19 @@ NAN_METHOD(GitDiff::TreeToWorkdir) {
     return Nan::ThrowError("Repository repo 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.");
   }
 
-  TreeToWorkdirBaton* baton = new TreeToWorkdirBaton;
+  TreeToWorkdirBaton* baton = new TreeToWorkdirBaton();
 
   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();
@@ -2592,7 +2591,7 @@ from_repo = Nan::ObjectWrap::Unwrap<GitRepository>(Nan::To<v8::Object>(info[0]).
           baton->repo = from_repo;
 // start convert_from_v8 block
   git_tree * from_old_tree = NULL;
-    if (info[1]->IsObject()) {
+    if ((info.Length() - 1) > 1 && info[1]->IsObject()) {
 from_old_tree = Nan::ObjectWrap::Unwrap<GitTree>(Nan::To<v8::Object>(info[1]).ToLocalChecked())->GetValue();
   }
   else {
@@ -2600,42 +2599,45 @@ from_old_tree = Nan::ObjectWrap::Unwrap<GitTree>(Nan::To<v8::Object>(info[1]).To
   }
 // end convert_from_v8 block
           baton->old_tree = from_old_tree;
-// start convert_from_v8 block
-  const git_diff_options * from_opts = NULL;
-    if (info[2]->IsObject()) {
-from_opts = Nan::ObjectWrap::Unwrap<GitDiffOptions>(Nan::To<v8::Object>(info[2]).ToLocalChecked())->GetValue();
-  }
-  else {
-    from_opts = 0;
-  }
-// end convert_from_v8 block
-          baton->opts = from_opts;
+          if (info[2]->IsNull() || info[2]->IsUndefined()) {
+            baton->opts = nullptr;
+          } else
+            {
+            auto conversionResult = ConfigurableGitDiffOptions::fromJavascript(nodegitContext, info[2]);
+            if (!conversionResult.result) {
+              return Nan::ThrowError(Nan::New(conversionResult.error).ToLocalChecked());
+            }
+
+            auto convertedObject = conversionResult.result;
+            cleanupHandles["opts"] = convertedObject;
+            baton->opts = convertedObject->GetValue();
+          }
+ 
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  TreeToWorkdirWorker *worker = new TreeToWorkdirWorker(baton, callback, cleanupHandles);
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[3]));
-  TreeToWorkdirWorker *worker = new TreeToWorkdirWorker(baton, callback);
+             worker->Reference<GitRepository>("repo", info[0]);
+               worker->Reference<GitTree>("old_tree", info[1]);
+             worker->Reference("opts", info[2]);
+ 
+  nodegitContext->QueueWorker(worker);
+  return;
+}
 
-        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("old_tree", Nan::To<v8::Object>(info[1]).ToLocalChecked());
-        if (!info[2]->IsUndefined() && !info[2]->IsNull())
-          worker->SaveToPersistent("opts", Nan::To<v8::Object>(info[2]).ToLocalChecked());
+nodegit::LockMaster GitDiff::TreeToWorkdirWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->repo
+          ,baton->old_tree
+          ,baton->opts
+  );
 
-  AsyncLibgit2QueueWorker(worker);
-  return;
+  return lockMaster;
 }
 
 void GitDiff::TreeToWorkdirWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->repo
-            ,baton->old_tree
-            ,baton->opts
-    );
-
     int result = git_diff_tree_to_workdir(
 &baton->diff,baton->repo,baton->old_tree,baton->opts  );
 
@@ -2645,28 +2647,50 @@ void GitDiff::TreeToWorkdirWorker::Execute() {
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitDiff::TreeToWorkdirWorker::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("Diff.treeToWorkdir").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_diff_free(baton->diff);
+
+  delete baton;
 }
 
 void GitDiff::TreeToWorkdirWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
-    v8::Local<v8::Value> to;
+    v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
     if (baton->diff != NULL) {
       v8::Local<v8::Array> owners = Nan::New<Array>(0);
             Nan::Set(owners, Nan::New<v8::Number>(owners->Length()), Nan::To<v8::Object>(this->GetFromPersistent("repo")).ToLocalChecked());
-             to = GitDiff::New(
+             v8ConversionSlot = GitDiff::New(
         baton->diff,
         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
@@ -2690,47 +2714,15 @@ void GitDiff::TreeToWorkdirWorker::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("old_tree"));
-              workerArguments.push(GetFromPersistent("opts"));
       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);
-          }
         }
       }
 
@@ -2747,6 +2739,7 @@ void GitDiff::TreeToWorkdirWorker::HandleOKCallback() {
       callback->Call(0, NULL, async_resource);
     }
 
+        git_diff_free(baton->diff);
   }
 
 
@@ -2766,15 +2759,19 @@ NAN_METHOD(GitDiff::TreeToWorkdirWithIndex) {
     return Nan::ThrowError("Repository repo 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.");
   }
 
-  TreeToWorkdirWithIndexBaton* baton = new TreeToWorkdirWithIndexBaton;
+  TreeToWorkdirWithIndexBaton* baton = new TreeToWorkdirWithIndexBaton();
 
   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();
@@ -2782,7 +2779,7 @@ from_repo = Nan::ObjectWrap::Unwrap<GitRepository>(Nan::To<v8::Object>(info[0]).
           baton->repo = from_repo;
 // start convert_from_v8 block
   git_tree * from_old_tree = NULL;
-    if (info[1]->IsObject()) {
+    if ((info.Length() - 1) > 1 && info[1]->IsObject()) {
 from_old_tree = Nan::ObjectWrap::Unwrap<GitTree>(Nan::To<v8::Object>(info[1]).ToLocalChecked())->GetValue();
   }
   else {
@@ -2790,42 +2787,45 @@ from_old_tree = Nan::ObjectWrap::Unwrap<GitTree>(Nan::To<v8::Object>(info[1]).To
   }
 // end convert_from_v8 block
           baton->old_tree = from_old_tree;
-// start convert_from_v8 block
-  const git_diff_options * from_opts = NULL;
-    if (info[2]->IsObject()) {
-from_opts = Nan::ObjectWrap::Unwrap<GitDiffOptions>(Nan::To<v8::Object>(info[2]).ToLocalChecked())->GetValue();
-  }
-  else {
-    from_opts = 0;
-  }
-// end convert_from_v8 block
-          baton->opts = from_opts;
+          if (info[2]->IsNull() || info[2]->IsUndefined()) {
+            baton->opts = nullptr;
+          } else
+            {
+            auto conversionResult = ConfigurableGitDiffOptions::fromJavascript(nodegitContext, info[2]);
+            if (!conversionResult.result) {
+              return Nan::ThrowError(Nan::New(conversionResult.error).ToLocalChecked());
+            }
+
+            auto convertedObject = conversionResult.result;
+            cleanupHandles["opts"] = convertedObject;
+            baton->opts = convertedObject->GetValue();
+          }
+ 
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  TreeToWorkdirWithIndexWorker *worker = new TreeToWorkdirWithIndexWorker(baton, callback, cleanupHandles);
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[3]));
-  TreeToWorkdirWithIndexWorker *worker = new TreeToWorkdirWithIndexWorker(baton, callback);
+             worker->Reference<GitRepository>("repo", info[0]);
+               worker->Reference<GitTree>("old_tree", info[1]);
+             worker->Reference("opts", info[2]);
+ 
+  nodegitContext->QueueWorker(worker);
+  return;
+}
 
-        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("old_tree", Nan::To<v8::Object>(info[1]).ToLocalChecked());
-        if (!info[2]->IsUndefined() && !info[2]->IsNull())
-          worker->SaveToPersistent("opts", Nan::To<v8::Object>(info[2]).ToLocalChecked());
+nodegit::LockMaster GitDiff::TreeToWorkdirWithIndexWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->repo
+          ,baton->old_tree
+          ,baton->opts
+  );
 
-  AsyncLibgit2QueueWorker(worker);
-  return;
+  return lockMaster;
 }
 
 void GitDiff::TreeToWorkdirWithIndexWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->repo
-            ,baton->old_tree
-            ,baton->opts
-    );
-
     int result = git_diff_tree_to_workdir_with_index(
 &baton->diff,baton->repo,baton->old_tree,baton->opts  );
 
@@ -2835,28 +2835,50 @@ void GitDiff::TreeToWorkdirWithIndexWorker::Execute() {
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitDiff::TreeToWorkdirWithIndexWorker::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("Diff.treeToWorkdirWithIndex").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_diff_free(baton->diff);
+
+  delete baton;
 }
 
 void GitDiff::TreeToWorkdirWithIndexWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
-    v8::Local<v8::Value> to;
+    v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
     if (baton->diff != NULL) {
       v8::Local<v8::Array> owners = Nan::New<Array>(0);
             Nan::Set(owners, Nan::New<v8::Number>(owners->Length()), Nan::To<v8::Object>(this->GetFromPersistent("repo")).ToLocalChecked());
-             to = GitDiff::New(
+             v8ConversionSlot = GitDiff::New(
         baton->diff,
         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
@@ -2880,47 +2902,15 @@ void GitDiff::TreeToWorkdirWithIndexWorker::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("old_tree"));
-              workerArguments.push(GetFromPersistent("opts"));
       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);
-          }
         }
       }
 
@@ -2937,6 +2927,7 @@ void GitDiff::TreeToWorkdirWithIndexWorker::HandleOKCallback() {
       callback->Call(0, NULL, async_resource);
     }
 
+        git_diff_free(baton->diff);
   }
 
 
@@ -2954,7 +2945,7 @@ NAN_METHOD(GitDiff::GetPerfdata) {
   git_error_clear();
 
   { // lock master scope start
-    LockMaster lockMaster(
+    nodegit::LockMaster lockMaster(
       /*asyncAction: */false
             ,
               Nan::ObjectWrap::Unwrap<GitDiff>(info.This())->GetValue()
@@ -2975,19 +2966,19 @@ NAN_METHOD(GitDiff::GetPerfdata) {
         }
       } // lock master scope end
 
-      v8::Local<v8::Value> to;
+      v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
     if (out != NULL) {
-        to = GitDiffPerfdata::New(
+        v8ConversionSlot = GitDiffPerfdata::New(
         out,
         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));
   }
 }
     // force base class template instantiation, to make sure we get all the