@swimlane/nodegit 1.1.2

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/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/lifecycleScripts/clean.js

@@ -0,0 +1,5 @@
+var cleanForPublish = require("clean-for-publish");
+var path = require("path");
+
+var location = path.join(__dirname, "..");
+cleanForPublish(location);

package/lifecycleScripts/install.js

@@ -0,0 +1,32 @@
+var buildFlags = require("../utils/buildFlags");
+
+module.exports = async function install() {
+  console.log("[nodegit] Running install script");
+
+  var args = ["install"];
+
+  if (buildFlags.mustBuild) {
+    console.info(
+      "[nodegit] Pre-built download disabled, building from source.",
+    );
+    args.push("--build-from-source");
+
+    if (buildFlags.debugBuild) {
+      console.info("[nodegit] Building debug version.");
+      args.push("--debug");
+    }
+  } else {
+    args.push("--fallback-to-build");
+  }
+
+  return;
+};
+
+// Called on the command line
+if (require.main === module) {
+  module.exports().catch(function (e) {
+    console.error("[nodegit] ERROR - Could not finish install");
+    console.error("[nodegit] ERROR - finished with error code: " + e);
+    process.exit(e);
+  });
+}

package/lifecycleScripts/postinstall.js

@@ -0,0 +1,83 @@
+var fse = require("fs-extra");
+var path = require("path");
+
+var exec = require("../utils/execPromise");
+var buildFlags = require("../utils/buildFlags");
+
+var rootPath = path.join(__dirname, "..");
+
+function printStandardLibError() {
+  console.log(
+    "[nodegit] ERROR - the latest libstdc++ is missing on your system!"
+  );
+  console.log("");
+  console.log("On Ubuntu you can install it using:");
+  console.log("");
+  console.log("$ sudo add-apt-repository ppa:ubuntu-toolchain-r/test");
+  console.log("$ sudo apt-get update");
+  console.log("$ sudo apt-get install libstdc++-4.9-dev");
+}
+
+module.exports = function install() {
+  if (buildFlags.isGitRepo) {
+    // If we're building NodeGit from a git repo we aren't going to do any
+    // cleaning up
+    return Promise.resolve();
+  }
+  if (buildFlags.isElectron || buildFlags.isNWjs) {
+    // If we're building for electron or NWjs, we're unable to require the
+    // built library so we have to just assume success, unfortunately.
+    return Promise.resolve();
+  }
+
+  return exec("node \"" + path.join(rootPath, "lib/nodegit.js\""))
+    .catch(function(e) {
+      if (~e.toString().indexOf("Module version mismatch")) {
+        console.warn(
+          "[nodegit] WARN - NodeGit was built for a different version of node."
+        );
+        console.warn(
+          "If you are building NodeGit for electron/nwjs you can " +
+          "ignore this warning."
+        );
+      }
+      else {
+        throw e;
+      }
+    })
+    .then(function() {
+      // If we're using NodeGit from a package manager then let's clean up after
+      // ourselves when we install successfully.
+      if (!buildFlags.mustBuild) {
+        // We can't remove the source files yet because apparently the
+        // "standard workflow" for native node moduels in Electron/nwjs is to
+        // build them for node and then nah eff that noise let's rebuild them
+        // again for the actual platform! Hurray!!! When that madness is dead
+        // we can clean up the source which is a serious amount of data.
+        // fse.removeSync(path.join(rootPath, "vendor"));
+        // fse.removeSync(path.join(rootPath, "src"));
+        // fse.removeSync(path.join(rootPath, "include"));
+
+        fse.removeSync(path.join(rootPath, "build/Release/*.a"));
+        fse.removeSync(path.join(rootPath, "build/Release/obj.target"));
+      }
+    });
+};
+
+// Called on the command line
+if (require.main === module) {
+  module.exports()
+    .catch(function(e) {
+      console.warn("[nodegit] WARN - Could not finish postinstall");
+
+      if (
+        process.platform === "linux" &&
+        ~e.toString().indexOf("libstdc++")
+      ) {
+        printStandardLibError();
+      }
+      else {
+        console.log(e);
+      }
+    });
+}

package/lifecycleScripts/preinstall.js

@@ -0,0 +1,47 @@
+var path = require("path");
+var local = path.join.bind(path, __dirname);
+
+var exec = require(local("../utils/execPromise"));
+var buildFlags = require(local("../utils/buildFlags"));
+
+module.exports = function prepareForBuild() {
+  console.log("[nodegit] Running pre-install script");
+
+  return exec("npm -v")
+    .then(
+      function(npmVersion) {
+        if (npmVersion.split(".")[0] < 3) {
+          console.log(
+            "[nodegit] npm@2 installed, pre-loading required packages"
+          );
+          return exec("npm install --ignore-scripts");
+        }
+
+        return Promise.resolve();
+      },
+      function() {
+        // We're installing via yarn, so don't
+        // care about compability with npm@2
+      }
+    )
+    .then(function() {
+      if (buildFlags.isGitRepo) {
+        var submodules = require(local("submodules"));
+        var generate = require(local("../generate"));
+        return submodules()
+          .then(function() {
+            return generate();
+          });
+      }
+    });
+};
+
+// Called on the command line
+if (require.main === module) {
+  module.exports()
+    .catch(function(e) {
+      console.error("[nodegit] ERROR - Could not finish preinstall");
+      console.error(e);
+      process.exit(1);
+    });
+}

package/lifecycleScripts/submodules/getStatus.js

@@ -0,0 +1,50 @@
+var path = require("path");
+var rootDir = path.join(__dirname, "../..");
+var exec = require(path.join(rootDir, "./utils/execPromise"));
+
+module.exports = function getStatus() {
+  return exec("git submodule status", { cwd: rootDir })
+    .then(function (stdout) {
+      if (!stdout) {
+        // In the case where we pull from npm they pre-init the submodules for
+        // us and `git submodule status` returns empty-string. In that case
+        // we'll just assume that we're good.
+        return Promise.resolve([]);
+      }
+
+      function getStatusPromiseFromLine(line) {
+        var lineSections = line.trim().split(" ");
+        var onNewCommit = !!~lineSections[0].indexOf("+");
+        var needsInitialization = !!~lineSections[0].indexOf("-");
+        var commitOid = lineSections[0].replace("+", "").replace("-", "");
+        var name = lineSections[1];
+
+        return exec("git status", { cwd: path.join(rootDir, name) }).then(
+          function (workDirStatus) {
+            return {
+              commitOid: commitOid,
+              onNewCommit: onNewCommit,
+              name: name,
+              needsInitialization: needsInitialization,
+              workDirDirty: !~workDirStatus
+                .trim()
+                .split("\n")
+                .pop()
+                .indexOf("nothing to commit"),
+            };
+          },
+        );
+      }
+
+      return Promise.all(
+        stdout.trim().split("\n").map(getStatusPromiseFromLine),
+      );
+    })
+    .catch(function (err) {
+      console.error("[readme] failure to get submodule status:", err);
+      // In the case that NodeGit is required from another project via npm we
+      // won't be able to run submodule commands but that's ok since the
+      // correct version of libgit2 is published with nodegit.
+      return Promise.resolve([]);
+    });
+};

package/lifecycleScripts/submodules/index.js

@@ -0,0 +1,84 @@
+var path = require("path");
+var rootDir = path.join(__dirname, "../..");
+
+var gitExecutableLocation = require(
+  path.join(rootDir, "./utils/gitExecutableLocation"),
+);
+var submoduleStatus = require("./getStatus");
+
+var exec = require(path.join(rootDir, "./utils/execPromise"));
+
+module.exports = function submodules() {
+  return gitExecutableLocation()
+    .catch(function () {
+      console.error(
+        "[nodegit] ERROR - Compilation of NodeGit requires git " +
+          "CLI to be installed and on the path",
+      );
+
+      throw new Error("git CLI is not installed or not on the path");
+    })
+    .then(function () {
+      console.log("[nodegit] Checking submodule status");
+      return submoduleStatus();
+    })
+    .then(function (statuses) {
+      console.log("[readme] submodule status: ", statuses);
+      function printSubmodule(submoduleName) {
+        console.log("\t" + submoduleName);
+      }
+
+      var dirtySubmodules = statuses
+        .filter(function (status) {
+          return status.workDirDirty && !status.needsInitialization;
+        })
+        .map(function (dirtySubmodule) {
+          return dirtySubmodule.name;
+        });
+
+      if (dirtySubmodules.length) {
+        console.error(
+          "[nodegit] ERROR - Some submodules have uncommited changes:",
+        );
+        dirtySubmodules.forEach(printSubmodule);
+        console.error(
+          "\nThey must either be committed or discarded before we build",
+        );
+
+        throw new Error("Dirty Submodules: " + dirtySubmodules.join(" "));
+      }
+
+      var outOfSyncSubmodules = statuses
+        .filter(function (status) {
+          return status.onNewCommit && !status.needsInitialization;
+        })
+        .map(function (outOfSyncSubmodule) {
+          return outOfSyncSubmodule.name;
+        });
+
+      if (outOfSyncSubmodules.length) {
+        console.warn(
+          "[nodegit] WARNING - Some submodules are pointing to an new commit:",
+        );
+        outOfSyncSubmodules.forEach(printSubmodule);
+        console.warn("\nThey will not be updated.");
+      }
+
+      return statuses
+        .filter(function (status) {
+          return !status.onNewCommit;
+        })
+        .reduce(function (chainPromise, submoduleToUpdate) {
+          return chainPromise.then(function () {
+            console.log(
+              "[nodegit] Initializing submodule",
+              submoduleToUpdate.name,
+            );
+            return exec(
+              "git submodule update --init --recursive " +
+                submoduleToUpdate.name,
+            );
+          });
+        }, Promise.resolve());
+    });
+};