Lookup functions now can normalize their objects

John Haley · maxkorp · commit 39357aa325c4 · 2014-12-01T14:49:50.000-07:00
diff --git a/lib/blob.js b/lib/blob.js
@@ -1,8 +1,18 @@
 var NodeGit = require("../");
 var TreeEntry = require("./tree_entry");
+var LookupWrapper = require("./util/lookupWrapper");
 
 var Blob = NodeGit.Blob;
 
+/**
+* Retrieves the blob pointed to by the oid
+* @param {Repository} repo The repo that the blob lives in
+* @param {String|Oid|Blob} id The blob to lookup
+* @param {Function} callback
+* @return {Blob}
+*/
+Blob.lookup = LookupWrapper(Blob);
+
 /**
  * Retrieve the content of the Blob.
  *
diff --git a/lib/commit.js b/lib/commit.js
@@ -1,9 +1,19 @@
 var events = require("events");
 var Promise = require("nodegit-promise");
 var NodeGit = require("../");
+var LookupWrapper = require("./util/lookupWrapper");
 
 var Commit = NodeGit.Commit;
 
+/**
+ * Retrieves the commit pointed to by the oid
+ * @param {Repository} repo The repo that the commit lives in
+ * @param {String|Oid|Commit} id The commit to lookup
+ * @param {Function} callback
+ * @return {Commit}
+ */
+Commit.lookup = LookupWrapper(Commit);
+
 /**
  * Retrieve the SHA.
  * @return {String}
diff --git a/lib/merge.js b/lib/merge.js
@@ -1,5 +1,6 @@
 var NodeGit = require("../");
 var normalizeOptions = require("./util/normalize_options");
+var Promise = require("nodegit-promise");
 
 var Merge = NodeGit.Merge;
 var mergeCommits = Merge.commits;
@@ -16,7 +17,12 @@ var mergeCommits = Merge.commits;
 Merge.commits = function(repo, ourCommit, theirCommit, options) {
   options = normalizeOptions(options, NodeGit.MergeOptions);
 
-  return mergeCommits.call(this, repo, ourCommit, theirCommit, options);
+  return Promise.all([
+    repo.getCommit(ourCommit),
+    repo.getCommit(theirCommit)
+  ]).then(function(commits) {
+    return mergeCommits.call(this, repo, commits[0], commits[1], options);
+  });
 };
 
 module.exports = Merge;
diff --git a/lib/reference.js b/lib/reference.js
@@ -1,8 +1,18 @@
 var NodeGit = require("../");
+var LookupWrapper = require("./util/lookupWrapper");
 
 var Reference = NodeGit.Reference;
 var Branch = NodeGit.Branch;
 
+/**
+* Retrieves the reference pointed to by the oid
+* @param {Repository} repo The repo that the reference lives in
+* @param {String|Reference} id The reference to lookup
+* @param {Function} callback
+* @return {Reference}
+*/
+Reference.lookup = LookupWrapper(Reference);
+
 /**
  * Returns true if this reference is valid
  * @return {Boolean}
diff --git a/lib/repository.js b/lib/repository.js
@@ -55,12 +55,14 @@ function(name, commit, force, signature, logMessage) {
 /**
  * Look up a branch
  *
- * @param {String} name Branch name, e.g. "master"
+ * @param {String|Ref} name Branch name, e.g. "master" or Branch Ref
  * @param {Function} callback
  * @return {Ref}
  */
 Repository.prototype.getBranch = function(name, callback) {
-  name = ~name.indexOf("refs/heads/") ? name : "refs/heads/" + name;
+  name = name instanceof Reference || ~name.indexOf("refs/heads/")
+    ? name
+    : "refs/heads/" + name;
 
   return this.getReference(name).then(function(reference) {
     if (typeof callback === "function") {
@@ -74,7 +76,7 @@ Repository.prototype.getBranch = function(name, callback) {
 /**
  * Look up a branch's most recent commit.
  *
- * @param {String} name Branch name, e.g. "master"
+ * @param {String|Ref} name Branch name, e.g. "master" or Branch Ref
  * @param {Function} callback
  * @return {Commit}
  */
@@ -331,40 +333,40 @@ Repository.prototype.getHeadCommit = function(callback) {
 Repository.prototype.createCommit = function(
   updateRef, author, committer, message, tree, parents, callback) {
 
-  var createCommit = null;
   var repo = this;
+  var promises = [];
 
-  if (tree instanceof Tree) {
-    createCommit = Promise.all([
-      Commit.create(
-        repo,
-        updateRef,
-        author,
-        committer,
-        null /* use default message encoding */,
-        message,
-        tree,
-        parents.length,
-        parents
-      )
-    ]);
-  } else {
-    createCommit = this.getTree(tree).then(function(tree) {
-      return Commit.create(
-        repo,
-        updateRef,
-        author,
-        committer,
-        null /* use default message encoding */,
-        message,
-        tree,
-        parents.length,
-        parents
-      );
-    });
-  }
+  parents = parents || [];
+
+  promises.push(repo.getTree(tree));
+
+  parents.forEach(function(parent) {
+    promises.push(repo.getCommit(parent));
+  });
 
-  return createCommit.then(function(commit) {
+  return Promise.all(promises).then(function(results) {
+    tree = results[0];
+
+    // Get the normalized values for our input into the function
+    var parentsLength = parents.length;
+    parents = [];
+
+    for (var i = 0; i < parentsLength; i++) {
+      parents.push(results[i + 1]);
+    }
+
+    return Commit.create(
+      repo,
+      updateRef,
+      author,
+      committer,
+      null /* use default message encoding */,
+      message,
+      tree,
+      parents.length,
+      parents
+    );
+  }).then(function(commit) {
     if (typeof callback === "function") {
       callback(null, commit);
     }
diff --git a/lib/tag.js b/lib/tag.js
@@ -1,5 +1,15 @@
 var git = require("../");
+var LookupWrapper = require("./util/lookupWrapper");
 
 var Tag = git.Tag;
 
+/**
+* Retrieves the tag pointed to by the oid
+* @param {Repository} repo The repo that the tag lives in
+* @param {String|Oid|Tag} id The tag to lookup
+* @param {Function} callback
+* @return {Tag}
+*/
+Tag.lookup = LookupWrapper(Tag);
+
 module.exports = Tag;
diff --git a/lib/tree.js b/lib/tree.js
@@ -3,6 +3,16 @@ var Tree = git.Tree;
 var Treebuilder = git.Treebuilder;
 var Diff = git.Diff;
 var events = require("events");
+var LookupWrapper = require("./util/lookupWrapper");
+
+/**
+* Retrieves the tree pointed to by the oid
+* @param {Repository} repo The repo that the tree lives in
+* @param {String|Oid|Tree} id The tree to lookup
+* @param {Function} callback
+* @return {Tree}
+*/
+Tree.lookup = LookupWrapper(Tree);
 
 /**
  * Diff two trees
diff --git a/lib/util/lookupWrapper.js b/lib/util/lookupWrapper.js
@@ -0,0 +1,37 @@
+var Promise = require("nodegit-promise");
+
+/**
+* Wraps a method so that you can pass in either a string, OID or the object
+* itself and you will always get back a promise that resolves to the object.
+* @param {Object} objectType The object type that you're expecting to receive.
+* @param {Function} lookupFunction  The function to do the lookup for the
+*                                   object. Defaults to `objectType.lookup`.
+* @return {Function}
+*/
+module.exports = function(objectType, lookupFunction) {
+  lookupFunction = lookupFunction || objectType.lookup;
+  
+  return function(repo, id, callback) {
+    if (id instanceof objectType) {
+      return Promise.resolve(id).then(function(obj) {
+        obj.repo = repo;
+
+        if (typeof callback === "function") {
+          callback(null, obj);
+        }
+
+        return obj;
+      }, callback);
+    }
+
+    return lookupFunction(repo, id).then(function(obj) {
+      obj.repo = repo;
+
+      if (typeof callback === "function") {
+        callback(null, obj);
+      }
+
+      return obj;
+    }, callback);
+  };
+};
