@swimlane/nodegit 1.1.2

package/lib/reset.js

@@ -0,0 +1,51 @@
+var NodeGit = require("../");
+
+var Reset = NodeGit.Reset;
+var _default = Reset.default;
+var _reset = Reset.reset;
+
+/**
+ * Look up a refs's commit.
+ *
+ * @async
+ * @param {Repository} repo Repository where to perform the reset operation.
+ * @param {Commit|Tag} target The committish which content will be used to reset
+ *                        the content of the index.
+ * @param {Strarray} pathspecs List of pathspecs to operate on.
+ *
+ * @return {Number} 0 on success or an error code
+ */
+Reset.default = function(repo, target, pathspecs) {
+  return _default.call(this, repo, target, pathspecs);
+};
+
+/**
+ * Reset a repository's current HEAD to the specified target.
+ *
+ * @async
+ * @param {Repository} repo Repository where to perform the reset operation.
+ *
+ * @param {Commit|Tag} target Committish to which the Head should be moved to.
+ *                        This object must belong to the given `repo` and can
+ *                        either be a git_commit or a git_tag. When a git_tag is
+ *                        being passed, it should be dereferencable to a
+ *                        git_commit which oid will be used as the target of the
+ *                        branch.
+ * @param {Number} resetType Kind of reset operation to perform.
+ *
+ * @param {CheckoutOptions} opts Checkout options to be used for a HARD reset.
+ *                               The checkout_strategy field will be overridden
+ *                               (based on reset_type). This parameter can be
+ *                               used to propagate notify and progress
+ *                               callbacks.
+ *
+ * @return {Number} 0 on success or an error code
+ */
+Reset.reset = function(repo, target, resetType, opts) {
+  if (repo !== target.repo) {
+    // this is the same that is performed on libgit2's side
+    // https://github.com/nodegit/libgit2/blob/8d89e409616831b7b30a5ca7b89354957137b65e/src/reset.c#L120-L124
+    throw new Error("Repository and target commit's repository does not match");
+  }
+  return _reset.call(this, repo, target, resetType, opts);
+};

package/lib/revparse.js

@@ -0,0 +1,18 @@
+var util = require("util");
+var NodeGit = require("../");
+
+const MODE = {
+  SINGLE: 1,
+  RANGE: 2,
+  MERGE_BASE: 4,
+};
+
+NodeGit.Revparse.MODE = {};
+Object.keys(MODE).forEach((key) => {
+  Object.defineProperty(NodeGit.Revparse.MODE, key, {
+    get: util.deprecate(
+      () => MODE[key],
+      `Use NodeGit.Revspec.TYPE.${key} instead of NodeGit.Revparse.MODE.${key}.`
+    )
+  });
+});

package/lib/revwalk.js

@@ -0,0 +1,142 @@
+var NodeGit = require("../");
+var Revwalk = NodeGit.Revwalk;
+
+Object.defineProperty(Revwalk.prototype, "repo", {
+  get: function () { return this.repository(); },
+  configurable: true
+});
+
+var _sorting = Revwalk.prototype.sorting;
+/**
+ * @typedef historyEntry
+ * @type {Object}
+ * @property {Commit} commit the commit for this entry
+ * @property {Number} status the status of the file in the commit
+ * @property {String} newName the new name that is provided when status is
+ *                            renamed
+ * @property {String} oldName the old name that is provided when status is
+ *                            renamed
+ */
+var fileHistoryWalk = Revwalk.prototype.fileHistoryWalk;
+/**
+ * @param {String} filePath
+ * @param {Number} max_count
+ * @async
+ * @return {Array<historyEntry>}
+ */
+Revwalk.prototype.fileHistoryWalk = fileHistoryWalk;
+
+/**
+ * Get a number of commits.
+ *
+ * @async
+ * @param  {Number} count (default: 10)
+ * @return {Array<Commit>}
+ */
+Revwalk.prototype.getCommits = function(count) {
+  count = count || 10;
+  var promises = [];
+  var walker = this;
+
+  function walkCommitsCount(count) {
+    if (count === 0) { return; }
+
+    return walker.next().then(function(oid) {
+      promises.push(walker.repo.getCommit(oid));
+      return walkCommitsCount(count - 1);
+    })
+    .catch(function(error) {
+      if (error.errno !== NodeGit.Error.CODE.ITEROVER) {
+        throw error;
+      }
+    });
+  }
+
+  return walkCommitsCount(count).then(function() {
+    return Promise.all(promises);
+  });
+};
+
+/**
+ * Walk the history grabbing commits until the checkFn called with the
+ * current commit returns false.
+ *
+ * @async
+ * @param  {Function} checkFn function returns false to stop walking
+ * @return {Array}
+ */
+Revwalk.prototype.getCommitsUntil = function(checkFn) {
+  var commits = [];
+  var walker = this;
+
+  function walkCommitsCb() {
+    return walker.next().then(function(oid) {
+      return walker.repo.getCommit(oid).then(function(commit) {
+        commits.push(commit);
+        if (checkFn(commit)) {
+          return walkCommitsCb();
+        }
+      });
+    })
+    .catch(function(error) {
+      if (error.errno !== NodeGit.Error.CODE.ITEROVER) {
+        throw error;
+      }
+    });
+  }
+
+  return walkCommitsCb().then(function() {
+    return commits;
+  });
+};
+
+/**
+ * Set the sort order for the revwalk. This function takes variable arguments
+ * like `revwalk.sorting(NodeGit.RevWalk.Topological, NodeGit.RevWalk.Reverse).`
+ *
+ * @param {Number} sort
+ */
+Revwalk.prototype.sorting = function() {
+  var sort = 0;
+
+  for (var i = 0; i < arguments.length; i++) {
+    sort |= arguments[i];
+  }
+
+  _sorting.call(this, sort);
+};
+
+/**
+ * Walk the history from the given oid. The callback is invoked for each commit;
+ * When the walk is over, the callback is invoked with `(null, null)`.
+ *
+ * @param  {Oid} oid
+ * @param  {Function} callback
+ */
+Revwalk.prototype.walk = function(oid, callback) {
+  var revwalk = this;
+
+  this.push(oid);
+
+  function walk() {
+    revwalk.next().then(function(oid) {
+      if (!oid) {
+        if (typeof callback === "function") {
+          return callback();
+        }
+
+        return;
+      }
+
+      revwalk.repo.getCommit(oid).then(function(commit) {
+        if (typeof callback === "function") {
+          callback(null, commit);
+        }
+
+        walk();
+      });
+    }, callback);
+  }
+
+  walk();
+};

package/lib/signature.js

@@ -0,0 +1,38 @@
+var NodeGit = require("../");
+var Signature = NodeGit.Signature;
+
+const toPaddedDoubleDigitString = (number) => {
+  if (number < 10) {
+    return `0${number}`;
+  }
+
+  return `${number}`;
+};
+
+/**
+ * Standard string representation of an author.
+ * @param {Boolean} withTime Whether or not to include timestamp
+ * @return {String} Representation of the author.
+ */
+Signature.prototype.toString = function(withTime) {
+  const name = this.name().toString();
+  const email = this.email().toString();
+
+  let stringifiedSignature = `${name} <${email}>`;
+
+  if (!withTime) {
+    return stringifiedSignature;
+  }
+
+  const when = this.when();
+  const offset = when.offset();
+  const offsetMagnitude = Math.abs(offset);
+  const time = when.time();
+
+  const sign = (offset < 0 || when.sign() === "-") ? "-" : "+";
+  const hours = toPaddedDoubleDigitString(Math.floor(offsetMagnitude / 60));
+  const minutes = toPaddedDoubleDigitString(offsetMagnitude % 60);
+
+  stringifiedSignature += ` ${time} ${sign}${hours}${minutes}`;
+  return stringifiedSignature;
+};

package/lib/stash.js

@@ -0,0 +1,16 @@
+var NodeGit = require("../");
+var Stash = NodeGit.Stash;
+
+var _foreach = Stash.foreach;
+
+// Override Stash.foreach to eliminate the need to pass null payload
+Stash.foreach = function(repo, callback) {
+  function wrappedCallback(index, message, oid) {
+    // We need to copy the OID since libgit2 types are getting cleaned up
+    // incorrectly right now in callbacks
+
+    return callback(index, message, oid.copy());
+  }
+
+  return _foreach(repo, wrappedCallback, null);
+};

package/lib/status.js

@@ -0,0 +1,16 @@
+var NodeGit = require("../");
+
+var Status = NodeGit.Status;
+
+var _foreach = Status.foreach;
+var _foreachExt = Status.foreachExt;
+
+// Override Status.foreach to eliminate the need to pass null payload
+Status.foreach = function(repo, callback) {
+  return _foreach(repo, callback, null);
+};
+
+// Override Status.foreachExt to eliminate the need to pass null payload
+Status.foreachExt = function(repo, opts, callback) {
+  return _foreachExt(repo, opts, callback, null);
+};

package/lib/status_file.js

@@ -0,0 +1,106 @@
+var NodeGit = require("../");
+var Status = NodeGit.Status;
+
+var StatusFile = function(args) {
+  var path = args.path;
+  var status = args.status;
+  var entry = args.entry;
+
+  if (entry) {
+    status = entry.status();
+    if (entry.indexToWorkdir()) {
+      path = entry.indexToWorkdir().newFile().path();
+    } else {
+      path = entry.headToIndex().newFile().path();
+    }
+  }
+
+  var codes = Status.STATUS;
+
+  var getStatus = function() {
+    var fileStatuses = [];
+
+    for(var key in Status.STATUS) {
+      if (status & Status.STATUS[key]) {
+        fileStatuses.push(key);
+      }
+    }
+
+    return fileStatuses;
+  };
+
+  var data = {
+    path: path,
+    entry: entry,
+    statusBit: status,
+    statuses: getStatus()
+  };
+
+  return {
+    headToIndex: function() {
+      if (data.entry) {
+        return entry.headToIndex();
+      } else {
+        return undefined;
+      }
+    },
+    indexToWorkdir: function() {
+      if (data.entry) {
+        return entry.indexToWorkdir();
+      } else {
+        return undefined;
+      }
+    },
+    inIndex: function() {
+      return status & codes.INDEX_NEW ||
+             status & codes.INDEX_MODIFIED ||
+             status & codes.INDEX_DELETED ||
+             status & codes.INDEX_TYPECHANGE ||
+             status & codes.INDEX_RENAMED;
+    },
+    inWorkingTree: function() {
+      return status & codes.WT_NEW ||
+             status & codes.WT_MODIFIED ||
+             status & codes.WT_DELETED ||
+             status & codes.WT_TYPECHANGE ||
+             status & codes.WT_RENAMED;
+    },
+    isConflicted: function() {
+      return status & codes.CONFLICTED;
+    },
+    isDeleted: function() {
+      return status & codes.WT_DELETED ||
+             status & codes.INDEX_DELETED;
+    },
+    isIgnored: function() {
+      return status & codes.IGNORED;
+    },
+    isModified: function() {
+      return status & codes.WT_MODIFIED ||
+             status & codes.INDEX_MODIFIED;
+    },
+    isNew: function() {
+      return status & codes.WT_NEW ||
+             status & codes.INDEX_NEW;
+    },
+    isRenamed: function() {
+      return status & codes.WT_RENAMED ||
+             status & codes.INDEX_RENAMED;
+    },
+    isTypechange: function() {
+      return status & codes.WT_TYPECHANGE ||
+             status & codes.INDEX_TYPECHANGE;
+    },
+    path: function() {
+      return data.path;
+    },
+    status: function() {
+      return data.statuses;
+    },
+    statusBit: function() {
+      return data.statusBit;
+    }
+  };
+};
+
+NodeGit.StatusFile = StatusFile;

package/lib/submodule.js

@@ -0,0 +1,10 @@
+var NodeGit = require("../");
+
+var Submodule = NodeGit.Submodule;
+
+var _foreach = Submodule.foreach;
+
+// Override Submodule.foreach to eliminate the need to pass null payload
+Submodule.foreach = function(repo, callback) {
+  return _foreach(repo, callback, null);
+};

package/lib/tag.js

@@ -0,0 +1,141 @@
+var util = require("util");
+var NodeGit = require("../");
+var LookupWrapper = NodeGit.Utils.lookupWrapper;
+var Tag = NodeGit.Tag;
+
+const signatureRegexesBySignatureType = {
+  gpgsig: [
+    /-----BEGIN PGP SIGNATURE-----[\s\S]+?-----END PGP SIGNATURE-----/gm,
+    /-----BEGIN PGP MESSAGE-----[\s\S]+?-----END PGP MESSAGE-----/gm,
+  ],
+  x509: [
+    /-----BEGIN SIGNED MESSAGE-----[\s\S]+?-----END SIGNED MESSAGE-----/gm,
+  ]
+};
+
+/**
+ * Retrieves the tag pointed to by the oid
+ * @async
+ * @param {Repository} repo The repo that the tag lives in
+ * @param {String|Oid|Tag} id The tag to lookup
+ * @return {Tag}
+ */
+Tag.lookup = LookupWrapper(Tag);
+
+/**
+ * @async
+ * @param {Repository} repo
+ * @param {String} tagName
+ * @param {Oid} target
+ * @param {Signature} tagger
+ * @return {String}
+ */
+Tag.createBuffer = function(repo, tagName, target, tagger, message) {
+  return NodeGit.Object.lookup(repo, target, NodeGit.Object.TYPE.ANY)
+    .then((object) => {
+      if (!NodeGit.Object.typeisloose(object.type())) {
+        throw new Error("Object must be a loose type");
+      }
+
+      const id = object.id().toString();
+      const objectType = NodeGit.Object.type2String(object.type());
+      const lines = [
+        `object ${id}`,
+        `type ${objectType}`,
+        `tag ${tagName}`,
+        `tagger ${tagger.toString(true)}\n`,
+        `${message}${message.endsWith("\n") ? "" : "\n"}`
+      ];
+      return lines.join("\n");
+    });
+};
+
+const deprecatedCreateWithSignatureHelper = util.deprecate(function(repo, oidTarget) {
+  return repo.getCommit(oidTarget);
+}, "Tag.createWithSignature target should be a Git Object, not Oid");
+
+/**
+ * @async
+ * @param {Repository} repo
+ * @param {String} tagName
+ * @param {Object} target
+ * @param {Signature} tagger
+ * @param {String} message
+ * @param {Number} force
+ * @param {Function} signingCallback Takes a string and returns a string
+ *                                   representing the signed message
+ * @return {Oid}
+ */
+Tag.createWithSignature = async (
+  repo,
+  tagName,
+  target,
+  tagger,
+  message,
+  force,
+  signingCallback
+) => {
+  let targetOid;
+  if (!target.id) {
+    targetOid = await deprecatedCreateWithSignatureHelper(repo, target);
+  } else {
+    targetOid = target;
+  }
+
+  const tagBuffer = await Tag.createBuffer(repo, tagName, targetOid.id(), tagger, message);
+  const { code, signedData } = await signingCallback(tagBuffer);
+  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,
+        targetOid,
+        tagger,
+        message,
+        force
+      );
+    default: {
+      const error = new Error(
+        `Tag.createWithSignature threw with error code ${code}`
+      );
+      error.errno = code;
+      throw error;
+    }
+  }
+};
+
+/**
+ * Retrieves the signature of an annotated tag
+ * @async
+ * @param {String} signatureType
+ * @return {String|null}
+ */
+Tag.prototype.extractSignature = function(signatureType = "gpgsig") {
+  const id = this.id();
+  const repo = this.repo;
+  const signatureRegexes = signatureRegexesBySignatureType[signatureType];
+  if (!signatureRegexes) {
+    throw new Error("Unsupported signature type");
+  }
+
+  return repo.odb().then((odb) => {
+    return odb.read(id);
+  }).then((odbObject) => {
+    const odbData = odbObject.toString();
+
+    for (const regex of signatureRegexes) {
+      const matchResult = odbData.match(regex);
+
+      if (matchResult !== null) {
+        return matchResult[0];
+      }
+    }
+
+    throw new Error("this tag is not signed");
+  });
+};