pj-nodegit 0.18.4 → 0.18.5

package/lib/tag.js

@@ -0,0 +1,135 @@
+var NodeGit = require("../");
+var LookupWrapper = NodeGit.Utils.lookupWrapper;
+var Tag = NodeGit.Tag;
+
+const signatureRegexesBySignatureType = {
+  gpgsig: [
+    /-----BEGIN PGP SIGNATURE-----[\s\S]+?-----END PGP SIGNATURE-----/gm,
+    /-----BEGIN PGP MESSAGE-----[\s\S]+?-----END PGP MESSAGE-----/gm,
+  ],
+  x509: [
+    /-----BEGIN SIGNED MESSAGE-----[\s\S]+?-----END SIGNED MESSAGE-----/gm,
+  ]
+};
+
+/**
+ * Retrieves the tag pointed to by the oid
+ * @async
+ * @param {Repository} repo The repo that the tag lives in
+ * @param {String|Oid|Tag} id The tag to lookup
+ * @return {Tag}
+ */
+Tag.lookup = LookupWrapper(Tag);
+
+/**
+ * @async
+ * @param {Repository} repo
+ * @param {String} tagName
+ * @param {Oid} target
+ * @param {Signature} tagger
+ * @return {String}
+ */
+Tag.createBuffer = function(repo, tagName, target, tagger, message) {
+  return NodeGit.Object.lookup(repo, target, NodeGit.Object.TYPE.ANY)
+    .then((object) => {
+      if (!NodeGit.Object.typeisloose(object.type())) {
+        throw new Error("Object must be a loose type");
+      }
+
+      const id = object.id().toString();
+      const objectType = NodeGit.Object.type2String(object.type());
+      const lines = [
+        `object ${id}`,
+        `type ${objectType}`,
+        `tag ${tagName}`,
+        `tagger ${tagger.toString(true)}\n`,
+        `${message}${message.endsWith("\n") ? "" : "\n"}`
+      ];
+      return lines.join("\n");
+    });
+};
+
+/**
+ * @async
+ * @param {Repository} repo
+ * @param {String} tagName
+ * @param {Oid} target
+ * @param {Signature} tagger
+ * @param {String} message
+ * @param {Number} force
+ * @param {Function} signingCallback Takes a string and returns a string
+ *                                   representing the signed message
+ * @return {Oid}
+ */
+Tag.createWithSignature = function(
+  repo,
+  tagName,
+  target,
+  tagger,
+  message,
+  force,
+  signingCallback
+) {
+  let tagBuffer;
+  return Tag.createBuffer(repo, tagName, target, tagger, message)
+    .then((tagBufferResult) => {
+      tagBuffer = tagBufferResult;
+      return signingCallback(tagBuffer);
+    })
+    .then(({ code, signedData }) => {
+      switch (code) {
+        case NodeGit.Error.CODE.OK: {
+          const normalizedEnding = signedData.endsWith("\n") ? "" : "\n";
+          const signedTagString = tagBuffer + signedData + normalizedEnding;
+          return Tag.createFromBuffer(repo, signedTagString, force);
+        }
+        case NodeGit.Error.CODE.PASSTHROUGH:
+          return Tag.create(
+            repo,
+            tagName,
+            target,
+            tagger,
+            message,
+            force
+          );
+        default: {
+          const error = new Error(
+            `Tag.createWithSignature threw with error code ${code}`
+          );
+          error.errno = code;
+          throw error;
+        }
+      }
+    });
+};
+
+/**
+ * Retrieves the signature of an annotated tag
+ * @async
+ * @param {String} signatureType
+ * @return {String|null}
+ */
+Tag.prototype.extractSignature = function(signatureType = "gpgsig") {
+  const id = this.id();
+  const repo = this.repo;
+  const signatureRegexes = signatureRegexesBySignatureType[signatureType];
+  if (!signatureRegexes) {
+    throw new Error("Unsupported signature type");
+  }
+
+  return repo.odb().then((odb) => {
+    return odb.read(id);
+  }).then((odbObject) => {
+    const odbData = odbObject.toString();
+
+    for (const regex of signatureRegexes) {
+      const matchResult = odbData.match(regex);
+
+      if (matchResult !== null) {
+        return matchResult[0];
+      }
+    }
+
+    throw new Error("this tag is not signed");
+  });
+};

package/lib/tree.js

@@ -0,0 +1,175 @@
+var path = require("path");
+var events = require("events");
+var NodeGit = require("../");
+var Diff = NodeGit.Diff;
+var LookupWrapper = NodeGit.Utils.lookupWrapper;
+var Tree = NodeGit.Tree;
+var Treebuilder = NodeGit.Treebuilder;
+
+/**
+* Retrieves the tree pointed to by the oid
+* @async
+* @param {Repository} repo The repo that the tree lives in
+* @param {String|Oid|Tree} id The tree to lookup
+* @return {Tree}
+*/
+Tree.lookup = LookupWrapper(Tree);
+
+/**
+ * Make builder. This is helpful for modifying trees.
+ * @return {Treebuilder}
+ */
+Tree.prototype.builder = function() {
+  var builder = Treebuilder.create(this);
+
+  builder.root = builder;
+  builder.repo = this.repo;
+
+  return builder;
+};
+
+/**
+ * Diff two trees
+ * @async
+ * @param {Tree} tree to diff against
+ * @return {Diff}
+ */
+Tree.prototype.diff = function(tree) {
+  return this.diffWithOptions(tree, null);
+};
+
+/**
+ * Diff two trees with options
+ * @async
+ * @param {Tree} tree to diff against
+ * @param {Object} options
+ * @return {Diff}
+ */
+Tree.prototype.diffWithOptions = function(tree, options) {
+  return Diff.treeToTree(this.repo, tree, this, options);
+};
+
+/**
+ * Return an array of the entries in this tree (excluding its children).
+ * @return {Array<TreeEntry>} an array of TreeEntrys
+ */
+Tree.prototype.entries = function() {
+  var size = this.entryCount();
+  var result = [];
+
+  for (var i = 0; i < size; i++) {
+    result.push(this.entryByIndex(i));
+  }
+
+  return result;
+};
+
+/**
+ * Get an entry at the ith position.
+ *
+ * @param {Number} i
+ * @return {TreeEntry}
+ */
+Tree.prototype.entryByIndex = function(i) {
+  var entry = this._entryByIndex(i);
+  entry.parent = this;
+  return entry;
+};
+
+/**
+ * Get an entry by name; if the tree is a directory, the name is the filename.
+ *
+ * @param {String} name
+ * @return {TreeEntry}
+ */
+Tree.prototype.entryByName = function(name) {
+  var entry = this._entryByName(name);
+  entry.parent = this;
+  return entry;
+};
+
+/**
+ * Get an entry at a path. Unlike by name, this takes a fully
+ * qualified path, like `/foo/bar/baz.javascript`
+ * @async
+ * @param {String} filePath
+ * @return {TreeEntry}
+ */
+Tree.prototype.getEntry = function(filePath) {
+  var tree = this;
+
+  return this.entryByPath(filePath).then(function(entry) {
+    entry.parent = tree;
+    entry.dirtoparent = path.dirname(filePath);
+    return entry;
+  });
+};
+
+/**
+ * Return the path of this tree, like `/lib/foo/bar`
+ * @return {String}
+ */
+Tree.prototype.path = function(blobsOnly) {
+  return this.entry ? this.entry.path() : "";
+};
+
+/**
+ * Recursively walk the tree in breadth-first order. Fires an event for each
+ * entry.
+ *
+ * @fires EventEmitter#entry Tree
+ * @fires EventEmitter#end Array<Tree>
+ * @fires EventEmitter#error Error
+ *
+ * @param {Boolean} [blobsOnly = true] True to emit only blob & blob executable
+ * entries.
+ *
+ * @return {EventEmitter}
+ */
+Tree.prototype.walk = function(blobsOnly) {
+  blobsOnly = typeof blobsOnly === "boolean" ? blobsOnly : true;
+
+  var self = this;
+  var event = new events.EventEmitter();
+
+  var total = 1;
+  var entries = new Set();
+  var finalEntires = [];
+
+  // This looks like a DFS, but it is a BFS because of implicit queueing in
+  // the recursive call to `entry.getTree(bfs)`
+  function bfs(error, tree) {
+    total--;
+
+    if (error) {
+      return event.emit("error", error);
+    }
+
+    tree.entries().forEach(function (entry, entryIndex) {
+      if (!blobsOnly || entry.isFile() && !entries.has(entry)) {
+        event.emit("entry", entry);
+        entries.add(entry);
+
+        // Node 0.12 doesn't support either [v for (v of entries)] nor
+        // Array.from so we'll just maintain our own list.
+        finalEntires.push(entry);
+      }
+
+      if (entry.isTree()) {
+        total++;
+        entry.getTree()
+          .then(result => bfs(null, result), bfs);
+      }
+    });
+
+    if (total === 0) {
+      event.emit("end", finalEntires);
+    }
+  }
+
+  event.start = function() {
+    bfs(null, self);
+  };
+
+  return event;
+};

package/lib/tree_entry.js

@@ -0,0 +1,99 @@
+var path = require("path").posix;
+var NodeGit = require("../");
+var TreeEntry = NodeGit.TreeEntry;
+
+/**
+ * Retrieve the blob for this entry. Make sure to call `isBlob` first!
+ * @async
+ * @return {Blob}
+ */
+TreeEntry.prototype.getBlob = function() {
+  return this.parent.repo.getBlob(this.id());
+};
+
+/**
+ * Retrieve the tree for this entry. Make sure to call `isTree` first!
+ * @async
+ * @return {Tree}
+ */
+TreeEntry.prototype.getTree = function() {
+  var entry = this;
+
+  return this.parent.repo.getTree(this.id()).then(function(tree) {
+    tree.entry = entry;
+    return tree;
+  });
+};
+
+/**
+ * Is this TreeEntry a blob? Alias for `isFile`
+ * @return {Boolean}
+ */
+TreeEntry.prototype.isBlob = function() {
+  return this.isFile();
+};
+
+/**
+ * Is this TreeEntry a directory? Alias for `isTree`
+ * @return {Boolean}
+ */
+TreeEntry.prototype.isDirectory = function() {
+  return this.isTree();
+};
+
+/**
+ * Is this TreeEntry a blob? (i.e., a file)
+ * @return {Boolean}
+ */
+TreeEntry.prototype.isFile = function() {
+  return this.filemode() === TreeEntry.FILEMODE.BLOB ||
+         this.filemode() === TreeEntry.FILEMODE.EXECUTABLE;
+};
+
+/**
+ * Is this TreeEntry a submodule?
+ * @return {Boolean}
+ */
+TreeEntry.prototype.isSubmodule = function() {
+  return this.filemode() === TreeEntry.FILEMODE.COMMIT;
+};
+
+/**
+ * Is this TreeEntry a tree? (i.e., a directory)
+ * @return {Boolean}
+ */
+TreeEntry.prototype.isTree = function() {
+  return this.filemode() === TreeEntry.FILEMODE.TREE;
+};
+
+/**
+ * Retrieve the SHA for this TreeEntry. Alias for `sha`
+ * @return {String}
+ */
+TreeEntry.prototype.oid = function() {
+  return this.sha();
+};
+
+/**
+ * Returns the path for this entry.
+ * @return {String}
+ */
+TreeEntry.prototype.path = function() {
+  var dirtoparent = this.dirtoparent || "";
+  return path.join(this.parent.path(), dirtoparent, this.name());
+};
+
+/**
+ * Retrieve the SHA for this TreeEntry.
+ * @return {String}
+ */
+TreeEntry.prototype.sha = function() {
+  return this.id().toString();
+};
+
+/**
+ * Alias for `path`
+ */
+TreeEntry.prototype.toString = function() {
+  return this.path();
+};

package/lib/utils/lookup_wrapper.js

@@ -0,0 +1,39 @@
+var NodeGit = require("../../");
+
+/**
+* Wraps a method so that you can pass in either a string, OID or the object
+* itself and you will always get back a promise that resolves to the object.
+* @param {Object} objectType The object type that you're expecting to receive.
+* @param {Function} lookupFunction  The function to do the lookup for the
+*                                   object. Defaults to `objectType.lookup`.
+* @return {Function}
+*/
+function lookupWrapper(objectType, lookupFunction) {
+  lookupFunction = lookupFunction || objectType.lookup;
+
+  return function(repo, id, callback) {
+    if (id instanceof objectType) {
+      return Promise.resolve(id).then(function(obj) {
+        obj.repo = repo;
+
+        if (typeof callback === "function") {
+          callback(null, obj);
+        }
+
+        return obj;
+      }, callback);
+    }
+
+    return lookupFunction(repo, id).then(function(obj) {
+      obj.repo = repo;
+
+      if (typeof callback === "function") {
+        callback(null, obj);
+      }
+
+      return obj;
+    }, callback);
+  };
+}
+
+NodeGit.Utils.lookupWrapper = lookupWrapper;

package/lib/utils/normalize_fetch_options.js

@@ -0,0 +1,43 @@
+var NodeGit = require("../../");
+var normalizeOptions = NodeGit.Utils.normalizeOptions;
+var shallowClone = NodeGit.Utils.shallowClone;
+
+/**
+ * Normalize an object to match a struct.
+ *
+ * @param {String, Object} oid - The oid string or instance.
+ * @return {Object} An Oid instance.
+ */
+function normalizeFetchOptions(options) {
+  if (options instanceof NodeGit.FetchOptions) {
+    return options;
+  }
+
+  var callbacks;
+  var proxyOpts;
+
+  if (options) {
+    options = shallowClone(options);
+    callbacks = options.callbacks;
+    proxyOpts = options.proxyOpts;
+    delete options.callbacks;
+    delete options.proxyOpts;
+  } else {
+    options = {};
+  }
+
+  options = normalizeOptions(options, NodeGit.FetchOptions);
+
+  if (callbacks) {
+    options.callbacks =
+      normalizeOptions(callbacks, NodeGit.RemoteCallbacks);
+  }
+
+  if (proxyOpts) {
+    options.proxyOpts =
+      normalizeOptions(proxyOpts, NodeGit.ProxyOptions);
+  }
+  return options;
+}
+
+NodeGit.Utils.normalizeFetchOptions = normalizeFetchOptions;

package/lib/utils/normalize_options.js

@@ -0,0 +1,29 @@
+var NodeGit = require("../../");
+
+/**
+ * Normalize an object to match a struct.
+ *
+ * @param {String, Object} oid - The oid string or instance.
+ * @return {Object} An Oid instance.
+ */
+function normalizeOptions(options, Ctor) {
+  if (!options) {
+    return null;
+  }
+
+  if (options instanceof Ctor) {
+    return options;
+  }
+
+  var instance = new Ctor();
+
+  Object.keys(options).forEach(function(key) {
+    if (typeof options[key] !== "undefined") {
+      instance[key] = options[key];
+    }
+  });
+
+  return instance;
+}
+
+NodeGit.Utils.normalizeOptions = normalizeOptions;

package/lib/utils/shallow_clone.js

@@ -0,0 +1,14 @@
+var NodeGit = require("../../");
+
+function shallowClone() {
+  var merges = Array.prototype.slice.call(arguments);
+
+  return merges.reduce(function(obj, merge) {
+    return Object.keys(merge).reduce(function(obj, key) {
+      obj[key] = merge[key];
+      return obj;
+    }, obj);
+  }, {});
+}
+
+NodeGit.Utils.shallowClone = shallowClone;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "pj-nodegit",
   "description": "Node.js libgit2 asynchronous native bindings",
-  "version": "0.18.4",
+  "version": "0.18.5",
   "homepage": "http://nodegit.org",
   "keywords": [
     "libgit2",