nodegit · johnhaley81 · Dec 5, 2014 · Dec 5, 2014 · Dec 5, 2014 · Dec 5, 2014
diff --git a/example/fetch.js b/example/fetch.js
@@ -2,8 +2,11 @@ var nodegit = require('../');
 var path = require('path');
 
 nodegit.Repository.open(path.resolve(__dirname, '../.git')).then(function(repo) {
-  return repo.fetch("origin");
-})
-.done(function() {
+  return repo.fetch("origin", {
+    credentials: function(url, userName) {
+      return nodegit.Cred.sshKeyFromAgent(userName);
+    }
+  });
+}).done(function() {
   console.log("It worked!");
 });
diff --git a/generate/input/descriptor.json b/generate/input/descriptor.json
@@ -1073,18 +1073,47 @@
             "reflog_message": {
               "isOptional": true
             }
+          },
+          "isAsync": true,
+          "return": {
+            "isErrorCode": true
           }
         },
         "git_remote_get_fetch_refspecs": {
-          "ignore": true
+          "args": {
+            "array": {
+              "isReturn": true,
+              "shouldAlloc": true,
+              "cppClassName": "Array",
+              "jsClassName": "Array",
+              "size": "count",
+              "key": "strings"
+            }
+          },
+          "isAsync": true
         },
         "git_remote_get_push_refspecs": {
-          "ignore": true
+          "args": {
+            "array": {
+              "isReturn": true,
+              "shouldAlloc": true,
+              "cppClassName": "Array",
+              "jsClassName": "Array",
+              "size": "count",
+              "key": "strings"
+            }
+          },
+          "isAsync": true
         },
         "git_remote_list": {
           "args": {
             "out": {
-              "shouldAlloc": true
+              "isReturn": true,
+              "shouldAlloc": true,
+              "cppClassName": "Array",
+              "jsClassName": "Array",
+              "size": "count",
+              "key": "strings"
             }
           }
         },
@@ -1093,6 +1122,12 @@
         },
         "git_remote_rename": {
           "ignore": true
+        },
+        "git_remote_set_fetch_refspecs": {
+          "ignore": true
+        },
+        "git_remote_set_push_refspecs": {
+          "ignore": true
         }
       }
     },

diff --git a/lib/reference.js b/lib/reference.js
@@ -13,6 +13,15 @@ var Branch = NodeGit.Branch;
 */
 Reference.lookup = LookupWrapper(Reference);
 
+/**
+* Retrieves the reference by it's short name
+* @param {Repository} repo The repo that the reference lives in
+* @param {String|Reference} id The reference to lookup
+* @param {Function} callback
+* @return {Reference}
+*/
+Reference.dwim = LookupWrapper(Reference, Reference.dwim);
+
 /**
  * Returns true if this reference is valid
  * @return {Boolean}

diff --git a/lib/repository.js b/lib/repository.js
@@ -53,37 +53,17 @@ function(name, commit, force, signature, logMessage) {
 };
 
 /**
- * Look up a branch
+ * Look up a refs's commit.
  *
- * @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 instanceof Reference ||
-     ~name.indexOf("refs/heads/")) ? name
-      : "refs/heads/" + name;
-
-  return this.getReference(name).then(function(reference) {
-    if (typeof callback === "function") {
-      callback(null, reference);
-    }
-
-    return reference;
-  }, callback);
-};
-
-/**
- * Look up a branch's most recent commit.
- *
- * @param {String|Ref} name Branch name, e.g. "master" or Branch Ref
+ * @param {String|Ref} name Ref name, e.g. "master", "refs/heads/master"
+ *                          or Branch Ref
  * @param {Function} callback
  * @return {Commit}
  */
-Repository.prototype.getBranchCommit = function(name, callback) {
+Repository.prototype.getReferenceCommit = function(name, callback) {
   var repository = this;
 
-  return this.getBranch(name).then(function(reference) {
+  return this.getReference(name).then(function(reference) {
     return repository.getCommit(reference.target()).then(function(commit) {
       if (typeof callback === "function") {
         callback(null, commit);
@@ -94,6 +74,30 @@ Repository.prototype.getBranchCommit = function(name, callback) {
   }, callback);
 };
 
+/**
+* Look up a branch. Alias for `getReference`
+*
+* @param {String|Ref} name Ref name, e.g. "master", "refs/heads/master"
+*                          or Branch Ref
+* @param {Function} callback
+* @return {Ref}
+*/
+Repository.prototype.getBranch = function(name, callback) {
+  return this.getReference(name, callback);
+};
+
+/**
+* Look up a branch's most recent commit. Alias to `getReferenceCommit`
+*
+* @param {String|Ref} name Ref name, e.g. "master", "refs/heads/master"
+*                          or Branch Ref
+* @param {Function} callback
+* @return {Commit}
+*/
+Repository.prototype.getBranchCommit = function(name, callback) {
+  return this.getReferenceCommit(name, callback);
+};
+
 /**
  * Gets the branch that HEAD currently points to
  * Is an alias to head()
@@ -106,14 +110,15 @@ Repository.prototype.getCurrentBranch = function() {
 /**
  * Lookup the reference with the given name.
  *
- * @param {String} name
+ * @param {String|Ref} name Ref name, e.g. "master", "refs/heads/master"
+ *                          or Branch Ref
  * @param {Function} callback
  * @return {Reference}
  */
 Repository.prototype.getReference = function(name, callback) {
   var repository = this;
 
-  return Reference.lookup(this, name).then(function(reference) {
+  return Reference.dwim(this, name).then(function(reference) {
     if (reference.isSymbolic()) {
       return reference.resolve(function (error, reference) {
         reference.repo = repository;
@@ -507,29 +512,47 @@ Repository.prototype.getRemote = function(remote, callback) {
  *
  * @param {String|Remote} remote
  */
-Repository.prototype.fetch = function(remote) {
+Repository.prototype.fetch = function(
+  remote,
+  remoteCallbacks,
+  ignoreCertErrors,
+  callback)
+{
   var repo = this;
 
   return repo.getRemote(remote).then(function(remote) {
-    return remote.fetch(repo.defaultSignature());
-  });
+    remote.setCallbacks(remoteCallbacks);
+    remote.checkCert(ignoreCertErrors ? 0 : 1);
+
+    return remote.fetch(repo.defaultSignature(), "Fetch from " + remote)
+    .then(function() {
+      if (typeof callback === "function") {
+        callback();
+      }
+    });
+  }, callback);
 };
 
 /**
  * Fetches from all remotes
  */
-Repository.prototype.fetchAll = function() {
+Repository.prototype.fetchAll = function(
+  remoteCallbacks,
+  ignoreCertErrors,
+  callback)
+{
   var repo = this;
 
-  return repo.getRemotes(function(remotes) {
+  return repo.getRemotes().then(function(remotes) {
     var fetchPromises = [];
 
     remotes.forEach(function(remote) {
-      fetchPromises.push(repo.fetch(remote));
+      fetchPromises.push(
+        repo.fetch(remote, remoteCallbacks, ignoreCertErrors, callback));
     });
 
     return Promise.all(fetchPromises);
-  });
+  }, callback);
 };
 
 /**

diff --git a/test/tests/remote.js b/test/tests/remote.js
@@ -104,11 +104,22 @@ describe("Remote", function() {
   });
 
   it("can fetch from a remote", function() {
-    return this.repository.fetch("origin")
-    .then(function() {
-      assert(true);
-    }, function() {
-      assert(false);
-    });
+    return this.repository.fetch("origin", {
+      credentials: function(url, userName) {
+        return NodeGit.Cred.sshKeyFromAgent(userName);
+      }
+    }, true);
+  });
+
+  it("can fetch from all remotes", function() {
+    // Set a reasonable timeout here for the fetchAll test
+    this.timeout(15000);
+
+    return this.repository.fetchAll({
+      credentials: function(url, userName) {
+        return NodeGit.Cred.sshKeyFromAgent(userName);
+      }
+    }, true);
   });
+
 });
diff --git a/test/tests/repository.js b/test/tests/repository.js
@@ -49,8 +49,8 @@ describe("Repository", function() {
 
   it("can list remotes", function() {
     return this.repository.getRemotes().then(function(remotes) {
-      assert.equal(remotes.count(), 1);
-      assert.equal(remotes.strings(), "origin");
+      assert.equal(remotes.length, 1);
+      assert.equal(remotes[0], "origin");
     });
   });