nodegit · implausible · Feb 5, 2019 · Feb 5, 2019 · Feb 5, 2019
diff --git a/lib/commit.js b/lib/commit.js
@@ -60,8 +60,7 @@ Commit.prototype.amend = function (
  * @param {String} messageEncoding
  * @param {String} message
  * @param {Tree|Oid} tree
- * @param {String} signatureField
- * @param {Function} onSignature
+ * @param {Function} onSignature Callback to be called with string to be signed
  * @return {Oid}
 */
 Commit.prototype.amendWithSignature = function(
@@ -71,13 +70,12 @@ Commit.prototype.amendWithSignature = function(
   messageEncoding,
   message,
   tree,
-  signatureField,
   onSignature
 ) {
-    var repo = this.repo;
-    var parentOids = this.parents();
-    var _this = this;
-    var promises = [];
+    let repo = this.repo;
+    let parentOids = this.parents();
+    let _this = this;
+    let promises = [];
 
     if (tree instanceof NodeGit.Oid) {
       promises.push(repo.getTree(tree));
@@ -89,22 +87,27 @@ Commit.prototype.amendWithSignature = function(
       promises.push(repo.getCommit(parentOid));
     });
 
-    var treeObject;
-    var parents;
-    var commitContent;
-    var commitOid;
-    var commit;
-
-    var createCommitPromise = Promise.all(promises)
+    let treeObject;
+    let parents;
+    let commitContent;
+    let commit;
+    let skippedSigning;
+    let resolvedAuthor;
+    let resolvedCommitter;
+    let resolvedMessageEncoding;
+    let resolvedMessage;
+    let resolvedTree;
+
+    let createCommitPromise = Promise.all(promises)
       .then(function(results) {
         treeObject = fp.head(results);
         parents = fp.tail(results);
         return _this.getTree();
       })
       .then(function(commitTreeResult) {
-        var commitTree = commitTreeResult;
+        let commitTree = commitTreeResult;
 
-        var truthyArgs = fp.omitBy(
+        let truthyArgs = fp.omitBy(
           fp.isNil,
           {
             author,
@@ -115,15 +118,15 @@ Commit.prototype.amendWithSignature = function(
           }
         );
 
-        var commitFields = {
+        let commitFields = {
           author: _this.author(),
           committer: _this.committer(),
           messageEncoding: _this.messageEncoding(),
           message: _this.message(),
           tree: commitTree
         };
 
-        var {
+        ({
           author: resolvedAuthor,
           committer: resolvedCommitter,
           messageEncoding: resolvedMessageEncoding,
@@ -132,7 +135,7 @@ Commit.prototype.amendWithSignature = function(
         } = fp.assign(
           commitFields,
           truthyArgs
-        );
+        ));
 
         return Commit.createBuffer(
           repo,
@@ -152,30 +155,61 @@ Commit.prototype.amendWithSignature = function(
         }
         return onSignature(commitContent);
       })
-      .then(function(signature) {
-        return Commit.createWithSignature(
-          repo,
-          commitContent,
-          signature,
-          signatureField
-        );
+      .then(function({ code, field, signedData }) {
+        switch (code) {
+          case NodeGit.Error.CODE.OK:
+            return Commit.createWithSignature(
+              repo,
+              commitContent,
+              signedData,
+              field
+            );
+          case NodeGit.Error.CODE.PASSTHROUGH:
+            skippedSigning = true;
+            return Commit.create(
+              repo,
+              updateRef,
+              resolvedAuthor,
+              resolvedCommitter,
+              resolvedMessageEncoding,
+              resolvedMessage,
+              resolvedTree,
+              parents.length,
+              parents
+            );
+          default: {
+            const error = new Error(
+              `Commit.amendWithSignature threw with error code ${code}`
+            );
+            error.errno = code;
+            throw error;
+          }
+        }
       });
 
     if (!updateRef) {
       return createCommitPromise;
     }
 
-    return createCommitPromise.then(function(commitOidResult) {
-      commitOid = commitOidResult;
-      return repo.getCommit(commitOid);
-    }).then(function(commitResult) {
-      commit = commitResult;
-      return repo.getReference(updateRef);
-    }).then(function(ref) {
-      return ref.setTarget(commitOid, `commit (amend): ${commit.summary()}`);
-    }).then(function() {
-      return commitOid;
-    });
+    return createCommitPromise
+      .then(function(commitOid) {
+        if (skippedSigning) {
+          return commitOid;
+        }
+
+        return repo.getCommit(commitOid)
+          .then(function(commitResult) {
+            commit = commitResult;
+            return repo.getReference(updateRef);
+          }).then(function(ref) {
+            return ref.setTarget(
+              commitOid,
+              `commit (amend): ${commit.summary()}`
+            );
+          }).then(function() {
+            return commitOid;
+          });
+      });
 };
 
 /**

diff --git a/lib/rebase.js b/lib/rebase.js
@@ -9,8 +9,8 @@ var _abort = Rebase.prototype.abort;
 var _commit = Rebase.prototype.commit;
 
 function defaultRebaseOptions(options, checkoutStrategy) {
-  var checkoutOptions;
-  var mergeOptions;
+  let checkoutOptions;
+  let mergeOptions;
 
   if (options) {
     options = shallowClone(options);
@@ -19,6 +19,27 @@ function defaultRebaseOptions(options, checkoutStrategy) {
     delete options.checkoutOptions;
     delete options.mergeOptions;
 
+    if (options.signingCb) {
+      let signingCb = options.signingCb;
+      options.signingCb = function (
+        signatureBuf,
+        signatureFieldBuf,
+        commitContent
+      ) {
+        return Promise.resolve(signingCb(commitContent))
+          .then(function({ code, field, signedData }) {
+            if (code === NodeGit.Error.CODE.OK) {
+              signatureBuf.setString(signedData);
+              if (field) {
+                signatureFieldBuf.setString(field);
+              }
+            }
+
+            return code;
+          });
+      };
+    }
+
     options = normalizeOptions(options, NodeGit.RebaseOptions);
   } else {
     options = normalizeOptions({}, NodeGit.RebaseOptions);

diff --git a/lib/repository.js b/lib/repository.js
@@ -658,25 +658,24 @@ Repository.prototype.createCommitBuffer = function(
  * @param {String} message
  * @param {Tree|Oid|String} Tree
  * @param {Array} parents
- * @param {String} signature_field typically "gpgsig"
  * @param {Function} onSignature Callback to be called with string to be signed
  * @return {Oid} The oid of the commit
  */
 Repository.prototype.createCommitWithSignature = function(
-    updateRef,
-    author,
-    committer,
-    message,
-    tree,
-    parents,
-    signature_field,
-    onSignature) {
+  updateRef,
+  author,
+  committer,
+  message,
+  tree,
+  parents,
+  onSignature
+) {
 
   var repo = this;
   var promises = [];
-  var commit_content;
-  var commit_oid;
+  var commitContent;
   var commit;
+  var skippedSigning;
 
   parents = parents || [];
 
@@ -707,35 +706,65 @@ Repository.prototype.createCommitWithSignature = function(
       parents.length,
       parents
     );
-  }).then(function(commit_contentResult) {
-    commit_content = commit_contentResult;
-    if (!commit_content.endsWith("\n")) {
-      commit_content += "\n";
+  }).then(function(commitContentResult) {
+    commitContent = commitContentResult;
+    if (!commitContent.endsWith("\n")) {
+      commitContent += "\n";
+    }
+    return onSignature(commitContent);
+  }).then(function({ code, field, signedData }) {
+    switch (code) {
+      case NodeGit.Error.CODE.OK:
+        return Commit.createWithSignature(
+          repo,
+          commitContent,
+          signedData,
+          field
+        );
+      case NodeGit.Error.CODE.PASSTHROUGH:
+        skippedSigning = true;
+        return Commit.create(
+          repo,
+          updateRef,
+          author,
+          committer,
+          null /* use default message encoding */,
+          message,
+          tree,
+          parents.length,
+          parents
+        );
+      default: {
+        const error = new Error(
+          "Repository.prototype.createCommitWithSignature " +
+          `threw with error code ${code}`
+        );
+        error.errno = code;
+        throw error;
+      }
     }
-    return onSignature(commit_content);
-  }).then(function(signature) {
-    return Commit.createWithSignature(
-      repo,
-      commit_content,
-      signature,
-      signature_field);
   });
 
   if (!updateRef) {
     return createCommitPromise;
   }
 
-  return createCommitPromise.then(function(commit_oidResult) {
-    commit_oid = commit_oidResult;
-    return repo.getCommit(commit_oid);
-  }).then(function(commitResult) {
-    commit = commitResult;
-    return repo.getReference(updateRef);
-  }).then(function(ref) {
-    return ref.setTarget(commit_oid, getReflogMessageForCommit(commit));
-  }).then(function() {
-    return commit_oid;
-  });
+  return createCommitPromise
+    .then(function(commitOid) {
+      if (skippedSigning) {
+        return commitOid;
+      }
+
+      return repo.getCommit(commitOid)
+        .then(function(commitResult) {
+          commit = commitResult;
+          return repo.getReference(updateRef);
+        }).then(function(ref) {
+          return ref.setTarget(commitOid, getReflogMessageForCommit(commit));
+        }).then(function() {
+          return commitOid;
+        });
+    });
 };
 
 /**

diff --git a/lib/tag.js b/lib/tag.js
@@ -76,10 +76,30 @@ Tag.createWithSignature = function(
       tagBuffer = tagBufferResult;
       return signingCallback(tagBuffer);
     })
-    .then((tagSignature) => {
-      const normalizedEnding = tagSignature.endsWith("\n") ? "" : "\n";
-      const signedTagString = tagBuffer + tagSignature + normalizedEnding;
-      return Tag.createFromBuffer(repo, signedTagString, force);
+    .then(({ code, signedData }) => {
+      switch (code) {
+        case NodeGit.Error.CODE.OK: {
+          const normalizedEnding = signedData.endsWith("\n") ? "" : "\n";
+          const signedTagString = tagBuffer + signedData + normalizedEnding;
+          return Tag.createFromBuffer(repo, signedTagString, force);
+        }
+        case NodeGit.Error.CODE.PASSTHROUGH:
+          return Tag.create(
+            repo,
+            tagName,
+            target,
+            tagger,
+            message,
+            force
+          );
+        default: {
+          const error = new Error(
+            `Tag.createWithSignature threw with error code ${code}`
+          );
+          error.errno = code;
+          throw error;
+        }
+      }
     });
 };
 
@@ -110,6 +130,6 @@ Tag.prototype.extractSignature = function(signatureType = "gpgsig") {
       }
     }
 
-    return null;
+    throw new Error("this tag is not signed");
   });
 };