pj-nodegit 0.27.12 → 0.28.1

package/src/filter_list.cc

@@ -12,7 +12,6 @@ extern "C" {
 #include "../include/functions/copy.h"
 #include "../include/filter_list.h"
 #include "nodegit_wrapper.cc"
-#include "../include/async_libgit2_queue_worker.h"
 
   #include "../include/git_buf_converter.h"
   #include "../include/filter_registry.h"
@@ -32,24 +31,25 @@ using namespace node;
     // way of knowing to free these values.
                            }
 
-  void GitFilterList::InitializeComponent(v8::Local<v8::Object> target) {
+  void GitFilterList::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("FilterList").ToLocalChecked());
 
-          Nan::SetPrototypeMethod(tpl, "applyToBlob", ApplyToBlob);
-            Nan::SetPrototypeMethod(tpl, "applyToData", ApplyToData);
-            Nan::SetPrototypeMethod(tpl, "applyToFile", ApplyToFile);
-             Nan::SetMethod(tpl, "load", Load);
+          Nan::SetPrototypeMethod(tpl, "applyToBlob", ApplyToBlob, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "applyToData", ApplyToData, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "applyToFile", ApplyToFile, nodegitExternal);
+             Nan::SetMethod(tpl, "load", Load, nodegitExternal);
     
     InitializeTemplate(tpl);
 
-    v8::Local<Function> _constructor_template = Nan::GetFunction(tpl).ToLocalChecked();
-    constructor_template.Reset(_constructor_template);
-    Nan::Set(target, Nan::New("FilterList").ToLocalChecked(), _constructor_template);
+    v8::Local<Function> constructor_template = Nan::GetFunction(tpl).ToLocalChecked();
+    nodegitContext->SaveToPersistent("GitFilterList::Template", constructor_template);
+    Nan::Set(target, Nan::New("FilterList").ToLocalChecked(), constructor_template);
   }
 
  
@@ -63,15 +63,19 @@ NAN_METHOD(GitFilterList::ApplyToBlob) {
     return Nan::ThrowError("Blob blob 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.");
   }
 
-  ApplyToBlobBaton* baton = new ApplyToBlobBaton;
+  ApplyToBlobBaton* baton = new ApplyToBlobBaton();
 
   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;
@@ -82,28 +86,30 @@ from_blob = Nan::ObjectWrap::Unwrap<GitBlob>(Nan::To<v8::Object>(info[0]).ToLoca
 // end convert_from_v8 block
           baton->blob = from_blob;
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[1]));
-  ApplyToBlobWorker *worker = new ApplyToBlobWorker(baton, callback);
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  ApplyToBlobWorker *worker = new ApplyToBlobWorker(baton, callback, cleanupHandles);
 
-        worker->SaveToPersistent("filters", info.This());
-        if (!info[0]->IsUndefined() && !info[0]->IsNull())
-          worker->SaveToPersistent("blob", Nan::To<v8::Object>(info[0]).ToLocalChecked());
-
-  AsyncLibgit2QueueWorker(worker);
+        worker->Reference<GitFilterList>("filters", info.This());
+             worker->Reference<GitBlob>("blob", info[0]);
+  
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitFilterList::ApplyToBlobWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->out
+          ,baton->filters
+          ,baton->blob
+  );
+
+  return lockMaster;
+}
+
 void GitFilterList::ApplyToBlobWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->out
-            ,baton->filters
-            ,baton->blob
-    );
-
     int result = git_filter_list_apply_to_blob(
 baton->out,baton->filters,baton->blob  );
 
@@ -113,22 +119,45 @@ baton->out,baton->filters,baton->blob  );
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitFilterList::ApplyToBlobWorker::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("FilterList.applyToBlob").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 GitFilterList::ApplyToBlobWorker::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
@@ -152,45 +181,15 @@ void GitFilterList::ApplyToBlobWorker::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("blob"));
       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);
-          }
         }
       }
 
@@ -226,15 +225,19 @@ NAN_METHOD(GitFilterList::ApplyToData) {
     return Nan::ThrowError("Buf in 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.");
   }
 
-  ApplyToDataBaton* baton = new ApplyToDataBaton;
+  ApplyToDataBaton* baton = new ApplyToDataBaton();
 
   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;
@@ -246,28 +249,30 @@ NAN_METHOD(GitFilterList::ApplyToData) {
 // end convert_from_v8 block
           baton->in = from_in;
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[1]));
-  ApplyToDataWorker *worker = new ApplyToDataWorker(baton, callback);
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  ApplyToDataWorker *worker = new ApplyToDataWorker(baton, callback, cleanupHandles);
 
-        worker->SaveToPersistent("filters", info.This());
-        if (!info[0]->IsUndefined() && !info[0]->IsNull())
-          worker->SaveToPersistent("in", Nan::To<v8::Object>(info[0]).ToLocalChecked());
-
-  AsyncLibgit2QueueWorker(worker);
+        worker->Reference<GitFilterList>("filters", info.This());
+           worker->Reference("in", info[0]);
+ 
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitFilterList::ApplyToDataWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->out
+          ,baton->filters
+          ,baton->in
+  );
+
+  return lockMaster;
+}
+
 void GitFilterList::ApplyToDataWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->out
-            ,baton->filters
-            ,baton->in
-    );
-
     int result = git_filter_list_apply_to_data(
 baton->out,baton->filters,baton->in  );
 
@@ -277,22 +282,47 @@ baton->out,baton->filters,baton->in  );
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitFilterList::ApplyToDataWorker::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("FilterList.applyToData").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);
+        git_buf_dispose(baton->in);
+        free((void *)baton->in);
+
+  delete baton;
 }
 
 void GitFilterList::ApplyToDataWorker::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
@@ -316,45 +346,15 @@ void GitFilterList::ApplyToDataWorker::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("in"));
       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);
-          }
         }
       }
 
@@ -397,15 +397,19 @@ NAN_METHOD(GitFilterList::ApplyToFile) {
     return Nan::ThrowError("String path 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.");
   }
 
-  ApplyToFileBaton* baton = new ApplyToFileBaton;
+  ApplyToFileBaton* baton = new ApplyToFileBaton();
 
   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;
@@ -430,31 +434,32 @@ from_repo = Nan::ObjectWrap::Unwrap<GitRepository>(Nan::To<v8::Object>(info[0]).
 // end convert_from_v8 block
           baton->path = from_path;
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[2]));
-  ApplyToFileWorker *worker = new ApplyToFileWorker(baton, callback);
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  ApplyToFileWorker *worker = new ApplyToFileWorker(baton, callback, cleanupHandles);
 
-        worker->SaveToPersistent("filters", info.This());
-        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("path", Nan::To<v8::Object>(info[1]).ToLocalChecked());
-
-  AsyncLibgit2QueueWorker(worker);
+        worker->Reference<GitFilterList>("filters", info.This());
+             worker->Reference<GitRepository>("repo", info[0]);
+             worker->Reference("path", info[1]);
+ 
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitFilterList::ApplyToFileWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->out
+          ,baton->filters
+          ,baton->repo
+          ,baton->path
+  );
+
+  return lockMaster;
+}
+
 void GitFilterList::ApplyToFileWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->out
-            ,baton->filters
-            ,baton->repo
-            ,baton->path
-    );
-
     int result = git_filter_list_apply_to_file(
 baton->out,baton->filters,baton->repo,baton->path  );
 
@@ -464,22 +469,45 @@ baton->out,baton->filters,baton->repo,baton->path  );
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitFilterList::ApplyToFileWorker::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("FilterList.applyToFile").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 GitFilterList::ApplyToFileWorker::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
@@ -503,46 +531,15 @@ void GitFilterList::ApplyToFileWorker::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("path"));
       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);
-          }
         }
       }
 
@@ -604,11 +601,11 @@ NAN_METHOD(GitFilterList::Load) {
     return Nan::ThrowError("Number flags is required.");
   }
 
-  if (info.Length() == 5 || !info[5]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  LoadBaton *baton = new LoadBaton;
+  LoadBaton *baton = new LoadBaton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
@@ -658,40 +655,55 @@ NAN_METHOD(GitFilterList::Load) {
   baton->flags = from_flags;
 
   Nan::Callback *callback =
-      new Nan::Callback(v8::Local<Function>::Cast(info[5]));
-  LoadWorker *worker = new LoadWorker(baton, callback);
-
-  if (!info[0]->IsUndefined() && !info[0]->IsNull())
-    worker->SaveToPersistent("repo", Nan::To<v8::Object>(info[0]).ToLocalChecked());
-  if (!info[1]->IsUndefined() && !info[1]->IsNull())
-    worker->SaveToPersistent("blob", Nan::To<v8::Object>(info[1]).ToLocalChecked());
-  if (!info[2]->IsUndefined() && !info[2]->IsNull())
-    worker->SaveToPersistent("path", Nan::To<v8::Object>(info[2]).ToLocalChecked());
-  if (!info[3]->IsUndefined() && !info[3]->IsNull())
-    worker->SaveToPersistent("mode", Nan::To<v8::Object>(info[3]).ToLocalChecked());
-  if (!info[4]->IsUndefined() && !info[4]->IsNull())
-    worker->SaveToPersistent("flags", Nan::To<v8::Object>(info[4]).ToLocalChecked());
-
-  AsyncLibgit2QueueWorker(worker);
+      new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
+  LoadWorker *worker = new LoadWorker(baton, callback, cleanupHandles);
+
+  worker->Reference<GitRepository>("repo", info[0]);
+  worker->Reference<GitBlob>("blob", info[1]);
+
+  nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitFilterList::LoadWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    true,
+    baton->repo,
+    baton->blob,
+    baton->path
+  );
+  return lockMaster;
+}
+
 void GitFilterList::LoadWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-        /*asyncAction: */ true, baton->repo, baton->blob, baton->path);
+  int result = git_filter_list_load(&baton->filters, baton->repo, baton->blob,
+                                    baton->path, baton->mode, baton->flags);
 
-    int result = git_filter_list_load(&baton->filters, baton->repo, baton->blob,
-                                      baton->path, baton->mode, baton->flags);
+  baton->error_code = result;
 
-    baton->error_code = result;
+  if (result != GIT_OK && git_error_last() != NULL) {
+    baton->error = git_error_dup(git_error_last());
+  }
+}
 
-    if (result != GIT_OK && git_error_last() != NULL) {
-      baton->error = git_error_dup(git_error_last());
+void GitFilterList::LoadWorker::HandleErrorCallback() {
+  if (baton->error) {
+    if (baton->error->message) {
+      free((void *)baton->error->message);
     }
+
+    free((void *)baton->error);
   }
+
+  git_filter_list_free(baton->filters);
+
+  free((void *)baton->path);
+
+  delete baton;
 }
 
 void GitFilterList::LoadWorker::HandleOKCallback() {
@@ -702,8 +714,7 @@ void GitFilterList::LoadWorker::HandleOKCallback() {
     if (baton->filters != NULL) {
       // GitFilterList baton->filters
       v8::Local<v8::Array> owners = Nan::New<Array>(0);
-      v8::Local<v8::Object> filterRegistry = Nan::New(GitFilterRegistry::persistentHandle);
-      v8::Local<v8::Array> propertyNames = Nan::GetPropertyNames(filterRegistry).ToLocalChecked();
+      nodegit::Context *nodegitContext = nodegit::Context::GetCurrentContext();
 
       Nan::Set(
         owners,
@@ -711,23 +722,18 @@ void GitFilterList::LoadWorker::HandleOKCallback() {
         Nan::To<v8::Object>(this->GetFromPersistent("repo")).ToLocalChecked()
       );
 
-      for (uint32_t index = 0; index < propertyNames->Length(); ++index) {
-        v8::Local<v8::String> propertyName = Nan::To<v8::String>(Nan::Get(propertyNames, index).ToLocalChecked()).ToLocalChecked();
-        Nan::Utf8String propertyNameAsUtf8Value(propertyName);
-        const char *propertyNameAsCString = *propertyNameAsUtf8Value;
-
-        bool isNotMethodOnRegistry = strcmp("register", propertyNameAsCString)
-          && strcmp("unregister", propertyNameAsCString);
-        if (isNotMethodOnRegistry && git_filter_list_contains(baton->filters, propertyNameAsCString)) {
-          Nan::Set(
-            owners,
-            Nan::New<Number>(owners->Length()),
-            Nan::Get(filterRegistry, propertyName).ToLocalChecked()
-          );
-        }
-      }
-
       to = GitFilterList::New(baton->filters, true, Nan::To<v8::Object>(owners).ToLocalChecked());
+      auto filterListWrapper = Nan::ObjectWrap::Unwrap<GitFilterList>(to.As<v8::Object>());
+      auto filterRegistryCleanupHandles = static_pointer_cast<nodegit::FilterRegistryCleanupHandles>(nodegit::Context::GetCurrentContext()->GetCleanupHandle("filterRegistry"));
+      std::for_each(
+        filterRegistryCleanupHandles->registeredFilters.begin(),
+        filterRegistryCleanupHandles->registeredFilters.end(),
+        [this, &filterListWrapper](std::pair<std::string, std::shared_ptr<nodegit::CleanupHandle>> filterCleanupHandle) {
+          if (git_filter_list_contains(baton->filters, filterCleanupHandle.first.c_str())) {
+            filterListWrapper->SaveCleanupHandle(filterCleanupHandle.second);
+          }
+        }
+      );
     } else {
       to = Nan::Null();
     }
@@ -754,44 +760,15 @@ void GitFilterList::LoadWorker::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("blob"));
-      workerArguments.push(GetFromPersistent("path"));
-      workerArguments.push(GetFromPersistent("mode"));
-      workerArguments.push(GetFromPersistent("flags"));
       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()) {
-          v8::Local<v8::Value> argv[1] = {Nan::To<v8::Object>(checkValue).ToLocalChecked()};
+      if (!callbackErrorHandle.IsEmpty()) {
+        v8::Local<v8::Value> maybeError = Nan::New(callbackErrorHandle);
+        if (!maybeError->IsNull() && !maybeError->IsUndefined()) {
+          v8::Local<v8::Value> argv[1] = {
+            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);
-          }
         }
       }
 
@@ -810,6 +787,8 @@ void GitFilterList::LoadWorker::HandleOKCallback() {
     }
   }
 
+  free((void *)baton->path);
+
   delete baton;
 }