pj-nodegit 0.18.4 → 0.18.5

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,142 @@
+var NodeGit = require("../");
+var Rebase = NodeGit.Rebase;
+var normalizeOptions = NodeGit.Utils.normalizeOptions;
+var shallowClone = NodeGit.Utils.shallowClone;
+
+var _init = Rebase.init;
+var _open = Rebase.open;
+var _abort = Rebase.prototype.abort;
+var _commit = Rebase.prototype.commit;
+
+function defaultRebaseOptions(options, checkoutStrategy) {
+  let checkoutOptions;
+  let mergeOptions;
+
+  if (options) {
+    options = shallowClone(options);
+    checkoutOptions = options.checkoutOptions;
+    mergeOptions = options.mergeOptions;
+    delete options.checkoutOptions;
+    delete options.mergeOptions;
+
+    if (options.signingCb) {
+      let signingCb = options.signingCb;
+      options.signingCb = function (
+        signatureBuf,
+        signatureFieldBuf,
+        commitContent
+      ) {
+        try {
+          const signingCbResult = signingCb(commitContent);
+
+          return Promise.resolve(signingCbResult)
+            .then(function({ code, field, signedData }) {
+              if (code === NodeGit.Error.CODE.OK) {
+                signatureBuf.setString(signedData);
+                if (field) {
+                  signatureFieldBuf.setString(field);
+                }
+              }
+
+              return code;
+            })
+            .catch(function(error) {
+              if (error && error.code) {
+                return error.code;
+              }
+              return NodeGit.Error.CODE.ERROR;
+            });
+        } catch (error) {
+          if (error && error.code) {
+            return error.code;
+          }
+          return NodeGit.Error.CODE.ERROR;
+        }
+      };
+    }
+
+    options = normalizeOptions(options, NodeGit.RebaseOptions);
+  } else {
+    options = normalizeOptions({}, NodeGit.RebaseOptions);
+    if (checkoutStrategy) {
+      checkoutOptions = {
+        checkoutStrategy: checkoutStrategy
+      };
+    }
+  }
+
+  if (checkoutOptions) {
+    options.checkoutOptions = normalizeOptions(
+      checkoutOptions,
+      NodeGit.CheckoutOptions
+    );
+  }
+
+  if (mergeOptions) {
+    options.mergeOptions = normalizeOptions(
+      mergeOptions,
+      NodeGit.MergeOptions
+    );
+  }
+
+  return options;
+}
+
+// Save options on the rebase object. If we don't do this,
+// the options may be cleaned up and cause a segfault
+// when Rebase.prototype.commit is called.
+const lockOptionsOnRebase = (options) => (rebase) => {
+  Object.defineProperty(rebase, "options", {
+    value: options,
+    writable: false
+  });
+  return rebase;
+};
+
+/**
+ * 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) {
+  options = defaultRebaseOptions(
+    options,
+    NodeGit.Checkout.STRATEGY.FORCE
+  );
+  return _init(repository, branch, upstream, onto, options)
+    .then(lockOptionsOnRebase(options));
+};
+
+/**
+ * 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) {
+  options = defaultRebaseOptions(
+    options,
+    NodeGit.Checkout.STRATEGY.SAFE
+  );
+  return _open(repository, options)
+    .then(lockOptionsOnRebase(options));
+};
+
+Rebase.prototype.commit = function(author, committer, encoding, message) {
+  return _commit.call(this, author, committer, encoding, message);
+};
+
+Rebase.prototype.abort = function() {
+  return _abort.call(this);
+};

package/lib/reference.js

@@ -0,0 +1,213 @@
+var util = require("util");
+var NodeGit = require("../");
+var LookupWrapper = NodeGit.Utils.lookupWrapper;
+
+var Reference = NodeGit.Reference;
+var Branch = NodeGit.Branch;
+
+/**
+* Retrieves the reference by it's short name
+* @async
+* @param {Repository} repo The repo that the reference lives in
+* @param {String|Reference} id The reference to lookup
+* @param {Function} callback
+* @return {Reference}
+*/
+Reference.dwim = LookupWrapper(Reference, Reference.dwim);
+
+/**
+* Retrieves the reference pointed to by the oid
+* @async
+* @param {Repository} repo The repo that the reference lives in
+* @param {String|Reference} id The reference to lookup
+* @param {Function} callback
+* @return {Reference}
+*/
+Reference.lookup = LookupWrapper(Reference);
+
+/**
+ * Returns true if this reference is not symbolic
+ * @return {Boolean}
+ */
+Reference.prototype.isConcrete = function() {
+  return this.type() == Reference.TYPE.DIRECT;
+};
+
+/**
+ * Returns if the ref is pointed at by HEAD
+ * @return {Boolean}
+ */
+Reference.prototype.isHead = function() {
+  return Branch.isHead(this);
+};
+
+/**
+ * Returns true if this reference is symbolic
+ * @return {Boolean}
+ */
+Reference.prototype.isSymbolic = function() {
+  return this.type() == Reference.TYPE.SYMBOLIC;
+};
+
+/**
+ * Returns true if this reference is valid
+ * @return {Boolean}
+ */
+Reference.prototype.isValid = function() {
+  return this.type() != Reference.TYPE.INVALID;
+};
+
+/**
+ * Returns the name of the reference.
+ * @return {String}
+ */
+Reference.prototype.toString = function() {
+ return this.name();
+};
+
+const getTerminal = (repo, refName, depth = 10, prevRef = null) => {
+  if (depth <= 0) {
+    return Promise.resolve({
+      error: NodeGit.Error.CODE.ENOTFOUND,
+      out: prevRef
+    });
+  }
+
+  return NodeGit.Reference.lookup(repo, refName)
+    .then((ref) => {
+      if (ref.type() === NodeGit.Reference.TYPE.DIRECT) {
+        return {
+          error: NodeGit.Error.CODE.OK,
+          out: ref
+        };
+      } else {
+        return getTerminal(repo, ref.symbolicTarget(), depth - 1, ref)
+          .then(({ error, out }) => {
+            if (error === NodeGit.Error.CODE.ENOTFOUND && !out) {
+              return { error, out: ref };
+            } else {
+              return { error, out };
+            }
+          });
+      }
+    })
+    .catch((error) => {
+      return {
+        error: error.errno,
+        out: null
+      };
+    });
+};
+
+const getSignatureForReflog = (repo) => {
+  const { email, name } = repo.ident();
+  if (email && name) {
+    return Promise.resolve(NodeGit.Signature.now(name, email));
+  }
+
+  return NodeGit.Signature.default(repo)
+    .catch(() => NodeGit.Signature.now("unknown", "unknown"));
+};
+
+/**
+ * Given a reference name, follows symbolic links and updates the direct
+ * reference to point to a given OID. Updates the reflog with a given message.
+ *
+ * @async
+ * @param {Repository} repo The repo where the reference and objects live
+ * @param {String} refName The reference name to update
+ * @param {Oid} oid The target OID that the reference will point to
+ * @param {String} logMessage The reflog message to be writted
+ * @param {Signature} signature Optional signature to use for the reflog entry
+ */
+Reference.updateTerminal = function (
+  repo,
+  refName,
+  oid,
+  logMessage,
+  signature
+) {
+  let signatureToUse;
+  let promiseChain = Promise.resolve();
+
+  if (!signature) {
+    promiseChain = promiseChain
+      .then(() => getSignatureForReflog(repo))
+      .then((sig) => {
+        signatureToUse = sig;
+        return Promise.resolve();
+      });
+  } else {
+    signatureToUse = signature;
+  }
+
+  return promiseChain
+    .then(() => getTerminal(repo, refName))
+    .then(({ error, out }) => {
+      if (error === NodeGit.Error.CODE.ENOTFOUND && out) {
+        return NodeGit.Reference.create(
+          repo,
+          out.symbolicTarget(),
+          oid,
+          0,
+          logMessage
+        );
+      } else if (error === NodeGit.Error.CODE.ENOTFOUND) {
+        return NodeGit.Reference.create(
+          repo,
+          refName,
+          oid,
+          0,
+          logMessage
+        );
+      } else {
+        return NodeGit.Reference.createMatching(
+          repo,
+          out.name(),
+          oid,
+          1,
+          out.target(),
+          logMessage
+        );
+      }
+    })
+    .then(() => NodeGit.Reflog.read(repo, refName))
+    .then((reflog) => {
+      // Janky, but works. Ideally, we would want to generate the correct reflog
+      // entry in the first place, rather than drop the most recent entry and
+      // write the correct one.
+      // NOTE: There is a theoretical race condition that could happen here.
+      // We may want to consider some kind of transactional logic to make sure
+      // that the reflog on disk isn't modified before we can write back.
+      reflog.drop(0, 1);
+      reflog.append(oid, signatureToUse, logMessage);
+      return reflog.write();
+    });
+};
+
+// Deprecated -----------------------------------------------------------------
+
+Object.defineProperty(NodeGit.Reference.TYPE, "OID", {
+  get: util.deprecate(
+    () => NodeGit.Reference.TYPE.DIRECT,
+    "Use NodeGit.Reference.TYPE.DIRECT instead of NodeGit.Reference.TYPE.OID."
+  )
+});
+
+Object.defineProperty(NodeGit.Reference.TYPE, "LISTALL", {
+  get: util.deprecate(
+    () => NodeGit.Reference.TYPE.ALL,
+    "Use NodeGit.Reference.TYPE.ALL instead of NodeGit.Reference.TYPE.LISTALL."
+  )
+});
+
+NodeGit.Reference.NORMALIZE = {};
+Object.keys(NodeGit.Reference.FORMAT).forEach((key) => {
+  Object.defineProperty(NodeGit.Reference.NORMALIZE, `REF_FORMAT_${key}`, {
+    get: util.deprecate(
+      () => NodeGit.Reference.FORMAT[key],
+      `Use NodeGit.Reference.FORMAT.${key} instead of ` +
+      `NodeGit.Reference.NORMALIZE.REF_FORMAT_${key}.`
+    )
+  });
+});