Return defaultResult when not waiting for callback result

srajko · srajko · commit 629d45c7d4ee · 2017-02-13T10:36:41.000-07:00
diff --git a/generate/templates/manual/include/async_baton.h b/generate/templates/manual/include/async_baton.h
@@ -12,37 +12,48 @@
 // or field properties of configuration objects whose values are callbacks)
 struct AsyncBaton {
   uv_sem_t semaphore;
+
+  virtual ~AsyncBaton() {}
 };
 
+void deleteBaton(AsyncBaton *baton);
+
 template<typename ResultT>
 struct AsyncBatonWithResult : public AsyncBaton {
   ResultT result;
   ResultT defaultResult; // result returned if the callback doesn't return anything valid
+  void (*onCompletion)(AsyncBaton *);
 
   AsyncBatonWithResult(const ResultT &defaultResult)
     : defaultResult(defaultResult) {
-    uv_sem_init(&semaphore, 0);
-  }
-
-  ~AsyncBatonWithResult() {
-    uv_sem_destroy(&semaphore);
   }
 
   void Done() {
-    // signal completion
-    uv_sem_post(&semaphore);
+    if (onCompletion) {
+      onCompletion(this);
+    } else {
+      // signal completion
+      uv_sem_post(&semaphore);
+    }
   }
 
-  ResultT ExecuteAsync(ThreadPool::Callback asyncCallback) {
+  ResultT ExecuteAsync(ThreadPool::Callback asyncCallback, void (*onCompletion)(AsyncBaton *) = NULL) {
     result = 0;
+    this->onCompletion = onCompletion;
+    if (!onCompletion) {
+      uv_sem_init(&semaphore, 0);
+    }
 
     {
       LockMaster::TemporaryUnlock temporaryUnlock;
 
       libgit2ThreadPool.ExecuteReverseCallback(asyncCallback, this);
 
-      // wait for completion
-      uv_sem_wait(&semaphore);
+      if (!onCompletion) {
+        // wait for completion
+        uv_sem_wait(&semaphore);
+        uv_sem_destroy(&semaphore);
+      }
     }
 
     return result;
diff --git a/generate/templates/manual/src/async_baton.cc b/generate/templates/manual/src/async_baton.cc
@@ -0,0 +1,5 @@
+#include "../include/async_baton.h"
+
+void deleteBaton(AsyncBaton *baton) {
+  delete baton;
+}
diff --git a/generate/templates/partials/field_accessors.cc b/generate/templates/partials/field_accessors.cc
@@ -119,19 +119,28 @@
           {{ arg.cType }} {{ arg.name}}{% if not arg.lastArg %},{% endif %}
         {% endeach %}
       ) {
-        {{ field.name|titleCase }}Baton baton({{ field.return.noResults }});
+        {{ field.name|titleCase }}Baton *baton =
+          new {{ field.name|titleCase }}Baton({{ field.return.noResults }});
 
         {% each field.args|argsInfo as arg %}
-          baton.{{ arg.name }} = {{ arg.name }};
+          baton->{{ arg.name }} = {{ arg.name }};
         {% endeach %}
 
-        {{ cppClassName }}* instance = {{ field.name }}_getInstanceFromBaton(&baton);
+        {{ cppClassName }}* instance = {{ field.name }}_getInstanceFromBaton(baton);
+
+        {{ field.return.type }} result;
 
         if (instance->{{ field.name }}.WillBeThrottled()) {
-          return baton.defaultResult;
+          result = baton->defaultResult;
+          delete baton;
+        } else if (instance->{{ field.name }}.ShouldWaitForResult()) {
+          result = baton->ExecuteAsync({{ field.name }}_async);
+          delete baton;
+        } else {
+          result = baton->defaultResult;
+          baton->ExecuteAsync({{ field.name }}_async, deleteBaton);
         }
-
-        return baton.ExecuteAsync({{ field.name }}_async);
+        return result;
       }
 
       void {{ cppClassName }}::{{ field.name }}_async(void *untypedBaton) {
diff --git a/generate/templates/templates/binding.gyp b/generate/templates/templates/binding.gyp
@@ -12,6 +12,7 @@
       },
 
       "sources": [
+        "src/async_baton.cc",
         "src/lock_master.cc",
         "src/nodegit.cc",
         "src/init_ssh2.cc",
diff --git a/test/tests/clone.js b/test/tests/clone.js
@@ -166,6 +166,37 @@ describe("Clone", function() {
     });
   });
 
+  it("can clone without waiting for callback results", function() {
+    var test = this;
+    var url = "https://github.com/nodegit/test.git";
+    var lastReceivedObjects = 0;
+    var cloneFinished = false;
+    var opts = {
+        fetchOpts: {
+          callbacks: {
+            transferProgress: {
+              waitForResult: false,
+              callback: function(progress) {
+                var receivedObjects = progress.receivedObjects();
+                assert.false(
+                  cloneFinished,
+                  "callback running after clone completion"
+                );
+                assert.gt(receivedObjects, lastReceivedObjects);
+                lastReceivedObjects = receivedObjects;
+              }
+            }
+          }
+        }
+    };
+
+    return Clone(url, clonePath, opts).then(function(repo) {
+      assert.ok(repo instanceof Repository);
+      cloneFinished = true;
+      test.repository = repo;
+    });
+  });
+
   it("can clone using nested function", function() {
     var test = this;
     var url = "https://github.com/nodegit/test.git";
