var fse = require("fs-extra");

var fp = require("lodash/fp");

var NodeGit = require("../");

var Blob = NodeGit.Blob;

var Checkout = NodeGit.Checkout;

var Commit = NodeGit.Commit;

var normalizeOptions = NodeGit.Utils.normalizeOptions;

var shallowClone = NodeGit.Utils.shallowClone;

var path = require("path");

var Filter = NodeGit.Filter;

var FilterList = NodeGit.FilterList;

var Reference = NodeGit.Reference;

var Remote = NodeGit.Remote;

var Repository = NodeGit.Repository;

var Revwalk = NodeGit.Revwalk;

var Status = NodeGit.Status;

var StatusFile = NodeGit.StatusFile;

var StatusList = NodeGit.StatusList;

var Submodule = NodeGit.Submodule;

var Tag = NodeGit.Tag;

var Tree = NodeGit.Tree;

var TreeBuilder = NodeGit.Treebuilder;

var _discover = Repository.discover;

var _initExt = Repository.initExt;

var _fetchheadForeach = Repository.prototype.fetchheadForeach;

var _mergeheadForeach = Repository.prototype.mergeheadForeach;

function applySelectedLinesToTarget

(originalContent, newLines, pathHunks, isStaged, reverse) {

// 43: ascii code for '+'

// 45: ascii code for '-'

var lineTypes = {

ADDED: !reverse ? 43 : 45,

DELETED: !reverse ? 45 : 43

};

var newContent = "";

var oldIndex = 0;

var linesPromises = [];

var oldLines = originalContent.toString().split("\n");

// if no selected lines were sent, return the original content

if (!newLines || newLines.length === 0) {

return originalContent;

}

function lineEqualsFirstNewLine(hunkLine) {

return ((hunkLine.oldLineno() === newLines[0].oldLineno()) &&

(hunkLine.newLineno() === newLines[0].newLineno()));

}

function processSelectedLine(hunkLine) {

// if this hunk line is a selected line find the selected line

var newLine = newLines.filter(function(nLine) {

return ((hunkLine.oldLineno() === nLine.oldLineno()) &&

(hunkLine.newLineno() === nLine.newLineno()));

});

if (hunkLine.content().indexOf("\\ No newline at end of file") !== -1) {

return false;

}

// determine what to add to the new content

if ((isStaged && newLine && newLine.length > 0) ||

(!isStaged && (!newLine || newLine.length === 0))) {

if (hunkLine.origin() !== lineTypes.ADDED) {

newContent += hunkLine.content();

}

if ((isStaged && hunkLine.origin() !== lineTypes.DELETED) ||

(!isStaged && hunkLine.origin() !== lineTypes.ADDED)) {

oldIndex++;

}

}

else {

switch (hunkLine.origin()) {

case lineTypes.ADDED:

newContent += hunkLine.content();

if (isStaged) {

oldIndex++;

}

break;

case lineTypes.DELETED:

if (!isStaged) {

oldIndex++;

}

break;

default:

newContent += oldLines[oldIndex++];

if (oldIndex < oldLines.length) {

newContent += "\n";

}

break;

}

}

}

// find the affected hunk

pathHunks.forEach(function(pathHunk) {

linesPromises.push(pathHunk.lines());

});

return Promise.all(linesPromises).then(function(results) {

for (var i = 0; i < results.length && newContent.length < 1; i++) {

var hunkStart = isStaged || reverse ? pathHunks[i].newStart()

: pathHunks[i].oldStart();

var lines = results[i];

if (lines.filter(lineEqualsFirstNewLine).length > 0) {

// add content that is before the hunk

while (hunkStart > (oldIndex + 1)) {

newContent += oldLines[oldIndex++] + "\n";

}

// modify the lines of the hunk according to the selection

lines.forEach(processSelectedLine);

// add the rest of the file

while (oldLines.length > oldIndex) {

newContent += oldLines[oldIndex++] +

(oldLines.length > oldIndex ? "\n" : "");

}

}

}

return newContent;

});

}

function getPathHunks(repo, index, filePath, isStaged, additionalDiffOptions) {

var diffOptions = additionalDiffOptions ? {

flags: additionalDiffOptions

} : undefined;

return Promise.resolve()

.then(function() {

if (isStaged) {

return repo.getHeadCommit()

.then(function getTreeFromCommit(commit) {

return commit.tree();

})

.then(function getDiffFromTree(tree) {

return NodeGit.Diff.treeToIndex(repo, tree, index, diffOptions);

});

}

return NodeGit.Diff.indexToWorkdir(repo, index, {

flags:

NodeGit.Diff.OPTION.SHOW_UNTRACKED_CONTENT |

NodeGit.Diff.OPTION.RECURSE_UNTRACKED_DIRS |

(additionalDiffOptions || 0)

});

})

.then(function(diff) {

return NodeGit.Status.file(repo, filePath)

.then(function(status) {

if (!(status & NodeGit.Status.STATUS.WT_MODIFIED) &&

!(status & NodeGit.Status.STATUS.INDEX_MODIFIED)) {

return Promise.reject

("Selected staging is only available on modified files.");

}

return diff.patches();

});

})

.then(function(patches) {

var pathPatch = patches.filter(function(patch) {

return patch.newFile().path() === filePath;

});

if (pathPatch.length !== 1) {

return Promise.reject("No differences found for this file.");

}

return pathPatch[0].hunks();

});

}

/**

* Goes through a rebase's rebase operations and commits them if there are

* no merge conflicts

*

* @param {Repository} repository The repository that the rebase is being

* performed in

* @param {Rebase} rebase The current rebase being performed

* @param {Signature} signature Identity of the one performing the rebase

* @param {Function} beforeNextFn Callback to be called before each

* invocation of next(). If the callback

* returns a promise, the next() will be

* called when the promise resolves.

* @param {Function} beforeFinishFn Callback called before the invocation

* of finish(). If the callback returns a

* promise, finish() will be called when the

* promise resolves. This callback will be

* provided a detailed overview of the rebase

* @return {Int|Index} An error code for an unsuccesful rebase or an index for

* a rebase with conflicts

*/

function performRebase(

repository,

rebase,

signature,

beforeNextFn,

beforeFinishFn

) {

var beforeNextFnResult;

/* In the case of FF merges and a beforeFinishFn, this will fail

* when looking for 'rewritten' so we need to handle that case.

*/

function readRebaseMetadataFile(fileName, continueOnError) {

return fse.readFile(

path.join(repository.path(), "rebase-merge", fileName),

{ encoding: "utf8" }

)

.then(fp.trim)

.catch(function(err) {

if (continueOnError) {

return null;

}

throw err;

});

}

function calcHeadName(input) {

return input.replace(/refs\/heads\/(.*)/, "$1");

}

function getPromise() {

return rebase.next()

.then(function() {

return repository.refreshIndex();

})

.then(function(index) {

if (index.hasConflicts()) {

throw index;

}

return rebase.commit(null, signature);

})

.then(function() {

return performRebase(

repository,

rebase,

signature,

beforeNextFn,

beforeFinishFn

);

})

.catch(function(error) {

if (error && error.errno === NodeGit.Error.CODE.ITEROVER) {

const calcRewritten = fp.cond([

[fp.isEmpty, fp.constant(null)],

[fp.stubTrue, fp.flow([

fp.split("\n"),

fp.map(fp.split(" "))

])]

]);

const beforeFinishFnPromise = !beforeFinishFn ?

Promise.resolve() :

Promise.all([

readRebaseMetadataFile("onto_name"),

readRebaseMetadataFile("onto"),

readRebaseMetadataFile("head-name").then(calcHeadName),

readRebaseMetadataFile("orig-head"),

readRebaseMetadataFile("rewritten", true).then(calcRewritten)

])

.then(function([

ontoName,

ontoSha,

originalHeadName,

originalHeadSha,

rewritten

]) {

return beforeFinishFn({

ontoName,

ontoSha,

originalHeadName,

originalHeadSha,

rebase,

rewritten

});

});

return beforeFinishFnPromise

.then(function() {

return rebase.finish(signature);

});

} else {

throw error;

}

});

}

if(beforeNextFn) {

beforeNextFnResult = beforeNextFn(rebase);

// if beforeNextFn returns a promise, chain the promise

return Promise.resolve(beforeNextFnResult)

.then(getPromise);

}

return getPromise();

}

/**

* Creates a branch with the passed in name pointing to the commit

*

* @async

* @param {String} startPath The base path where the lookup starts.

* @param {Number} acrossFs If non-zero, then the lookup will not stop when a

filesystem device change is detected while exploring

parent directories.

* @param {String} ceilingDirs A list of absolute symbolic link free paths.

the search will stop if any of these paths

are hit. This may be set to null

* @return {String} Path of the git repository

*/

Repository.discover = function(startPath, acrossFs, ceilingDirs, callback) {

return _discover(startPath, acrossFs, ceilingDirs)

.then(function(foundPath) {

foundPath = path.resolve(foundPath);

if (typeof callback === "function") {

callback(null, foundPath);

}

return foundPath;

}, callback);

};

// Override Repository.initExt to normalize initoptions

Repository.initExt = function(repo_path, opts) {

opts = normalizeOptions(opts, NodeGit.RepositoryInitOptions);

return _initExt(repo_path, opts);

};

Repository.getReferences = function(repo, type, refNamesOnly, callback) {

return Reference.list(repo).then(function(refList) {

var refFilterPromises = [];

var filteredRefs = [];

refList.forEach(function(refName) {

refFilterPromises.push(Reference.lookup(repo, refName)

.then(function(ref) {

if (type == Reference.TYPE.LISTALL || ref.type() == type) {

if (refNamesOnly) {

filteredRefs.push(refName);

return;

}

if (ref.isSymbolic()) {

return ref.resolve().then(function(resolvedRef) {

resolvedRef.repo = repo;

filteredRefs.push(resolvedRef);

})

.catch(function() {

// If we can't resolve the ref then just ignore it.

});

}

else {

filteredRefs.push(ref);

}

}

})

);

});

return Promise.all(refFilterPromises).then(function() {

if (typeof callback === "function") {

callback(null, filteredRefs);

}

return filteredRefs;

}, callback);

});

};

/**

* This will set the HEAD to point to the local branch and then attempt

* to update the index and working tree to match the content of the

* latest commit on that branch

*

* @async

* @param {String|Reference} branch the branch to checkout

* @param {Object|CheckoutOptions} opts the options to use for the checkout

*/

Repository.prototype.checkoutBranch = function(branch, opts) {

var repo = this;

return repo.getReference(branch)

.then(function(ref) {

if (!ref.isBranch()) {

return false;

}

return repo.checkoutRef(ref, opts);

});

};

/**

* This will set the HEAD to point to the reference and then attempt

* to update the index and working tree to match the content of the

* latest commit on that reference

*

* @async

* @param {Reference} reference the reference to checkout

* @param {Object|CheckoutOptions} opts the options to use for the checkout

*/

Repository.prototype.checkoutRef = function(reference, opts) {

var repo = this;

opts = opts || {};

opts.checkoutStrategy = opts.checkoutStrategy ||

(NodeGit.Checkout.STRATEGY.SAFE |

NodeGit.Checkout.STRATEGY.RECREATE_MISSING);

return repo.getReferenceCommit(reference.name())

.then(function(commit) {

return commit.tree();

})

.then(function(tree) {

return Checkout.tree(repo, tree, opts);

})

.then(function() {

var name = reference.name();

return repo.setHead(name);

});

};

/**

* Continues an existing rebase

*

* @async

* @param {Signature} signature Identity of the one performing the rebase

* @param {Function} beforeNextFn Callback to be called before each step

* of the rebase. If the callback returns a

* promise, the rebase will resume when the

* promise resolves. The rebase object is

* is passed to the callback.

* @param {Function} beforeFinishFn Callback called before the invocation

* of finish(). If the callback returns a

* promise, finish() will be called when the

* promise resolves. This callback will be

* provided a detailed overview of the rebase

* @return {Oid|Index} A commit id for a succesful merge or an index for a

* rebase with conflicts

*/

Repository.prototype.continueRebase = function(

signature,

beforeNextFn,

beforeFinishFn

) {

var repo = this;

signature = signature || repo.defaultSignature();

var rebase;

return repo.refreshIndex()

.then(function(index) {

if (index.hasConflicts()) {

throw index;

}

return NodeGit.Rebase.open(repo);

})

.then(function(_rebase) {

rebase = _rebase;

return rebase.commit(null, signature)

.catch(function() {

// Ignore all errors to prevent

// this routine from choking now

// that we made rebase.commit

// asynchronous

});

})

.then(function() {

return performRebase(

repo,

rebase,

signature,

beforeNextFn,

beforeFinishFn

);

})

.then(function(error) {

if (error) {

throw error;

}

return repo.getBranchCommit("HEAD");

});

};

/**

* Creates a branch with the passed in name pointing to the commit

*

* @async

* @param {String} name Branch name, e.g. "master"

* @param {Commit|String|Oid} commit The commit the branch will point to

* @param {Boolean} force Overwrite branch if it exists

* @return {Reference}

*/

Repository.prototype.createBranch = function(name, commit, force) {

var repo = this;

if (commit instanceof Commit) {

return NodeGit.Branch.create(

repo,

name,

commit,

force ? 1 : 0);

}

else {

return repo.getCommit(commit).then(function(commit) {

return NodeGit.Branch.create(

repo,

name,

commit,

force ? 1 : 0);

});

}

};

/**

* Create a blob from a buffer

*

* @param {Buffer} buffer

* @return {Oid}

*/

Repository.prototype.createBlobFromBuffer = function(buffer) {

return Blob.createFromBuffer(this, buffer, buffer.length);

};

/**

* Create a commit

*

* @async

* @param {String} updateRef

* @param {Signature} author

* @param {Signature} committer

* @param {String} message

* @param {Oid|String} Tree

* @param {Array} parents

* @return {Oid} The oid of the commit

*/

Repository.prototype.createCommit = function(

updateRef, author, committer, message, tree, parents, callback) {

var repo = this;

var promises = [];

parents = parents || [];

promises.push(repo.getTree(tree));

parents.forEach(function(parent) {

promises.push(repo.getCommit(parent));

});

return Promise.all(promises).then(function(results) {

tree = results[0];

// Get the normalized values for our input into the function

var parentsLength = parents.length;

parents = [];

for (var i = 0; i < parentsLength; i++) {

parents.push(results[i + 1]);

}

return Commit.create(

repo,

updateRef,

author,

committer,

null /* use default message encoding */,

message,

tree,

parents.length,

parents

);

}).then(function(commit) {

if (typeof callback === "function") {

callback(null, commit);

}

return commit;

}, callback);

};

/**

* Create a commit

*

* @async

* @param {Signature} author

* @param {Signature} committer

* @param {String} message

* @param {Oid|String} treeOid

* @param {Array} parents

* @return {String} The content of the commit object

* as a string

*/

Repository.prototype.createCommitBuffer = function(

author, committer, message, treeOid, parents) {

const repo = this;

const promises = (parents || [])

.reduce(function(acc, parent) {

acc.push(repo.getCommit(parent));

return acc;

}, [repo.getTree(treeOid)]);

return Promise.all(promises)

.then(function([tree, ...parentCommits]) {

return Commit.createBuffer(

repo,

author,

committer,

null /* use default message encoding */,

message,

tree,

parentCommits.length,

parentCommits

);

});

};

/**

* Creates a new commit on HEAD from the list of passed in files

*

* @async

* @param {Array} filesToAdd

* @param {Signature} author

* @param {Signature} committer

* @param {String} message

* @return {Oid} The oid of the new commit

*/

Repository.prototype.createCommitOnHead = function(

filesToAdd,

author,

committer,

message,

callback) {

var repo = this;

return repo.refreshIndex()

.then(function(index) {

if (!filesToAdd) {

filesToAdd = [];

}

return filesToAdd

.reduce(function(lastFilePromise, filePath) {

return lastFilePromise

.then(function() {

return index.addByPath(filePath);

});

}, Promise.resolve())

.then(function() {

return index.write();

})

.then(function() {

return index.writeTree();

});

})

.then(function(treeOid) {

return repo.getHeadCommit()

.then(function(parent) {

if (parent !== null) { // To handle a fresh repo with no commits

parent = [parent];

}

return repo.createCommit(

"HEAD",

author,

committer,

message,

treeOid,

parent

);

});

}, callback);

};

/**

* Creates a new lightweight tag

*

* @async

* @param {String|Oid} String sha or Oid

* @param {String} name the name of the tag

* @return {Reference}

*/

Repository.prototype.createLightweightTag = function(oid, name, callback) {

var repository = this;

return Commit.lookup(repository, oid)

.then(function(commit) {

// Final argument is `force` which overwrites any previous tag

return Tag.createLightweight(repository, name, commit, 0);

})

.then(function() {

return Reference.lookup(repository, "refs/tags/" + name);

});

};

/**

* Instantiate a new revision walker for browsing the Repository"s history.

* See also `Commit.prototype.history()`

*

* @param {String|Oid} String sha or Oid

* @return {RevWalk}

*/

Repository.prototype.createRevWalk = function() {

return Revwalk.create(this);

};

/**

* Creates a new annotated tag

*

* @async

* @param {String|Oid} String sha or Oid

* @param {String} name the name of the tag

* @param {String} message the description that will be attached to the

* annotated tag

* @return {Tag}

*/

Repository.prototype.createTag = function(oid, name, message, callback) {

var repository = this;

var signature = repository.defaultSignature();

return Commit.lookup(repository, oid)

.then(function(commit) {

// Final argument is `force` which overwrites any previous tag

return Tag.create(repository, name, commit, signature, message, 0);

})

.then(function(tagOid) {

return repository.getTag(tagOid, callback);

});

};

/**

* Gets the default signature for the default user and now timestamp

* @return {Signature}

*/

Repository.prototype.defaultSignature = function() {

var result = NodeGit.Signature.default(this);

if (!result || !result.name()) {

result = NodeGit.Signature.now("unknown", "unknown@example.com");

}

return result;

};

/**

* Deletes a tag from a repository by the tag name.

*

* @async

* @param {String} Short or full tag name

*/

Repository.prototype.deleteTagByName = function(name) {

var repository = this;

name = ~name.indexOf("refs/tags/") ? name.substr(10) : name;

return Tag.delete(repository, name);

};

/**

* Discard line selection of a specified file.

* Assumes selected lines are unstaged.

*

* @async

* @param {String} filePath The relative path of this file in the repo

* @param {Array} selectedLines The array of DiffLine objects

* selected for discarding

* @return {Number} 0 or an error code

*/

Repository.prototype.discardLines =

function(filePath, selectedLines, additionalDiffOptions) {

var repo = this;

var fullFilePath = path.join(repo.workdir(), filePath);

var index;

var originalContent;

var filterList;

return repo.refreshIndex()

.then(function(indexResult) {

index = indexResult;

return FilterList.load(

repo,

null,

filePath,

Filter.MODE.CLEAN,

Filter.FLAG.DEFAULT

);

})

.then(function(_filterList) {

filterList = _filterList;

if (filterList) {

return filterList.applyToFile(repo, filePath);

}

return fse.readFile(fullFilePath, "utf8");

})

.then(function(content) {

originalContent = content;

return getPathHunks(repo, index, filePath, false, additionalDiffOptions);

})

.then(function(hunks) {

return applySelectedLinesToTarget(

originalContent, selectedLines, hunks, false, true

);

})

.then(function(newContent) {

return FilterList.load(

repo,

null,

filePath,

Filter.MODE.SMUDGE,

Filter.FLAG.DEFAULT

)

.then(function(_filterList) {

filterList = _filterList;

if (filterList) {

/* jshint ignore:start */

// We need the constructor for the check in NodeGit's C++ layer

// to accept an object, and this seems to be a nice way to do it

return filterList.applyToData(new String(newContent));

/* jshint ignore:end */

}

return newContent;

});

})

.then(function(filteredContent) {

return fse.writeFile(fullFilePath, filteredContent);

});

};

/**

* Fetches from a remote

*

* @async

* @param {String|Remote} remote

* @param {Object|FetchOptions} fetchOptions Options for the fetch, includes

* callbacks for fetching

*/

Repository.prototype.fetch = function(

remote,

fetchOptions,

callback)

{

var repo = this;

function finallyFn(error) {

if (typeof callback === "function") {

callback(error);

}

}

return repo.getRemote(remote)

.then(function(remote) {

return remote.fetch(null, fetchOptions, "Fetch from " + remote)

.then(function() {

return remote.disconnect();

});

})

.then(finallyFn)

.catch(function(error) {

finallyFn(error);

throw error;

});

};

/**

* Fetches from all remotes. This is done in series due to deadlocking issues

* with fetching from many remotes that can happen.

*

* @async

* @param {Object|FetchOptions} fetchOptions Options for the fetch, includes

* callbacks for fetching

* @param {Function} callback

*/

Repository.prototype.fetchAll = function(

fetchOptions,

callback)

{

var repo = this;

function createCallbackWrapper(fn, remote) {

return function() {

var args = Array.prototype.slice.call(arguments);

args.push(remote);

return fn.apply(this, args);

}.bind(this);

}

fetchOptions = fetchOptions || {};

var remoteCallbacks = fetchOptions.callbacks || {};

var credentials = remoteCallbacks.credentials;

var certificateCheck = remoteCallbacks.certificateCheck;

var transferProgress = remoteCallbacks.transferProgress;

return repo.getRemotes()

.then(function(remotes) {

return remotes.reduce(function(fetchPromise, remote) {

var wrappedFetchOptions = shallowClone(fetchOptions);

var wrappedRemoteCallbacks = shallowClone(remoteCallbacks);

if (credentials) {

wrappedRemoteCallbacks.credentials =

createCallbackWrapper(credentials, remote);

}

if (certificateCheck) {

wrappedRemoteCallbacks.certificateCheck =

createCallbackWrapper(certificateCheck, remote);

}

if (transferProgress) {

wrappedRemoteCallbacks.transferProgress =

createCallbackWrapper(transferProgress, remote);

}

wrappedFetchOptions.callbacks = wrappedRemoteCallbacks;

return fetchPromise.then(function() {

return repo.fetch(remote, wrappedFetchOptions);

});

}, Promise.resolve());

})

.then(function() {

if (typeof callback === "function") {

callback();

}

});

};

/**

* @async

* @param {FetchheadForeachCb} callback The callback function to be called on

* each entry

*/

Repository.prototype.fetchheadForeach = function(callback) {

return _fetchheadForeach.call(this, callback, null);

};

/**

* Retrieve the blob represented by the oid.

*

* @async

* @param {String|Oid} String sha or Oid

* @return {Blob}

*/

Repository.prototype.getBlob = function(oid, callback) {

var repository = this;

return Blob.lookup(repository, oid).then(function(blob) {

blob.repo = repository;

if (typeof callback === "function") {

callback(null, blob);

}

return blob;

}, callback);

};

/**

* Look up a branch. Alias for `getReference`

*

* @async

* @param {String|Reference} name Ref name, e.g. "master", "refs/heads/master"

* or Branch Ref

* @return {Reference}

*/

Repository.prototype.getBranch = function(name, callback) {

return this.getReference(name, callback);

};

/**

* Look up a branch's most recent commit. Alias to `getReferenceCommit`

*

* @async

* @param {String|Reference} name Ref name, e.g. "master", "refs/heads/master"

* or Branch Ref

* @return {Commit}

*/

Repository.prototype.getBranchCommit = function(name, callback) {

return this.getReferenceCommit(name, callback);

};

/**

* Retrieve the commit identified by oid.

*

* @async

* @param {String|Oid} String sha or Oid

* @return {Commit}