pj-nodegit 0.18.4 → 0.18.5

package/lib/reset.js

@@ -0,0 +1,76 @@
+var NodeGit = require("../");
+var normalizeOptions = NodeGit.Utils.normalizeOptions;
+
+var Reset = NodeGit.Reset;
+var _default = Reset.default;
+var _reset = Reset.reset;
+var _fromAnnotated = Reset.fromAnnotated;
+
+/**
+ * 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) {
+  opts = normalizeOptions(opts, NodeGit.CheckoutOptions);
+  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);
+};
+
+/**
+ * Sets the current head to the specified commit oid and optionally
+ * resets the index and working tree to match.
+ * 
+ * This behaves like reset but takes an annotated commit, which lets
+ * you specify which extended sha syntax string was specified by a
+ * user, allowing for more exact reflog messages.
+ * 
+ * See the documentation for reset.
+ * 
+ * @async
+ * @param {Repository} repo
+ * @param {AnnotatedCommit} target
+ * @param {Number} resetType
+ * @param {CheckoutOptions} opts
+ */
+Reset.fromAnnotated = function(repo, target, resetType, opts) {
+  opts = normalizeOptions(opts, NodeGit.CheckoutOptions);
+
+  return _fromAnnotated.call(this, repo, target, resetType, opts);
+};

package/lib/revert.js

@@ -0,0 +1,77 @@
+var NodeGit = require("../");
+var shallowClone = NodeGit.Utils.shallowClone;
+var normalizeOptions = NodeGit.Utils.normalizeOptions;
+
+var Revert = NodeGit.Revert;
+var _commit = Revert.commit;
+var _revert = Revert.revert;
+
+/**
+ * Reverts the given commit against the given "our" commit, producing an index
+ * that reflects the result of the revert.
+ *
+ * @async
+ * @param {Repository} repo the repository that contains the given commits.
+ * @param {Commit} revert_commit the commit to revert
+ * @param {Commit} our_commit the commit to revert against (e.g. HEAD)
+ * @param {Number} mainline the parent of the revert commit, if it is a merge
+ * @param {MergeOptions} merge_options the merge options (or null for defaults)
+ *
+ * @return {Index} the index result
+ */
+Revert.commit = function(
+  repo,
+  revert_commit,
+  our_commit,
+  mainline,
+  merge_options
+)
+{
+  merge_options = normalizeOptions(merge_options, NodeGit.MergeOptions);
+
+  return _commit.call(
+    this,
+    repo,
+    revert_commit,
+    our_commit,
+    mainline,
+    merge_options
+  );
+};
+
+/**
+ * Reverts the given commit, producing changes in the index and
+ * working directory.
+ *
+ * @async
+ * @param {Repository} repo the repository to perform the revert in
+ * @param {Commit} commit the commit to revert
+ * @param {RevertOptions} revert_options the revert options
+ *                                       (or null for defaults)
+ */
+Revert.revert = function(repo, commit, revertOpts) {
+  var mergeOpts;
+  var checkoutOpts;
+
+  if (revertOpts) {
+    revertOpts = shallowClone(revertOpts);
+    mergeOpts = revertOpts.mergeOpts;
+    checkoutOpts = revertOpts.checkoutOpts;
+    delete revertOpts.mergeOpts;
+    delete revertOpts.checkoutOpts;
+  }
+
+  revertOpts = normalizeOptions(revertOpts, NodeGit.RevertOptions);
+
+  if (mergeOpts) {
+    revertOpts.mergeOpts =
+      normalizeOptions(mergeOpts, NodeGit.MergeOptions);
+  }
+
+  if (checkoutOpts) {
+    revertOpts.checkoutOpts =
+      normalizeOptions(checkoutOpts, NodeGit.CheckoutOptions);
+  }
+
+  return _revert.call(this, repo, commit, revertOpts);
+};

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,62 @@
+var NodeGit = require("../");
+var normalizeOptions = NodeGit.Utils.normalizeOptions;
+var shallowClone = NodeGit.Utils.shallowClone;
+var Stash = NodeGit.Stash;
+
+var _apply = Stash.apply;
+var _foreach = Stash.foreach;
+var _pop = Stash.pop;
+
+Stash.apply = function(repo, index, options) {
+  var checkoutOptions;
+
+  if (options) {
+    options = shallowClone(options);
+    checkoutOptions = options.checkoutOptions;
+    delete options.checkoutOptions;
+  } else {
+    options = {};
+  }
+
+  options = normalizeOptions(options, NodeGit.StashApplyOptions);
+
+  if (checkoutOptions) {
+    options.checkoutOptions =
+      normalizeOptions(checkoutOptions, NodeGit.CheckoutOptions);
+  }
+
+  return _apply(repo, index, options);
+};
+
+// 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);
+};
+
+Stash.pop = function(repo, index, options) {
+  var checkoutOptions;
+
+  if (options) {
+    options = shallowClone(options);
+    checkoutOptions = options.checkoutOptions;
+    delete options.checkoutOptions;
+  } else {
+    options = {};
+  }
+
+  options = normalizeOptions(options, NodeGit.StashApplyOptions);
+
+  if (checkoutOptions) {
+    options.checkoutOptions =
+      normalizeOptions(checkoutOptions, NodeGit.CheckoutOptions);
+  }
+
+  return _pop(repo, index, options);
+};

package/lib/status.js

@@ -0,0 +1,18 @@
+var NodeGit = require("../");
+var normalizeOptions = NodeGit.Utils.normalizeOptions;
+
+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 normalize opts
+Status.foreachExt = function(repo, opts, callback) {
+  opts = normalizeOptions(opts, NodeGit.StatusOptions);
+  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/status_list.js

@@ -0,0 +1,12 @@
+var NodeGit = require("../");
+var normalizeOptions = NodeGit.Utils.normalizeOptions;
+
+var StatusList = NodeGit.StatusList;
+
+var _create = StatusList.create;
+
+// Override StatusList.create to normalize opts
+StatusList.create = function(repo, opts) {
+  opts = normalizeOptions(opts, NodeGit.StatusOptions);
+  return _create(repo, opts);
+};

package/lib/submodule.js

@@ -0,0 +1,51 @@
+var NodeGit = require("../");
+var normalizeFetchOptions = NodeGit.Utils.normalizeFetchOptions;
+var normalizeOptions = NodeGit.Utils.normalizeOptions;
+var shallowClone = NodeGit.Utils.shallowClone;
+
+var Submodule = NodeGit.Submodule;
+
+var _foreach = Submodule.foreach;
+var _update = Submodule.prototype.update;
+
+// Override Submodule.foreach to eliminate the need to pass null payload
+Submodule.foreach = function(repo, callback) {
+  return _foreach(repo, callback, null);
+};
+
+/**
+ * Updates a submodule
+ *
+ * @async
+ * @param {Number} init Setting this to 1 will initialize submodule
+ *                      before updating
+ * @param {SubmoduleUpdateOptions} options Submodule update settings
+ * @return {Number} 0 on success, any non-zero return value from a callback
+ */
+Submodule.prototype.update = function(init, options) {
+  var fetchOpts;
+  var checkoutOpts;
+
+  if (options) {
+    options = shallowClone(options);
+    fetchOpts = options.fetchOpts;
+    checkoutOpts = options.checkoutOpts;
+    delete options.fetchOpts;
+    delete options.checkoutOpts;
+  }
+  
+  options = normalizeOptions(options, NodeGit.SubmoduleUpdateOptions);
+
+  if (fetchOpts) {
+    options.fetchOpts = normalizeFetchOptions(fetchOpts);
+  }
+
+  if (checkoutOpts) {
+    options.checkoutOpts = normalizeOptions(
+      checkoutOpts,
+      NodeGit.CheckoutOptions
+    );
+  }
+
+  return _update.call(this, init, options);
+};