Added lookup to tree

faceleg · faceleg · commit f2fd93af0232 · 2013-04-04T00:53:58.000+13:00
diff --git a/include/tree.h b/include/tree.h
@@ -42,6 +42,10 @@ class GitTree : public ObjectWrap {
 
     static Handle<Value> New(const Arguments& args);
 
+    static Handle<Value> Lookup(const Arguments& args);
+    static void LookupWork(uv_work_t* req);
+    static void LookupAfterWork(uv_work_t* req);
+
     static Handle<Value> Walk(const Arguments& args);
     static void WalkWork(void* payload);
     static int WalkWorkEntry(const char *root, const git_tree_entry *entry, void *payload);
@@ -56,6 +60,17 @@ class GitTree : public ObjectWrap {
 
     git_tree* tree;
 
+    struct LookupBaton {
+      uv_work_t request;
+      const git_error* error;
+
+      git_oid rawOid;
+      git_repository* rawRepo;
+      git_tree* rawTree;
+
+      Persistent<Function> callback;
+    };
+
     struct WalkEntry {
         git_tree_entry* rawEntry;
         std::string root;
diff --git a/lib/tree.js b/lib/tree.js
@@ -22,6 +22,27 @@ var Tree = function(rawRepo, rawTree) {
   }
 };
 
+/**
+ * Retrieve the raw tree identified by the given Oid.
+ *
+ * @param  {Oid} oid The Oid identifying a tree.
+ * @param  {Tree~lookupCallback} callback
+ */
+Tree.prototype.lookup = function(oid, callback) {
+  /**
+   * @callback Tree~lookupCallback Callback executed when the tree is retrieved.
+   * @param {GitError|null} error An Error or null if successful.
+   * @param {Tree|null} tree The tree object or null.
+   */
+  var self = this;
+  self.rawTree.lookup(oid.getRawOid(), self.rawRepo, function(error, rawTree) {
+    if (success(error, callback)) {
+      self.rawTree = rawTree;
+      callback(null, self);
+    }
+  });
+};
+
 /**
  * Retrieve the entry by path.
  *
@@ -32,7 +53,7 @@ Tree.prototype.entry = function(path, callback) {
   /**
    * @callback Tree~entryCallback Callback executed when an entry is retrieved.
    * @param {GitError|null} error An Error or null if successful.
-   * @param {Entry|null} blob The tree entry object or null.
+   * @param {Entry|null} entry The tree entry object or null.
    */
   var self = this;
   self.rawTree.entryByPath(path, function(error, rawEntry) {
diff --git a/src/tree.cc b/src/tree.cc
@@ -33,6 +33,7 @@ void GitTree::Initialize (Handle<v8::Object> target) {
   tpl->InstanceTemplate()->SetInternalFieldCount(1);
   tpl->SetClassName(String::NewSymbol("Tree"));
 
+  NODE_SET_PROTOTYPE_METHOD(tpl, "lookup", Lookup);
   NODE_SET_PROTOTYPE_METHOD(tpl, "walk", Walk);
   NODE_SET_PROTOTYPE_METHOD(tpl, "entryByPath", EntryByPath);
 
@@ -57,6 +58,64 @@ Handle<Value> GitTree::New(const Arguments& args) {
   return scope.Close(args.This());
 }
 
+Handle<Value> GitTree::Lookup(const Arguments& args) {
+  HandleScope scope;
+
+  if(args.Length() == 0 || !args[0]->IsObject()) {
+    return ThrowException(Exception::Error(String::New("Oid is required and must be a Object.")));
+  }
+
+  if(args.Length() == 1 || !args[1]->IsObject()) {
+    return ThrowException(Exception::Error(String::New("Repository is required and must be a Object.")));
+  }
+
+  if(args.Length() == 2 || !args[2]->IsFunction()) {
+    return ThrowException(Exception::Error(String::New("Callback is required and must be a Function.")));
+  }
+
+  LookupBaton* baton = new LookupBaton;
+  baton->request.data = baton;
+  baton->error = NULL;
+  baton->rawTree = ObjectWrap::Unwrap<GitTree>(args.This())->GetValue();
+  baton->rawOid = ObjectWrap::Unwrap<GitOid>(args[0]->ToObject())->GetValue();
+  baton->rawRepo = ObjectWrap::Unwrap<GitRepo>(args[1]->ToObject())->GetValue();
+  baton->callback = Persistent<Function>::New(Local<Function>::Cast(args[2]));
+
+  uv_queue_work(uv_default_loop(), &baton->request, LookupWork, (uv_after_work_cb)LookupAfterWork);
+
+  return Undefined();
+}
+void GitTree::LookupWork(uv_work_t* req) {
+  LookupBaton* baton = static_cast<LookupBaton*>(req->data);
+
+  int returnCode = git_tree_lookup(&baton->rawTree, baton->rawRepo, &baton->rawOid);
+  if (returnCode != GIT_OK) {
+    baton->error = giterr_last();
+  }
+}
+void GitTree::LookupAfterWork(uv_work_t* req) {
+  HandleScope scope;
+  LookupBaton* baton = static_cast<LookupBaton* >(req->data);
+
+  if (success(baton->error, baton->callback)) {
+    Local<Object> tree = GitTree::constructor_template->NewInstance();
+    GitTree *treeInstance = ObjectWrap::Unwrap<GitTree>(tree);
+    treeInstance->SetValue(baton->rawTree);
+
+    Handle<Value> argv[2] = {
+      Local<Value>::New(Null()),
+      tree
+    };
+
+    TryCatch try_catch;
+    baton->callback->Call(Context::GetCurrent()->Global(), 2, argv);
+    if (try_catch.HasCaught()) {
+        node::FatalException(try_catch);
+    }
+  }
+  delete req;
+}
+
 Handle<Value> GitTree::Walk(const Arguments& args) {
   HandleScope scope;
 
