pj-nodegit 0.18.4 → 0.18.5

package/lib/commit.js

@@ -0,0 +1,437 @@
+var events = require("events");
+var fp = require("lodash/fp");
+var NodeGit = require("../");
+var Commit = NodeGit.Commit;
+var LookupWrapper = NodeGit.Utils.lookupWrapper;
+
+var _amend = Commit.prototype.amend;
+var _parent = Commit.prototype.parent;
+
+/**
+ * Retrieves the commit pointed to by the oid
+ * @async
+ * @param {Repository} repo The repo that the commit lives in
+ * @param {String|Oid|Commit} id The commit to lookup
+ * @return {Commit}
+ */
+Commit.lookup = LookupWrapper(Commit);
+
+/**
+ * @async
+ * @param {Number} n
+ * @return {Commit}
+ */
+Commit.prototype.parent = function(n) {
+  var repo = this.repo;
+  return _parent.call(this, n).then(p => {
+    p.repo = repo;
+    return p;
+  });
+};
+
+/**
+ * Amend a commit
+ * @async
+ * @param {String} update_ref
+ * @param {Signature} author
+ * @param {Signature} committer
+ * @param {String} message_encoding
+ * @param {String} message
+ * @param {Tree|Oid} tree
+ * @return {Oid}
+ */
+Commit.prototype.amend = function (
+  updateRef, author, committer, message_encoding, message, tree) {
+    var repo = this.repo;
+    var _this = this;
+    var treePromise;
+
+    if (tree instanceof NodeGit.Oid){
+      treePromise = repo.getTree(tree);
+    } else {
+      treePromise = Promise.resolve(tree);
+    }
+
+    return treePromise
+      .then(function(treeObject){
+        return _amend.call(_this,
+          updateRef,
+          author,
+          committer,
+          message_encoding,
+          message,
+          treeObject
+        );
+      });
+};
+
+/**
+ * Amend a commit with the given signature
+ * @async
+ * @param {String} updateRef
+ * @param {Signature} author
+ * @param {Signature} committer
+ * @param {String} messageEncoding
+ * @param {String} message
+ * @param {Tree|Oid} tree
+ * @param {Function} onSignature Callback to be called with string to be signed
+ * @return {Oid}
+*/
+Commit.prototype.amendWithSignature = function(
+  updateRef,
+  author,
+  committer,
+  messageEncoding,
+  message,
+  tree,
+  onSignature
+) {
+    let repo = this.repo;
+    let parentOids = this.parents();
+    let _this = this;
+    let promises = [];
+
+    if (tree instanceof NodeGit.Oid) {
+      promises.push(repo.getTree(tree));
+    } else {
+      promises.push(Promise.resolve(tree));
+    }
+
+    parentOids.forEach(function (parentOid) {
+      promises.push(repo.getCommit(parentOid));
+    });
+
+    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) {
+        let commitTree = commitTreeResult;
+
+        let truthyArgs = fp.omitBy(
+          fp.isNil,
+          {
+            author,
+            committer,
+            messageEncoding,
+            message,
+            tree: treeObject
+          }
+        );
+
+        let commitFields = {
+          author: _this.author(),
+          committer: _this.committer(),
+          messageEncoding: _this.messageEncoding(),
+          message: _this.message(),
+          tree: commitTree
+        };
+
+        ({
+          author: resolvedAuthor,
+          committer: resolvedCommitter,
+          messageEncoding: resolvedMessageEncoding,
+          message: resolvedMessage,
+          tree: resolvedTree
+        } = fp.assign(
+          commitFields,
+          truthyArgs
+        ));
+
+        return Commit.createBuffer(
+          repo,
+          resolvedAuthor,
+          resolvedCommitter,
+          resolvedMessageEncoding,
+          resolvedMessage,
+          resolvedTree,
+          parents.length,
+          parents
+        );
+      })
+      .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,
+              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(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;
+          });
+      });
+};
+
+/**
+ * Retrieve the commit time as a Date object.
+ * @return {Date}
+ */
+Commit.prototype.date = function() {
+  return new Date(this.timeMs());
+};
+
+/**
+ * Generate an array of diff trees showing changes between this commit
+ * and its parent(s).
+ *
+ * @async
+ * @return {Array<Diff>} an array of diffs
+ */
+Commit.prototype.getDiff = function() {
+  return this.getDiffWithOptions(null);
+};
+
+/**
+ * Generate an array of diff trees showing changes between this commit
+ * and its parent(s).
+ *
+ * @async
+ * @param {Object} options
+ * @return {Array<Diff>} an array of diffs
+ */
+Commit.prototype.getDiffWithOptions = function(options) {
+  var commit = this;
+
+  return commit.getTree().then(function(thisTree) {
+    return commit.getParents().then(function(parents) {
+      var diffs;
+      if (parents.length) {
+        diffs = parents.map(function(parent) {
+          return parent.getTree().then(function(parentTree) {
+            return thisTree.diffWithOptions(parentTree, options);
+          });
+        });
+      } else {
+        diffs = [thisTree.diffWithOptions(null, options)];
+      }
+
+      return Promise.all(diffs);
+    });
+  });
+};
+
+/**
+ * Retrieve the entry represented by path for this commit.
+ * Path must be relative to repository root.
+ *
+ * @async
+ * @param {String} path
+ * @return {TreeEntry}
+ */
+Commit.prototype.getEntry = function(path) {
+  return this.getTree().then(function(tree) {
+    return tree.getEntry(path);
+  });
+};
+
+/**
+ * Retrieve the commit's parents as commit objects.
+ *
+ * @async
+ * @param {number} limit Optional amount of parents to return.
+ * @return {Array<Commit>} array of commits
+ */
+Commit.prototype.getParents = function(limit) {
+  var parents = [];
+
+  // If no limit was set, default to the maximum parents.
+  limit = typeof limit === "number" ? limit : this.parentcount();
+  limit = Math.min(limit, this.parentcount());
+
+  for (var i = 0; i < limit; i++) {
+    var oid = this.parentId(i);
+    var parent = this.repo.getCommit(oid);
+
+    parents.push(parent);
+  }
+
+  // Wait for all parents to complete, before returning.
+  return Promise.all(parents);
+};
+
+/**
+ * @typedef extractedSignature
+ * @type {Object}
+ * @property {String} signature the signature of the commit
+ * @property {String} signedData the extracted signed data
+ */
+
+/**
+ * Retrieve the signature and signed data for a commit.
+ * @param  {String} field Optional field to get from the signature,
+ *                        defaults to gpgsig
+ * @return {extractedSignature}
+ */
+Commit.prototype.getSignature = function(field) {
+  return Commit.extractSignature(this.repo, this.id(), field);
+};
+
+/**
+ * Get the tree associated with this commit.
+ *
+ * @async
+ * @return {Tree}
+ */
+Commit.prototype.getTree = function() {
+  return this.repo.getTree(this.treeId());
+};
+
+/**
+ * Walk the history from this commit backwards.
+ *
+ * An EventEmitter is returned that will emit a "commit" event for each
+ * commit in the history, and one "end" event when the walk is completed.
+ * Don't forget to call `start()` on the returned event.
+ *
+ * @fires EventEmitter#commit Commit
+ * @fires EventEmitter#end Array<Commit>
+ * @fires EventEmitter#error Error
+ *
+ * @return {EventEmitter}
+ * @start start()
+ */
+Commit.prototype.history = function() {
+  var event = new events.EventEmitter();
+  var oid = this.id();
+  var revwalk = this.repo.createRevWalk();
+
+  revwalk.sorting.apply(revwalk, arguments);
+
+  var commits = [];
+
+  event.start = function() {
+    revwalk.walk(oid, function commitRevWalk(error, commit) {
+      if (error) {
+        if (error.errno === NodeGit.Error.CODE.ITEROVER) {
+          event.emit("end", commits);
+          return;
+        } else {
+          return event.emit("error", error);
+        }
+      }
+
+      event.emit("commit", commit);
+      commits.push(commit);
+    });
+  };
+
+  return event;
+};
+
+/**
+ * Get the specified parent of the commit.
+ *
+ * @param {number} the position of the parent, starting from 0
+ * @async
+ * @return {Commit} the parent commit at the specified position
+ */
+Commit.prototype.parent = function (id) {
+  var repository = this.repo;
+  return _parent.call(this, id).then(function(parent) {
+    parent.repo = repository;
+    return parent;
+  });
+};
+
+/**
+ * Retrieve the commit's parent shas.
+ *
+ * @return {Array<Oid>} array of oids
+ */
+Commit.prototype.parents = function() {
+  var result = [];
+
+  for (var i = 0; i < this.parentcount(); i++) {
+    result.push(this.parentId(i));
+  }
+
+  return result;
+};
+
+/**
+ * Retrieve the SHA.
+ * @return {String}
+ */
+Commit.prototype.sha = function() {
+  return this.id().toString();
+};
+
+/**
+ * Retrieve the commit time as a unix timestamp.
+ * @return {Number}
+ */
+Commit.prototype.timeMs = function() {
+  return this.time() * 1000;
+};
+
+/**
+ * The sha of this commit
+ * @return {String}
+ */
+Commit.prototype.toString = function() {
+  return this.sha();
+};

package/lib/config.js

@@ -0,0 +1,25 @@
+var util = require("util");
+var NodeGit = require("../");
+
+var Config = NodeGit.Config;
+
+// Backwards compatibility.
+Config.prototype.getString = function() {
+  return this.getStringBuf.apply(this, arguments);
+};
+
+NodeGit.Enums.CVAR = {};
+var DEPRECATED_CVAR_ENUMS = [
+  "FALSE",
+  "TRUE",
+  "INT32",
+  "STRING"
+];
+DEPRECATED_CVAR_ENUMS.forEach((key) => {
+  Object.defineProperty(NodeGit.Enums.CVAR, key, {
+    get: util.deprecate(
+      () => Config.MAP[key],
+      `Use NodeGit.Config.MAP.${key} instead of NodeGit.Enums.CVAR.${key}.`
+    )
+  });
+});

package/lib/convenient_hunks.js

@@ -0,0 +1,61 @@
+var NodeGit = require("../");
+
+var ConvenientHunk = NodeGit.ConvenientHunk;
+
+var header = ConvenientHunk.prototype.header;
+ /**
+  * Diff header string that represents the context of this hunk
+  * of the diff. Something like `@@ -169,14 +167,12 @@ ...`
+  * @return {String}
+  */
+ConvenientHunk.prototype.header = header;
+
+var headerLen = ConvenientHunk.prototype.headerLen;
+/**
+ * The length of the header
+ * @return {Number}
+ */
+ConvenientHunk.prototype.headerLen = headerLen;
+
+var lines = ConvenientHunk.prototype.lines;
+/**
+ * The lines in this hunk
+ * @async
+ * @return {Array<DiffLine>}
+ */
+ConvenientHunk.prototype.lines = lines;
+
+var newLines = ConvenientHunk.prototype.newLines;
+/**
+ * The number of new lines in the hunk
+ * @return {Number}
+ */
+ConvenientHunk.prototype.newLines = newLines;
+
+var newStart = ConvenientHunk.prototype.newStart;
+/**
+ * The starting offset of the first new line in the file
+ * @return {Number}
+ */
+ConvenientHunk.prototype.newStart = newStart;
+
+var oldLines = ConvenientHunk.prototype.oldLines;
+/**
+ * The number of old lines in the hunk
+ * @return {Number}
+ */
+ConvenientHunk.prototype.oldLines = oldLines;
+
+var oldStart = ConvenientHunk.prototype.oldStart;
+/**
+ * The starting offset of the first old line in the file
+ * @return {Number}
+ */
+ConvenientHunk.prototype.oldStart = oldStart;
+
+var size = ConvenientHunk.prototype.size;
+/**
+ * Number of lines in this hunk
+ * @return {Number}
+ */
+ConvenientHunk.prototype.size = size;

package/lib/convenient_patch.js

@@ -0,0 +1,131 @@
+var NodeGit = require("../");
+
+var ConvenientPatch = NodeGit.ConvenientPatch;
+
+var hunks = ConvenientPatch.prototype.hunks;
+/**
+ * The hunks in this patch
+ * @async
+ * @return {Array<ConvenientHunk>}  a promise that resolves to an array of
+ *                                      ConvenientHunks
+ */
+ConvenientPatch.prototype.hunks = hunks;
+
+var isAdded = ConvenientPatch.prototype.isAdded;
+/**
+ * Is this an added patch?
+ * @return {Boolean}
+ */
+ConvenientPatch.prototype.isAdded = isAdded;
+
+var isConflicted = ConvenientPatch.prototype.isConflicted;
+/**
+ * Is this a conflicted patch?
+ * @return {Boolean}
+ */
+ConvenientPatch.prototype.isConflicted = isConflicted;
+
+var isCopied = ConvenientPatch.prototype.isCopied;
+/**
+ * Is this a copied patch?
+ * @return {Boolean}
+ */
+ConvenientPatch.prototype.isCopied = isCopied;
+
+var isDeleted = ConvenientPatch.prototype.isDeleted;
+/**
+ * Is this a deleted patch?
+ * @return {Boolean}
+ */
+ConvenientPatch.prototype.isDeleted = isDeleted;
+
+var isIgnored = ConvenientPatch.prototype.isIgnored;
+/**
+ * Is this an ignored patch?
+ * @return {Boolean}
+ */
+ConvenientPatch.prototype.isIgnored = isIgnored;
+
+var isModified = ConvenientPatch.prototype.isModified;
+/**
+ * Is this an modified patch?
+ * @return {Boolean}
+ */
+ConvenientPatch.prototype.isModified = isModified;
+
+var isRenamed = ConvenientPatch.prototype.isRenamed;
+/**
+ * Is this a renamed patch?
+ * @return {Boolean}
+ */
+ConvenientPatch.prototype.isRenamed = isRenamed;
+
+var isTypeChange = ConvenientPatch.prototype.isTypeChange;
+/**
+ * Is this a type change?
+ * @return {Boolean}
+ */
+ConvenientPatch.prototype.isTypeChange = isTypeChange;
+
+var isUnmodified = ConvenientPatch.prototype.isUnmodified;
+/**
+ * Is this an unmodified patch?
+ * @return {Boolean}
+ */
+ConvenientPatch.prototype.isUnmodified = isUnmodified;
+
+var isUnreadable = ConvenientPatch.prototype.isUnreadable;
+/**
+ * Is this an undreadable patch?
+ * @return {Boolean}
+ */
+ConvenientPatch.prototype.isUnreadable = isUnreadable;
+
+var isUntracked = ConvenientPatch.prototype.isUntracked;
+/**
+ * Is this an untracked patch?
+ * @return {Boolean}
+ */
+ConvenientPatch.prototype.isUntracked = isUntracked;
+
+/**
+ * @typedef lineStats
+ * @type {Object}
+ * @property {number} total_context # of contexts in the patch
+ * @property {number} total_additions # of lines added in the patch
+ * @property {number} total_deletions # of lines deleted in the patch
+ */
+var lineStats = ConvenientPatch.prototype.lineStats;
+/**
+ * The line statistics of this patch (#contexts, #added, #deleted)
+ * @return {lineStats}
+ */
+ConvenientPatch.prototype.lineStats = lineStats;
+
+var newFile = ConvenientPatch.prototype.newFile;
+/**
+ * New attributes of the file
+ * @return {DiffFile}
+ */
+ConvenientPatch.prototype.newFile = newFile;
+
+var oldFile = ConvenientPatch.prototype.oldFile;
+/**
+ * Old attributes of the file
+ * @return {DiffFile}
+ */
+ConvenientPatch.prototype.oldFile = oldFile;
+
+var size = ConvenientPatch.prototype.size;
+/**
+ * The number of hunks in this patch
+ * @return {Number}
+ */
+ConvenientPatch.prototype.size = size;
+
+var status = ConvenientPatch.prototype.status;
+/**
+ * The status of this patch (unmodified, added, deleted)
+ * @return {Number}
+ */
+ConvenientPatch.prototype.status = status;

package/lib/credential.js

@@ -0,0 +1,33 @@
+var util = require("util");
+var NodeGit = require("../");
+
+var Credential = NodeGit.Credential;
+
+var deprecatedFn = (method) =>
+  util.deprecate(
+    Credential[method].bind(Credential),
+    `Use NodeGit.Credential.${method} instead of NodeGit.Cred.${method}`
+  );
+
+var createCredTypeDeprecationMessage = type =>
+  `Use NodeGit.Credential.TYPE.${type} instead of NodeGit.Cred.TYPE.${type}`;
+
+NodeGit.Cred = {
+  defaultNew: deprecatedFn("defaultNew"),
+  sshKeyFromAgent: deprecatedFn("sshKeyFromAgent"),
+  sshKeyNew: deprecatedFn("sshKeyNew"),
+  usernameNew: deprecatedFn("usernameNew"),
+  userpassPlaintextNew: deprecatedFn("userpassPlaintextNew"),
+  TYPE: Object.keys(Credential.TYPE).reduce(
+    (type, key) => {
+      Object.defineProperty(type, key, {
+        get: util.deprecate(
+          () => Credential.TYPE[type],
+          createCredTypeDeprecationMessage(type)
+        )
+      });
+      return type;
+    },
+    {}
+  )
+};