pj-nodegit 0.18.5 → 0.18.6

package/lib/note.js

@@ -1,17 +0,0 @@
-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

@@ -1,45 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,142 +0,0 @@
-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

@@ -1,213 +0,0 @@
-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}.`
-    )
-  });
-});