Move getReferences to C++

nodegit · implausible · May 3, 2019 · Oct 23, 2018 · Oct 23, 2018 · Apr 17, 2019
commit adcc5c520aae1a3351d9c463ee0ae7a207e666d1
diff --git a/generate/input/libgit2-supplement.json b/generate/input/libgit2-supplement.json
@@ -260,6 +260,28 @@
           "isErrorCode": true
         }
       },
+      "git_repository_get_references": {
+        "args": [
+          {
+            "name": "out",
+            "type": "std::vector<git_reference *> *"
+          },
+          {
+            "name": "repo",
+            "type": "git_repository *"
+          }
+        ],
+        "type": "function",
+        "isManual": true,
+        "cFile": "generate/templates/manual/repository/get_references.cc",
+        "isAsync": true,
+        "isPrototypeMethod": true,
+        "group": "repository",
+        "return": {
+          "type": "int",
+          "isErrorCode": true
+        }
+      },
       "git_repository_get_remotes": {
         "args": [
           {
@@ -555,6 +577,7 @@
       [
         "repository",
         [
+          "git_repository_get_references",
           "git_repository_get_remotes"
         ]
       ],

diff --git a/generate/templates/manual/repository/get_references.cc b/generate/templates/manual/repository/get_references.cc
@@ -0,0 +1,133 @@
+NAN_METHOD(GitRepository::GetReferences)
+{
+  if (info.Length() == 0 || !info[0]->IsFunction()) {
+    return Nan::ThrowError("Callback is required and must be a Function.");
+  }
+
+  GetReferencesBaton* baton = new GetReferencesBaton;
+
+  baton->error_code = GIT_OK;
+  baton->error = NULL;
+  baton->out = new std::vector<git_reference *>;
+  baton->repo = Nan::ObjectWrap::Unwrap<GitRepository>(info.This())->GetValue();
+
+  Nan::Callback *callback = new Nan::Callback(Local<Function>::Cast(info[0]));
+  GetReferencesWorker *worker = new GetReferencesWorker(baton, callback);
+  worker->SaveToPersistent("repo", info.This());
+  Nan::AsyncQueueWorker(worker);
+  return;
+}
+
+void GitRepository::GetReferencesWorker::Execute()
+{
+  giterr_clear();
+
+  LockMaster lockMaster(true, baton->repo);
+  git_repository *repo = baton->repo;
+
+  git_strarray reference_names;
+  baton->error_code = git_reference_list(&reference_names, repo);
+
+  if (baton->error_code != GIT_OK) {
+    if (giterr_last() != NULL) {
+      baton->error = git_error_dup(giterr_last());
+    }
+    delete baton->out;
+    baton->out = NULL;
+    return;
+  }
+
+  for (size_t reference_index = 0; reference_index < reference_names.count; ++reference_index) {
+    git_reference *reference;
+    baton->error_code = git_reference_lookup(&reference, repo, reference_names.strings[reference_index]);
+
+    // stop execution and return if there is an error
+    if (baton->error_code != GIT_OK) {
+      if (giterr_last() != NULL) {
+        baton->error = git_error_dup(giterr_last());
+      }
+
+      // unwind and return
+      while (baton->out->size()) {
+        git_reference *referenceToFree = baton->out->back();
+        baton->out->pop_back();
+        git_reference_free(referenceToFree);
+      }
+
+      git_strarray_free(&reference_names);
+      git_repository_free(repo);
+      delete baton->out;
+      baton->out = NULL;
+      return;
+    }
+
+    if (git_reference_type(reference) == GIT_REF_SYMBOLIC) {
+      git_reference *resolved_reference;
+      int resolve_result = git_reference_resolve(&resolved_reference, reference);
+      git_reference_free(reference);
+
+      // if we can't resolve the ref, then just ignore it
+      if (resolve_result == GIT_OK) {
+        baton->out->push_back(resolved_reference);
+      }
+    } else {
+      baton->out->push_back(reference);
+    }
+  }
+}
+
+void GitRepository::GetReferencesWorker::HandleOKCallback()
+{
+  if (baton->out != NULL)
+  {
+    unsigned int size = baton->out->size();
+    Local<Array> result = Nan::New<Array>(size);
+    for (unsigned int i = 0; i < size; i++) {
+      git_reference *reference = baton->out->at(i);
+      Nan::Set(
+        result,
+        Nan::New<Number>(i),
+        GitRefs::New(
+          reference,
+          true,
+          GitRepository::New(git_reference_owner(reference), true)->ToObject()
+        )
+      );
+    }
+
+    delete baton->out;
+
+    Local<v8::Value> argv[2] = {
+      Nan::Null(),
+      result
+    };
+    callback->Call(2, argv, async_resource);
+  }
+  else if (baton->error)
+  {
+    Local<v8::Value> argv[1] = {
+      Nan::Error(baton->error->message)
+    };
+    callback->Call(1, argv, async_resource);
+    if (baton->error->message)
+    {
+      free((void *)baton->error->message);
+    }
+
+    free((void *)baton->error);
+  }
+  else if (baton->error_code < 0)
+  {
+    Local<v8::Object> err = Nan::Error("Repository getReferences has thrown an error.")->ToObject();
+    err->Set(Nan::New("errno").ToLocalChecked(), Nan::New(baton->error_code));
+    err->Set(Nan::New("errorFunction").ToLocalChecked(), Nan::New("Repository.getReferences").ToLocalChecked());
+    Local<v8::Value> argv[1] = {
+      err
+    };
+    callback->Call(1, argv, async_resource);
+  }
+  else
+  {
+    callback->Call(0, NULL, async_resource);
+  }
+}
diff --git a/lib/repository.js b/lib/repository.js
@@ -24,6 +24,7 @@ var TreeBuilder = NodeGit.Treebuilder;
 var _discover = Repository.discover;
 var _initExt = Repository.initExt;
 var _fetchheadForeach = Repository.prototype.fetchheadForeach;
+var _getReferences = Repository.prototype.getReferences;
 var _mergeheadForeach = Repository.prototype.mergeheadForeach;
 
 function applySelectedLinesToTarget
@@ -349,44 +350,21 @@ Repository.initExt = function(repo_path, opts) {
 };
 
 
-Repository.getReferences = function(repo, type, refNamesOnly, callback) {
-  return Reference.list(repo).then(function(refList) {
-    var refFilterPromises = [];
-    var filteredRefs = [];
-
-    refList.forEach(function(refName) {
-      refFilterPromises.push(Reference.lookup(repo, refName)
-        .then(function(ref) {
-          if (type == Reference.TYPE.LISTALL || ref.type() == type) {
-            if (refNamesOnly) {
-              filteredRefs.push(refName);
-              return;
-            }
-
-            if (ref.isSymbolic()) {
-              return ref.resolve().then(function(resolvedRef) {
-                resolvedRef.repo = repo;
-
-                filteredRefs.push(resolvedRef);
-              })
-              .catch(function() {
-                // If we can't resolve the ref then just ignore it.
-              });
-            }
-            else {
-              filteredRefs.push(ref);
-            }
-          }
-        })
-      );
+Repository.getReferences = function(repo, type, refNamesOnly) {
+  return repo.getReferences().then(function(refList) {
+    var filteredRefList = refList;
+
+    filteredRefList.filter(function(reference) {
+      return type == Reference.TYPE.LISTALL || ref.type === type
     });
 
-    return Promise.all(refFilterPromises).then(function() {
-      if (typeof callback === "function") {
-        callback(null, filteredRefs);
-      }
-      return filteredRefs;
-    }, callback);
+    if (refNamesOnly) {
+      filteredRefList.map(function(reference) {
+        return reference.name();
+      });
+    }
+
+    return filteredRefList;
   });
 };
 
@@ -1289,9 +1267,6 @@ Repository.prototype.getReferenceNames = function(type, callback) {
  * @param {Reference.TYPE} type Type of reference to look up
  * @return {Array<Reference>}
  */
-Repository.prototype.getReferences = function(type, callback) {
-  return Repository.getReferences(this, type, false, callback);
-};
 
 /**
  * Gets a remote from the repo