@swimlane/nodegit 1.1.2

package/lib/deprecated/structs/BlobFilterOptions.js

@@ -0,0 +1,3 @@
+module.exports = function() {
+  this.flags = 1;
+};

package/lib/deprecated/structs/CheckoutOptions.js

@@ -0,0 +1,8 @@
+module.exports = function() {
+  this.checkoutStrategy = 1;
+  this.disableFilters = 0;
+  this.dirMode = 0;
+  this.fileMode = 0;
+  this.fileOpenFlags = 0;
+  this.notifyFlags = 0;
+};

package/lib/deprecated/structs/CherrypickOptions.js

@@ -0,0 +1,5 @@
+module.exports = function(NodeGit) {
+  this.checkoutOpts = new NodeGit.CheckoutOptions();
+  this.mainline = 0;
+  this.mergeOpts = new NodeGit.MergeOptions();
+};

package/lib/deprecated/structs/CloneOptions.js

@@ -0,0 +1,6 @@
+module.exports = function(NodeGit) {
+  this.bare = 0;
+  this.checkoutOpts = new NodeGit.CheckoutOptions();
+  this.fetchOpts = new NodeGit.FetchOptions();
+  this.local = 0;
+};

package/lib/deprecated/structs/DescribeFormatOptions.js

@@ -0,0 +1,4 @@
+module.exports = function() {
+  this.abbreviatedSize = 7;
+  this.alwaysUseLongFormat = 0;
+};

package/lib/deprecated/structs/DescribeOptions.js

@@ -0,0 +1,6 @@
+module.exports = function() {
+  this.describeStrategy = 0;
+  this.maxCandidatesTags = 10;
+  this.onlyFollowFirstParent = 0;
+  this.showCommitOidAsFallback = 0;
+};

package/lib/deprecated/structs/DiffFindOptions.js

@@ -0,0 +1,8 @@
+module.exports = function() {
+  this.breakRewriteThreshold = 0;
+  this.copyThreshold = 0;
+  this.flags = 0;
+  this.renameFromRewriteThreshold = 0;
+  this.renameLimit = 0;
+  this.renameThreshold = 0;
+};

package/lib/deprecated/structs/DiffOptions.js

@@ -0,0 +1,8 @@
+module.exports = function() {
+  this.contextLines = 3;
+  this.flags = 0;
+  this.idAbbrev = 0;
+  this.ignoreSubmodules = -1;
+  this.interhunkLines = 0;
+  this.maxSize = 0;
+};

package/lib/deprecated/structs/FetchOptions.js

@@ -0,0 +1,7 @@
+module.exports = function(NodeGit) {
+  this.callbacks = new NodeGit.RemoteCallbacks();
+  this.downloadTags = 0;
+  this.proxyOpts = new NodeGit.ProxyOptions();
+  this.prune = 0;
+  this.updateFetchhead = 1;
+};

package/lib/deprecated/structs/MergeFileInput.js

@@ -0,0 +1,4 @@
+module.exports = function() {
+  this.mode = 0;
+  this.size = 0;
+};

package/lib/deprecated/structs/MergeFileOptions.js

@@ -0,0 +1,5 @@
+module.exports = function() {
+  this.favor = 0;
+  this.flags = 0;
+  this.markerSize = 0;
+};

package/lib/deprecated/structs/MergeOptions.js

@@ -0,0 +1,8 @@
+module.exports = function() {
+  this.fileFavor = 0;
+  this.fileFlags = 0;
+  this.flags = 1;
+  this.recursionLimit = 0;
+  this.renameThreshold = 0;
+  this.targetLimit = 0;
+};

package/lib/deprecated/structs/ProxyOptions.js

@@ -0,0 +1,3 @@
+module.exports = function() {
+  this.type = 0;
+};

package/lib/deprecated/structs/PushOptions.js

@@ -0,0 +1,5 @@
+module.exports = function(NodeGit) {
+  this.callbacks = new NodeGit.RemoteCallbacks();
+  this.pbParallelism = 1;
+  this.proxyOpts = new NodeGit.ProxyOptions();
+};

package/lib/deprecated/structs/RebaseOptions.js

@@ -0,0 +1,6 @@
+module.exports = function(NodeGit) {
+  this.checkoutOptions = new NodeGit.CheckoutOptions();
+  this.inmemory = 0;
+  this.mergeOptions = new NodeGit.MergeOptions();
+  this.quiet = 0;
+};

package/lib/deprecated/structs/RemoteCreateOptions.js

@@ -0,0 +1,3 @@
+module.exports = function() {
+  this.flags = 0;
+};

package/lib/deprecated/structs/RepositoryInitOptions.js

@@ -0,0 +1,4 @@
+module.exports = function() {
+  this.flags = 0;
+  this.mode = 0;
+};

package/lib/deprecated/structs/RevertOptions.js

@@ -0,0 +1,5 @@
+module.exports = function(NodeGit) {
+  this.checkoutOpts = new NodeGit.CheckoutOptions();
+  this.mainline = 0;
+  this.mergeOpts = new NodeGit.MergeOptions();
+};

package/lib/deprecated/structs/StashApplyOptions.js

@@ -0,0 +1,4 @@
+module.exports = function(NodeGit) {
+  this.checkoutOptions = new NodeGit.CheckoutOptions();
+  this.flags = 0;
+};

package/lib/deprecated/structs/StatusOptions.js

@@ -0,0 +1,4 @@
+module.exports = function() {
+  this.flags = 0;
+  this.show = 0;
+};

package/lib/deprecated/structs/SubmoduleUpdateOptions.js

@@ -0,0 +1,5 @@
+module.exports = function(NodeGit) {
+  this.allowFetch = 1;
+  this.checkoutOpts = new NodeGit.CheckoutOptions();
+  this.fetchOpts = new NodeGit.FetchOptions();
+};

package/lib/diff.js

@@ -0,0 +1,67 @@
+var NodeGit = require("../");
+var Diff = NodeGit.Diff;
+var Patch = NodeGit.Patch;
+
+var _blobToBuffer = Diff.blobToBuffer;
+
+/**
+ * Directly run a diff between a blob and a buffer.
+ * @async
+ * @param {Blob} old_blob Blob for old side of diff, or NULL for empty blob
+ * @param {String} old_as_path Treat old blob as if it had this filename;
+ * can be NULL
+ * @param {String} buffer Raw data for new side of diff, or NULL for empty
+ * @param {String} buffer_as_path Treat buffer as if it had this filename;
+ * can be NULL
+ * @param {DiffOptions} opts Options for diff, or NULL for default options
+ * @param {Function} file_cb Callback for "file"; made once if there is a diff;
+ * can be NULL
+ * @param {Function} binary_cb Callback for binary files; can be NULL
+ * @param {Function} hunk_cb Callback for each hunk in diff; can be NULL
+ * @param {Function} line_cb Callback for each line in diff; can be NULL
+ */
+Diff.blobToBuffer= function(
+    old_blob,
+    old_as_path,
+    buffer,
+    buffer_as_path,
+    opts,
+    file_cb,
+    binary_cb,
+    hunk_cb,
+    line_cb) {
+  var bufferText;
+  var bufferLength;
+  if (buffer instanceof Buffer) {
+    bufferText = buffer.toString("utf8");
+    bufferLength = Buffer.byteLength(buffer, "utf8");
+  } else {
+    bufferText = buffer;
+    bufferLength = !buffer ? 0 : Buffer.byteLength(buffer, "utf8");
+  }
+
+  return _blobToBuffer.call(
+    this,
+    old_blob,
+    old_as_path,
+    bufferText,
+    bufferLength,
+    buffer_as_path,
+    opts,
+    file_cb,
+    binary_cb,
+    hunk_cb,
+    line_cb,
+    null);
+};
+
+/**
+ * Retrieve patches in this difflist
+ *
+ * @async
+ * @return {Array<ConvenientPatch>} a promise that resolves to an array of
+ *                                      ConvenientPatches
+ */
+Diff.prototype.patches = function(idxs) {
+  return Patch.convenientFromDiff(this, idxs);
+};

package/lib/diff_file.js

@@ -0,0 +1,38 @@
+var NodeGit = require("../");
+
+var DiffFile = NodeGit.DiffFile;
+
+var flags = DiffFile.prototype.flags;
+/**
+ * Returns the file's flags
+ * @return {Number}
+ */
+DiffFile.prototype.flags = flags;
+
+var id = DiffFile.prototype.id;
+/**
+ * Returns the file's Oid
+ * @return {Oid}
+ */
+DiffFile.prototype.id = id;
+
+var mode = DiffFile.prototype.mode;
+/**
+ * Returns the file's mode
+ * @return {Number}
+ */
+DiffFile.prototype.mode = mode;
+
+var path = DiffFile.prototype.path;
+/**
+ * Returns the file's path
+ * @return {String}
+ */
+DiffFile.prototype.path = path;
+
+var size = DiffFile.prototype.size;
+/**
+ * Returns the file's size
+ * @return {Number}
+ */
+DiffFile.prototype.size = size;

package/lib/diff_line.js

@@ -0,0 +1,32 @@
+var NodeGit = require("../");
+var DiffLine = NodeGit.DiffLine;
+
+var _rawContent = DiffLine.prototype.content;
+
+/**
+* The relevant line
+* @return {String}
+*/
+DiffLine.prototype.content = function() {
+  if (!this._cache) {
+    this._cache = {};
+  }
+
+  if (!this._cache.content) {
+    this._cache.content = Buffer.from(this.rawContent())
+      .slice(0, this.contentLen())
+      .toString("utf8");
+  }
+
+  return this._cache.content;
+};
+
+/**
+* The non utf8 translated text
+* @return {String}
+*/
+DiffLine.prototype.rawContent = function() {
+  return _rawContent.call(this);
+};
+
+NodeGit.DiffLine = DiffLine;

package/lib/error.js

@@ -0,0 +1,17 @@
+var util = require("util");
+var NodeGit = require("../");
+
+// Deprecated -----------------------------------------------------------------
+
+// In 0.28.0 git_error was majorly refactored to have better naming in libgit2
+// We will continue to support the old enum entries but with a deprecation
+// warning as they will go away soon.
+Object.keys(NodeGit.Error.CODE).forEach((key) => {
+  Object.defineProperty(NodeGit.Error.CODE, `GITERR_${key}`, {
+    get: util.deprecate(
+      () => NodeGit.Error.CODE[key],
+      `Use NodeGit.Error.CODE.${key} instead of ` +
+      `NodeGit.Error.CODE.GETERR_${key}.`
+    )
+  });
+});

package/lib/filter_registry.js

@@ -0,0 +1,22 @@
+var NodeGit = require("../");
+
+var FilterRegistry = NodeGit.FilterRegistry;
+
+var _register = FilterRegistry.register;
+
+// register should add filter by name to dict and return
+// Override FilterRegistry.register to normalize Filter
+FilterRegistry.register = function(name, filter, priority) {
+  // setting default value of attributes
+  if (filter.attributes === undefined) {
+    filter.attributes = "";
+  }
+
+  if (!filter.check || !filter.apply) {
+    return Promise.reject(new Error(
+      "ERROR: please provide check and apply callbacks for filter"
+    ));
+  }
+
+  return _register(name, filter, priority);
+};

package/lib/graph.js

@@ -0,0 +1,15 @@
+var NodeGit = require("../");
+
+var Graph = NodeGit.Graph;
+
+var _reachableFromAny = Graph.reachableFromAny;
+
+/**
+ * Determine if a commit is reachable from any of a list of commits by following parent edges.
+ * @param {repository} the repository where the commits exist
+ * @param {commit} a previously loaded commit
+ * @param {descendant_array} oids of the commits
+ */
+Graph.reachableFromAny = function(repository, commit, descendant_array) {
+  return _reachableFromAny(repository, commit, descendant_array, descendant_array.length);
+};

package/lib/index.js

@@ -0,0 +1,103 @@
+var util = require("util");
+var NodeGit = require("../");
+
+var Index = NodeGit.Index;
+
+var _addAll = Index.prototype.addAll;
+var _removeAll = Index.prototype.removeAll;
+var _updateAll = Index.prototype.updateAll;
+
+Index.prototype.addAll = function(pathspec, flags, matchedCallback) {
+  return _addAll.call(this, pathspec || "*", flags, matchedCallback, null);
+};
+
+/**
+ * Return an array of the entries in this index.
+ * @return {Array<IndexEntry>} an array of IndexEntrys
+ */
+Index.prototype.entries = function() {
+  var size = this.entryCount();
+  var result = [];
+
+  for (var i = 0; i < size; i++) {
+    result.push(this.getByIndex(i));
+  }
+
+  return result;
+};
+
+Index.prototype.removeAll = function(pathspec, matchedCallback) {
+  return _removeAll.call(this, pathspec || "*", matchedCallback, null);
+};
+
+Index.prototype.updateAll = function(pathspec, matchedCallback) {
+  return _updateAll.call(this, pathspec || "*", matchedCallback, null);
+};
+
+// Deprecated -----------------------------------------------------------------
+
+NodeGit.Index.CAP = {};
+Object.keys(NodeGit.Index.CAPABILITY).forEach((key) => {
+  Object.defineProperty(NodeGit.Index.CAP, key, {
+    get: util.deprecate(
+      () => NodeGit.Index.CAPABILITY[key],
+      `Use NodeGit.Index.CAPABILITY.${key} instead of ` +
+      `NodeGit.Index.CAP.${key}.`
+    )
+  });
+});
+
+NodeGit.Enums.INDXENTRY_FLAG = {};
+Object.defineProperty(NodeGit.Enums.INDXENTRY_FLAG, "IDXENTRY_EXTENDED", {
+  get: util.deprecate(
+    () => NodeGit.Index.ENTRY_FLAG.ENTRY_EXTENDED,
+    "Use NodeGit.Index.ENTRY_FLAG.ENTRY_EXTENDED instead of " +
+    "NodeGit.Enums.INDXENTRY_FLAG.IDXENTRY_EXTENDED."
+  )
+});
+Object.defineProperty(NodeGit.Enums.INDXENTRY_FLAG, "IDXENTRY_VALID", {
+  get: util.deprecate(
+    () => NodeGit.Index.ENTRY_FLAG.ENTRY_VALID,
+    "Use NodeGit.Index.ENTRY_FLAG.ENTRY_VALID instead of " +
+    "NodeGit.Enums.INDXENTRY_FLAG.IDXENTRY_VALID."
+  )
+});
+
+NodeGit.Enums.IDXENTRY_EXTENDED_FLAG = {};
+var EXTENDED_FLAGS_MAP = {
+  IDXENTRY_INTENT_TO_ADD: "ENTRY_INTENT_TO_ADD",
+  IDXENTRY_SKIP_WORKTREE: "ENTRY_SKIP_WORKTREE",
+  S: "S",
+  IDXENTRY_UPTODATE: "ENTRY_UPTODATE"
+};
+Object.keys(EXTENDED_FLAGS_MAP).forEach((key) => {
+  const newKey = EXTENDED_FLAGS_MAP[key];
+  Object.defineProperty(NodeGit.Enums.IDXENTRY_EXTENDED_FLAG, key, {
+    get: util.deprecate(
+      () => NodeGit.Index.ENTRY_EXTENDED_FLAG[newKey],
+      `Use NodeGit.Index.ENTRY_EXTENDED_FLAG.${newKey} instead of ` +
+      `NodeGit.Enums.IDXENTRY_EXTENDED_FLAG.${key}.`
+    )
+  });
+});
+
+var DEPRECATED_EXTENDED_FLAGS = {
+  IDXENTRY_EXTENDED2: 32768,
+  IDXENTRY_UPDATE: 1,
+  IDXENTRY_REMOVE: 2,
+  IDXENTRY_ADDED: 8,
+  IDXENTRY_HASHED: 16,
+  IDXENTRY_UNHASHED: 32,
+  IDXENTRY_WT_REMOVE: 64,
+  IDXENTRY_CONFLICTED: 128,
+  IDXENTRY_UNPACKED: 256,
+  IDXENTRY_NEW_SKIP_WORKTREE: 512,
+};
+Object.keys(DEPRECATED_EXTENDED_FLAGS).forEach((key) => {
+  Object.defineProperty(NodeGit.Enums.IDXENTRY_EXTENDED_FLAG, key, {
+    get: util.deprecate(
+      () => DEPRECATED_EXTENDED_FLAGS[key],
+      "LibGit2 has removed this flag for public usage."
+    )
+  });
+});

package/lib/merge.js

@@ -0,0 +1,41 @@
+var NodeGit = require("../");
+
+var Merge = NodeGit.Merge;
+var _commits = Merge.commits;
+var _merge = Merge.merge;
+
+/**
+ * Merge 2 commits together and create an new index that can
+ * be used to create a merge commit.
+ *
+ * @param {Repository} repo Repository that contains the given commits
+ * @param {Commit} ourCommit The commit that reflects the destination tree
+ * @param {Commit} theirCommit The commit to merge into ourCommit
+ * @param {MergeOptions} [options] The merge tree options (null for default)
+ */
+Merge.commits = function(repo, ourCommit, theirCommit, options) {
+  return Promise.all([
+    repo.getCommit(ourCommit),
+    repo.getCommit(theirCommit)
+  ]).then(function(commits) {
+    return _commits.call(this, repo, commits[0], commits[1], options);
+  });
+};
+
+/**
+ * Merge a commit into HEAD and writes the results to the working directory.
+ *
+ * @param {Repository} repo Repository that contains the given commits
+ * @param {AnnotatedCommit} theirHead The annotated commit to merge into HEAD
+ * @param {MergeOptions} [mergeOpts] The merge tree options (null for default)
+ * @param {CheckoutOptions} [checkoutOpts] The checkout options
+ *                                         (null for default)
+ */
+Merge.merge = function(repo, theirHead, mergeOpts, checkoutOpts) {
+  // Even though git_merge takes an array of annotated_commits, it expects
+  // exactly one to have been passed in or it will throw an error...  ¯\_(ツ)_/¯
+  var theirHeads = [theirHead];
+
+  return _merge.call(this, repo, theirHeads, theirHeads.length,
+    mergeOpts, checkoutOpts);
+};

package/lib/note.js

@@ -0,0 +1,17 @@
+var NodeGit = require("../");
+
+var Note = NodeGit.Note;
+
+var _foreach = Note.foreach;
+
+// Override Note.foreach to eliminate the need to pass null payload
+Note.foreach = function(repo, notesRef, callback) {
+  function wrapperCallback(blobId, objectId) {
+    // We need to copy the OID since libgit2 types are getting cleaned up
+    // incorrectly right now in callbacks
+
+    return callback(blobId.copy(), objectId.copy());
+  }
+
+  return _foreach(repo, notesRef, wrapperCallback, null);
+};

package/lib/object.js

@@ -0,0 +1,45 @@
+var util = require("util");
+var NodeGit = require("../");
+
+var Obj = NodeGit.Object;
+
+/**
+ * Is this object a blob?
+ * @return {Boolean}
+ */
+Obj.prototype.isBlob = function() {
+  return this.type() == Obj.TYPE.BLOB;
+};
+
+/**
+ * Is this object a commit?
+ * @return {Boolean}
+ */
+Obj.prototype.isCommit = function() {
+  return this.type() == Obj.TYPE.COMMIT;
+};
+
+/**
+ * Is this object a tag?
+ * @return {Boolean}
+ */
+Obj.prototype.isTag = function() {
+  return this.type() == Obj.TYPE.TAG;
+};
+
+/**
+ * Is this object a tree?
+ * @return {Boolean}
+ */
+Obj.prototype.isTree = function() {
+  return this.type() == Obj.TYPE.TREE;
+};
+
+// Deprecated -----------------------------------------------------------------
+
+Object.defineProperty(Obj.TYPE, "BAD", {
+  get: util.deprecate(
+    () => Obj.TYPE.INVALID,
+    "Use NodeGit.Object.TYPE.INVALID instead of NodeGit.Object.TYPE.BAD."
+  )
+});

package/lib/odb_object.js

@@ -0,0 +1,9 @@
+var NodeGit = require("../");
+
+var OdbObject = NodeGit.OdbObject;
+
+OdbObject.prototype.toString = function(size) {
+  size = size || this.size();
+
+  return this.data().toBuffer(size).toString();
+};

package/lib/oid.js

@@ -0,0 +1,23 @@
+var NodeGit = require("../");
+
+var Oid = NodeGit.Oid;
+
+// Backwards compatibility.
+Object.defineProperties(Oid.prototype, {
+  "allocfmt": {
+    value: Oid.prototype.tostrS,
+    enumerable: false
+  },
+  "toString": {
+    value: Oid.prototype.tostrS,
+    enumerable: false
+  }
+});
+
+Oid.prototype.copy = function() {
+  return this.cpy(); // seriously???
+};
+
+Oid.prototype.inspect = function() {
+  return "[Oid " + this.allocfmt() + "]";
+};

package/lib/rebase.js

@@ -0,0 +1,86 @@
+var NodeGit = require("../");
+var Rebase = NodeGit.Rebase;
+
+var _init = Rebase.init;
+var _open = Rebase.open;
+
+function defaultRebaseOptions(repository, options, checkoutStrategy) {
+  if (options) {
+     // Ensure we don't modify the passed-in options object.
+     // This could lead to us recursing commitCreateCb if the same
+     // options object is later re-used.
+    options = Object.assign({}, options);
+
+    if (options.signingCb && !options.commitCreateCb) {
+      console.warn("signingCb is deperecated, use commitCreateCb instead.");
+
+      let signingCb = options.signingCb;
+      options.commitCreateCb = function (
+        author,
+        committer,
+        message_encoding,
+        message,
+        tree,
+        parent_count,
+        parents
+      ) {
+        return repository.createCommitWithSignature(
+          null,
+          author,
+          committer,
+          message,
+          tree,
+          parents,
+          signingCb).then((oid) => {
+            return oid;
+          });
+      };
+    }
+  } else if (checkoutStrategy) {
+    options = {
+      checkoutOptions: {
+        checkoutStrategy: checkoutStrategy
+      }
+    };
+  }
+
+  return options;
+}
+
+/**
+ * Initializes a rebase
+ * @async
+ * @param {Repository} repo The repository to perform the rebase
+ * @param {AnnotatedCommit} branch The terminal commit to rebase, or NULL to
+ *                                 rebase the current branch
+ * @param {AnnotatedCommit} upstream The commit to begin rebasing from, or NULL
+ *                                   to rebase all reachable commits
+ * @param {AnnotatedCommit} onto The branch to rebase onto, or NULL to rebase
+ *                               onto the given upstream
+ * @param {RebaseOptions} options Options to specify how rebase is performed,
+ *                                or NULL
+ * @return {Remote}
+ */
+Rebase.init = function(repository, branch, upstream, onto, options) {
+  return _init(repository, branch, upstream, onto, defaultRebaseOptions(
+    repository,
+    options,
+    NodeGit.Checkout.STRATEGY.FORCE
+  ));
+};
+
+/**
+ * Opens an existing rebase that was previously started by either an invocation
+ * of Rebase.open or by another client.
+ * @async
+ * @param {Repository} repo The repository that has a rebase in-progress
+ * @param {RebaseOptions} options Options to specify how rebase is performed
+ * @return {Remote}
+ */
+Rebase.open = function(repository, options) {
+  return _open(repository, defaultRebaseOptions(
+    repository,
+    options,
+    NodeGit.Checkout.STRATEGY.SAFE
+  ));
+};