pj-nodegit 0.18.4 → 0.18.5

package/lib/diff.js

@@ -0,0 +1,113 @@
+var NodeGit = require("../");
+var Diff = NodeGit.Diff;
+var normalizeOptions = NodeGit.Utils.normalizeOptions;
+var Patch = NodeGit.Patch;
+
+var _blobToBuffer = Diff.blobToBuffer;
+var _indexToWorkdir = Diff.indexToWorkdir;
+var _treeToIndex = Diff.treeToIndex;
+var _treeToTree = Diff.treeToTree;
+var _treeToWorkdir = Diff.treeToWorkdir;
+var _treeToWorkdirWithIndex = Diff.treeToWorkdirWithIndex;
+
+var _findSimilar = Diff.prototype.findSimilar;
+
+/**
+ * Directly run a diff between a blob and a buffer.
+ * @async
+ * @param {Blob} old_blob Blob for old side of diff, or NULL for empty blob
+ * @param {String} old_as_path Treat old blob as if it had this filename;
+ * can be NULL
+ * @param {String} buffer Raw data for new side of diff, or NULL for empty
+ * @param {String} buffer_as_path Treat buffer as if it had this filename;
+ * can be NULL
+ * @param {DiffOptions} opts Options for diff, or NULL for default options
+ * @param {Function} file_cb Callback for "file"; made once if there is a diff;
+ * can be NULL
+ * @param {Function} binary_cb Callback for binary files; can be NULL
+ * @param {Function} hunk_cb Callback for each hunk in diff; can be NULL
+ * @param {Function} line_cb Callback for each line in diff; can be NULL
+ */
+Diff.blobToBuffer= function(
+    old_blob,
+    old_as_path,
+    buffer,
+    buffer_as_path,
+    opts,
+    file_cb,
+    binary_cb,
+    hunk_cb,
+    line_cb) {
+  var bufferText;
+  var bufferLength;
+  if (buffer instanceof Buffer) {
+    bufferText = buffer.toString("utf8");
+    bufferLength = Buffer.byteLength(buffer, "utf8");
+  } else {
+    bufferText = buffer;
+    bufferLength = !buffer ? 0 : Buffer.byteLength(buffer, "utf8");
+  }
+
+  opts = normalizeOptions(opts, NodeGit.DiffOptions);
+
+  return _blobToBuffer.call(
+    this,
+    old_blob,
+    old_as_path,
+    bufferText,
+    bufferLength,
+    buffer_as_path,
+    opts,
+    file_cb,
+    binary_cb,
+    hunk_cb,
+    line_cb,
+    null);
+};
+
+// Override Diff.indexToWorkdir to normalize opts
+Diff.indexToWorkdir = function(repo, index, opts) {
+  opts = normalizeOptions(opts, NodeGit.DiffOptions);
+  return _indexToWorkdir(repo, index, opts);
+};
+
+// Override Diff.treeToIndex to normalize opts
+Diff.treeToIndex = function(repo, tree, index, opts) {
+  opts = normalizeOptions(opts, NodeGit.DiffOptions);
+  return _treeToIndex(repo, tree, index, opts);
+};
+
+// Override Diff.treeToTree to normalize opts
+Diff.treeToTree = function(repo, from_tree, to_tree, opts) {
+  opts = normalizeOptions(opts, NodeGit.DiffOptions);
+  return _treeToTree(repo, from_tree, to_tree, opts);
+};
+
+// Override Diff.treeToWorkdir to normalize opts
+Diff.treeToWorkdir = function(repo, tree, opts) {
+  opts = normalizeOptions(opts, NodeGit.DiffOptions);
+  return _treeToWorkdir(repo, tree, opts);
+};
+
+// Override Diff.treeToWorkdir to normalize opts
+Diff.treeToWorkdirWithIndex = function(repo, tree, opts) {
+  opts = normalizeOptions(opts, NodeGit.DiffOptions);
+  return _treeToWorkdirWithIndex(repo, tree, opts);
+};
+
+// Override Diff.findSimilar to normalize opts
+Diff.prototype.findSimilar = function(opts) {
+  opts = normalizeOptions(opts, NodeGit.DiffFindOptions);
+  return _findSimilar.call(this, opts);
+};
+
+/**
+ * Retrieve patches in this difflist
+ *
+ * @async
+ * @return {Array<ConvenientPatch>} a promise that resolves to an array of
+ *                                      ConvenientPatches
+ */
+Diff.prototype.patches = function() {
+  return Patch.convenientFromDiff(this);
+};

package/lib/diff_file.js

@@ -0,0 +1,38 @@
+var NodeGit = require("../");
+
+var DiffFile = NodeGit.DiffFile;
+
+var flags = DiffFile.prototype.flags;
+/**
+ * Returns the file's flags
+ * @return {Number}
+ */
+DiffFile.prototype.flags = flags;
+
+var id = DiffFile.prototype.id;
+/**
+ * Returns the file's Oid
+ * @return {Oid}
+ */
+DiffFile.prototype.id = id;
+
+var mode = DiffFile.prototype.mode;
+/**
+ * Returns the file's mode
+ * @return {Number}
+ */
+DiffFile.prototype.mode = mode;
+
+var path = DiffFile.prototype.path;
+/**
+ * Returns the file's path
+ * @return {String}
+ */
+DiffFile.prototype.path = path;
+
+var size = DiffFile.prototype.size;
+/**
+ * Returns the file's size
+ * @return {Number}
+ */
+DiffFile.prototype.size = size;

package/lib/diff_line.js

@@ -0,0 +1,32 @@
+var NodeGit = require("../");
+var DiffLine = NodeGit.DiffLine;
+
+var _rawContent = DiffLine.prototype.content;
+
+/**
+* The relevant line
+* @return {String}
+*/
+DiffLine.prototype.content = function() {
+  if (!this._cache) {
+    this._cache = {};
+  }
+
+  if (!this._cache.content) {
+    this._cache.content = Buffer.from(this.rawContent())
+      .slice(0, this.contentLen())
+      .toString("utf8");
+  }
+
+  return this._cache.content;
+};
+
+/**
+* The non utf8 translated text
+* @return {String}
+*/
+DiffLine.prototype.rawContent = function() {
+  return _rawContent.call(this);
+};
+
+NodeGit.DiffLine = DiffLine;