Added blobsOnly flag to walk, if true only blobs & blob executables are returned during a walk

faceleg · faceleg · commit 2d7d237c4ecc · 2013-04-03T23:42:48.000+13:00
diff --git a/include/tree.h b/include/tree.h
@@ -72,6 +72,8 @@ class GitTree : public ObjectWrap {
       std::vector<WalkEntry* > rawTreeEntries;
 
       git_tree* rawTree;
+      bool blobsOnly;
+
       Persistent<Function> entryCallback;
       Persistent<Function> endCallback;
     };
diff --git a/lib/tree.js b/lib/tree.js
@@ -48,33 +48,34 @@ Tree.prototype.entry = function(path, callback) {
  * @fires Tree#entry
  * @fires Tree#end
  *
+ * @param {Boolean} [blobsOnly = true] True to emit only blob & blob executable entries.
+ *
  * @return {EventEmitter}
  */
-Tree.prototype.walk = function() {
+Tree.prototype.walk = function(blobsOnly) {
+  blobsOnly = typeof blobsOnly === 'undefined' ? true : blobsOnly;
+
   var self = this,
       event = new events.EventEmitter(),
       entries = [];
 
-  self.rawTree.walk(function treeWalkEntries(error, rawEntries) {
+  var total = 0;
+
+  self.rawTree.walk(blobsOnly, function treeWalkEntries(error, rawEntries) {
     rawEntries.forEach(function treeWalkEntryEmitter(rawEntry) {
       var entry = new git.entry(self.rawRepo, rawEntry);
       entries.push(entry);
-      if (!error) {
-        /**
-         * Entry event.
-         *
-         * @event Tree#entry
-         *
-         * @param {GitError|null} error An error object if there was an issue, null otherwise.
-         * @param {Entry} entry The tree entry.
-         */
-        event.emit('entry', null, entry);
-      }
+      /**
+       * Entry event.
+       *
+       * @event Tree#entry
+       *
+       * @param {GitError|null} error An error object if there was an issue, null otherwise.
+       * @param {Entry} entry The tree entry.
+       */
+      event.emit('entry', null, entry);
     });
   }, function treeWalkEnd(error) {
-    if (error) {
-      event.emit('end', git.error(error), entries);
-    }
     /**
      * End event.
      *
@@ -83,7 +84,7 @@ Tree.prototype.walk = function() {
      * @param {GitError|null} error An error object if there was an issue, null otherwise.
      * @param {Entry[]} entries The tree entries.
      */
-    event.emit('end', null, entries);
+      event.emit('end', error ? git.error(error) : null, entries);
   });
 
   return event;
diff --git a/src/tree.cc b/src/tree.cc
@@ -66,11 +66,15 @@ Handle<Value> GitTree::Walk(const Arguments& args) {
     return ThrowException(Exception::Error(String::New("No tree list to Walk.")));
   }
 
-  if(args.Length() == 0 || !args[0]->IsFunction()) {
-    return ThrowException(Exception::Error(String::New("Entry callback is required and must be a Function.")));
+  if(args.Length() == 0 || !args[0]->IsBoolean()) {
+    return ThrowException(Exception::Error(String::New("Blobs only flag is required and must be a Boolean.")));
   }
 
   if(args.Length() == 1 || !args[1]->IsFunction()) {
+    return ThrowException(Exception::Error(String::New("Entry callback is required and must be a Function.")));
+  }
+
+  if(args.Length() == 2 || !args[2]->IsFunction()) {
     return ThrowException(Exception::Error(String::New("End callback is required and must be a Function.")));
   }
 
@@ -82,8 +86,9 @@ Handle<Value> GitTree::Walk(const Arguments& args) {
 
   baton->rawTree = tree->GetValue();
   baton->error = NULL;
-  baton->entryCallback = Persistent<Function>::New(Local<Function>::Cast(args[0]));
-  baton->endCallback = Persistent<Function>::New(Local<Function>::Cast(args[1]));
+  baton->blobsOnly = CastFromJS<bool>(args[0]->ToBoolean());
+  baton->entryCallback = Persistent<Function>::New(Local<Function>::Cast(args[1]));
+  baton->endCallback = Persistent<Function>::New(Local<Function>::Cast(args[2]));
 
   uv_thread_create(&baton->threadId, WalkWork, baton);
 
@@ -106,16 +111,32 @@ void GitTree::WalkWork(void* payload) {
   baton->asyncEnd.data = baton;
   uv_async_send(&baton->asyncEnd);
 }
-int GitTree::WalkWorkEntry(const char* root, const git_tree_entry* entry, void* payload) {
+int GitTree::WalkWorkEntry(const char* root, const git_tree_entry* entry,
+                           void* payload) {
   WalkBaton *baton = static_cast<WalkBaton *>(payload);
 
   uv_mutex_lock(&baton->mutex);
 
-  GitTree::WalkEntry* walkEntry = new WalkEntry;
-  walkEntry->rawEntry = git_tree_entry_dup(entry);
-  walkEntry->root = root;
+  if (!baton->blobsOnly) {
+
+    GitTree::WalkEntry* walkEntry = new WalkEntry;
+    walkEntry->rawEntry = git_tree_entry_dup(entry);
+    walkEntry->root = root;
+    baton->rawTreeEntries.push_back(walkEntry);
 
-  baton->rawTreeEntries.push_back(walkEntry);
+  } else {
+    git_tree_entry* rawEntry = git_tree_entry_dup(entry);
+    git_filemode_t fileMode = git_tree_entry_filemode(rawEntry);
+
+    if (fileMode == GIT_FILEMODE_BLOB ||
+        fileMode == GIT_FILEMODE_BLOB_EXECUTABLE) {
+
+      GitTree::WalkEntry* walkEntry = new WalkEntry;
+      walkEntry->rawEntry = rawEntry;
+      walkEntry->root = root;
+      baton->rawTreeEntries.push_back(walkEntry);
+    }
+  }
 
   uv_mutex_unlock(&baton->mutex);
 
