public static void ReportStashResult(IProgressMonitor monitor, MergeCommandResult result)
{
if (result.GetMergeStatus() == NGit.Api.MergeStatus.FAILED)
{
string msg = GettextCatalog.GetString("Stash operation failed.");
DispatchService.GuiDispatch(delegate {
IdeApp.Workbench.StatusBar.ShowWarning(msg);
});
string txt = msg + "\n\n" + GetMergeResultErrorDetail(result);
monitor.ReportError(txt, null);
}
else if (result.GetMergeStatus() == NGit.Api.MergeStatus.NOT_SUPPORTED)
{
string msg = GettextCatalog.GetString("Operation not supported");
monitor.ReportError(msg, null);
DispatchService.GuiDispatch(delegate {
IdeApp.Workbench.StatusBar.ShowWarning(msg);
});
}
else if (result.GetMergeStatus() == NGit.Api.MergeStatus.CONFLICTING)
{
string msg = GettextCatalog.GetString("Stash applied with conflicts");
DispatchService.GuiDispatch(delegate {
IdeApp.Workbench.StatusBar.ShowWarning(msg);
});
}
else
{
string msg = GettextCatalog.GetString("Stash successfully applied");
DispatchService.GuiDispatch(delegate {
IdeApp.Workbench.StatusBar.ShowMessage(msg);
});
}
}
internal PullResult(FetchResult fetchResult, string fetchedFrom, MergeCommandResult
mergeResult)
{
this.fetchResult = fetchResult;
this.fetchedFrom = fetchedFrom;
this.mergeResult = mergeResult;
}
internal static string GetMergeResultErrorDetail(MergeCommandResult result)
{
string msg = "";
if (result.GetFailingPaths() != null)
{
foreach (var f in result.GetFailingPaths())
{
if (msg.Length > 0)
{
msg += "\n";
}
switch (f.Value)
{
case NGit.Merge.ResolveMerger.MergeFailureReason.DIRTY_WORKTREE:
msg += GettextCatalog.GetString("The file '{0}' has unstaged changes", f.Key);
break;
case NGit.Merge.ResolveMerger.MergeFailureReason.DIRTY_INDEX:
msg += GettextCatalog.GetString("The file '{0}' has staged changes", f.Key);
break;
case NGit.Merge.ResolveMerger.MergeFailureReason.COULD_NOT_DELETE:
msg += GettextCatalog.GetString("The file '{0}' could not be deleted", f.Key);
break;
}
}
}
return(msg);
}
public virtual void CheckMergeConflictingNewTrees(MergeStrategy strategy)
{
Git git = Git.Wrap(db);
WriteTrashFile("2", "orig");
git.Add().AddFilepattern("2").Call();
RevCommit first = git.Commit().SetMessage("added 2").Call();
WriteTrashFile("d/1", "master");
git.Add().AddFilepattern("d/1").Call();
RevCommit masterCommit = git.Commit().SetAll(true).SetMessage("added d/1 on master"
).Call();
git.Checkout().SetCreateBranch(true).SetStartPoint(first).SetName("side").Call();
WriteTrashFile("d/1", "side");
git.Add().AddFilepattern("d/1").Call();
git.Commit().SetAll(true).SetMessage("added d/1 on side").Call();
git.Rm().AddFilepattern("d/1").Call();
git.Rm().AddFilepattern("d").Call();
MergeCommandResult mergeRes = git.Merge().SetStrategy(strategy).Include(masterCommit
).Call();
NUnit.Framework.Assert.AreEqual(MergeStatus.CONFLICTING, mergeRes.GetMergeStatus(
));
NUnit.Framework.Assert.AreEqual("[2, mode:100644, content:orig][d/1, mode:100644, stage:2, content:side][d/1, mode:100644, stage:3, content:master]"
, IndexState(CONTENT));
}
public virtual void TestConflictingFromMultipleCreations()
{
Git git = new Git(db);
WriteTrashFile("a", "1\na\n3\n");
git.Add().AddFilepattern("a").Call();
RevCommit initialCommit = git.Commit().SetMessage("initial").Call();
CreateBranch(initialCommit, "refs/heads/side");
CheckoutBranch("refs/heads/side");
WriteTrashFile("b", "1\nb(side)\n3\n");
git.Add().AddFilepattern("b").Call();
RevCommit secondCommit = git.Commit().SetMessage("side").Call();
CheckoutBranch("refs/heads/master");
WriteTrashFile("b", "1\nb(main)\n3\n");
git.Add().AddFilepattern("b").Call();
git.Commit().SetMessage("main").Call();
MergeCommandResult result = git.Merge().Include(secondCommit.Id).SetStrategy(MergeStrategy
.RESOLVE).Call();
NUnit.Framework.Assert.AreEqual(MergeStatus.CONFLICTING, result.GetMergeStatus());
FileTreeIterator iterator = new FileTreeIterator(db);
IndexDiff diff = new IndexDiff(db, Constants.HEAD, iterator);
diff.Diff();
NUnit.Framework.Assert.AreEqual("[]", new TreeSet <string>(diff.GetChanged()).ToString
());
NUnit.Framework.Assert.AreEqual("[]", diff.GetAdded().ToString());
NUnit.Framework.Assert.AreEqual("[]", diff.GetRemoved().ToString());
NUnit.Framework.Assert.AreEqual("[]", diff.GetMissing().ToString());
NUnit.Framework.Assert.AreEqual("[]", diff.GetModified().ToString());
NUnit.Framework.Assert.AreEqual("[b]", diff.GetConflicting().ToString());
}
internal PullResult(FetchResult fetchResult, string fetchedFrom, RebaseResult rebaseResult
)
{
this.fetchResult = fetchResult;
this.fetchedFrom = fetchedFrom;
this.mergeResult = null;
this.rebaseResult = rebaseResult;
}
public MergeCommandResult Pop()
{
List <Stash> stashes = ReadStashes();
Stash last = stashes.Last();
MergeCommandResult res = last.Apply();
Remove(stashes, last);
return(res);
}
public MergeCommandResult Pop(ProgressMonitor monitor)
{
List <Stash> stashes = ReadStashes();
Stash last = stashes.Last();
MergeCommandResult res = last.Apply(monitor);
if (res.GetMergeStatus() != MergeStatus.FAILED && res.GetMergeStatus() != MergeStatus.NOT_SUPPORTED)
{
Remove(stashes, last);
}
return(res);
}
internal MergeCommandResult Apply(ProgressMonitor monitor, Stash stash)
{
monitor.Start(1);
monitor.BeginTask("Applying stash", 100);
ObjectId cid = _repo.Resolve(stash.CommitId);
RevWalk rw = new RevWalk(_repo);
RevCommit wip = rw.ParseCommit(cid);
RevCommit oldHead = wip.Parents.First();
rw.ParseHeaders(oldHead);
MergeCommandResult res = GitUtil.MergeTrees(monitor, _repo, oldHead, wip, "Stash", false);
monitor.EndTask();
return(res);
}
public virtual void TestConflicting()
{
Git git = new Git(db);
WriteTrashFile("a", "1\na\n3\n");
WriteTrashFile("b", "1\nb\n3\n");
git.Add().AddFilepattern("a").AddFilepattern("b").Call();
RevCommit initialCommit = git.Commit().SetMessage("initial").Call();
// create side branch with two modifications
CreateBranch(initialCommit, "refs/heads/side");
CheckoutBranch("refs/heads/side");
WriteTrashFile("a", "1\na(side)\n3\n");
WriteTrashFile("b", "1\nb\n3\n(side)");
git.Add().AddFilepattern("a").AddFilepattern("b").Call();
RevCommit secondCommit = git.Commit().SetMessage("side").Call();
// update a on master to generate conflict
CheckoutBranch("refs/heads/master");
WriteTrashFile("a", "1\na(main)\n3\n");
git.Add().AddFilepattern("a").Call();
git.Commit().SetMessage("main").Call();
// merge side with master
MergeCommandResult result = git.Merge().Include(secondCommit.Id).SetStrategy(MergeStrategy
.RESOLVE).Call();
NUnit.Framework.Assert.AreEqual(MergeStatus.CONFLICTING, result.GetMergeStatus());
FileTreeIterator iterator = new FileTreeIterator(db);
IndexDiff diff = new IndexDiff(db, Constants.HEAD, iterator);
diff.Diff();
NUnit.Framework.CollectionAssert.AreEqual("[b]", new TreeSet <string>(diff.GetChanged()).ToString
());
NUnit.Framework.CollectionAssert.IsEmpty(diff.GetAdded());
NUnit.Framework.CollectionAssert.IsEmpty(diff.GetRemoved());
NUnit.Framework.CollectionAssert.IsEmpty(diff.GetMissing());
NUnit.Framework.CollectionAssert.IsEmpty(diff.GetModified());
NUnit.Framework.Assert.AreEqual("a", diff.GetConflicting().First());
NUnit.Framework.Assert.AreEqual(1, diff.GetConflicting().Count());
NUnit.Framework.CollectionAssert.IsEmpty(diff.GetUntrackedFolders());
}
public virtual void CheckLockedFilesToBeDeleted(MergeStrategy strategy)
{
Git git = Git.Wrap(db);
WriteTrashFile("a.txt", "orig");
WriteTrashFile("b.txt", "orig");
git.Add().AddFilepattern("a.txt").AddFilepattern("b.txt").Call();
RevCommit first = git.Commit().SetMessage("added a.txt, b.txt").Call();
// modify and delete files on the master branch
WriteTrashFile("a.txt", "master");
git.Rm().AddFilepattern("b.txt").Call();
RevCommit masterCommit = git.Commit().SetMessage("modified a.txt, deleted b.txt")
.SetAll(true).Call();
// switch back to a side branch
git.Checkout().SetCreateBranch(true).SetStartPoint(first).SetName("side").Call();
WriteTrashFile("c.txt", "side");
git.Add().AddFilepattern("c.txt").Call();
git.Commit().SetMessage("added c.txt").Call();
// Get a handle to the the file so on windows it can't be deleted.
FileInputStream fis = new FileInputStream(new FilePath(db.WorkTree, "b.txt"));
MergeCommandResult mergeRes = git.Merge().SetStrategy(strategy).Include(masterCommit
).Call();
if (mergeRes.GetMergeStatus().Equals(MergeStatus.FAILED))
{
// probably windows
NUnit.Framework.Assert.AreEqual(1, mergeRes.GetFailingPaths().Count);
NUnit.Framework.Assert.AreEqual(ResolveMerger.MergeFailureReason.COULD_NOT_DELETE
, mergeRes.GetFailingPaths().Get("b.txt"));
}
NUnit.Framework.Assert.AreEqual("[a.txt, mode:100644, content:master]" + "[c.txt, mode:100644, content:side]"
, IndexState(CONTENT));
fis.Close();
}
public virtual void CheckMergeConflictingFilesWithTreeInIndex(MergeStrategy strategy
)
{
Git git = Git.Wrap(db);
WriteTrashFile("0", "orig");
git.Add().AddFilepattern("0").Call();
RevCommit first = git.Commit().SetMessage("added 0").Call();
WriteTrashFile("0", "master");
RevCommit masterCommit = git.Commit().SetAll(true).SetMessage("modified 0 on master"
).Call();
git.Checkout().SetCreateBranch(true).SetStartPoint(first).SetName("side").Call();
WriteTrashFile("0", "side");
git.Commit().SetAll(true).SetMessage("modified 0 on side").Call();
git.Rm().AddFilepattern("0").Call();
WriteTrashFile("0/0", "side");
git.Add().AddFilepattern("0/0").Call();
MergeCommandResult mergeRes = git.Merge().SetStrategy(strategy).Include(masterCommit
).Call();
NUnit.Framework.Assert.AreEqual(MergeStatus.FAILED, mergeRes.GetMergeStatus());
}
public virtual void CheckMergeEqualTreesWithoutIndex(MergeStrategy strategy)
{
Git git = Git.Wrap(db);
WriteTrashFile("d/1", "orig");
git.Add().AddFilepattern("d/1").Call();
RevCommit first = git.Commit().SetMessage("added d/1").Call();
WriteTrashFile("d/1", "modified");
RevCommit masterCommit = git.Commit().SetAll(true).SetMessage("modified d/1 on master"
).Call();
git.Checkout().SetCreateBranch(true).SetStartPoint(first).SetName("side").Call();
WriteTrashFile("d/1", "modified");
git.Commit().SetAll(true).SetMessage("modified d/1 on side").Call();
git.Rm().AddFilepattern("d/1").Call();
git.Rm().AddFilepattern("d").Call();
MergeCommandResult mergeRes = git.Merge().SetStrategy(strategy).Include(masterCommit
).Call();
NUnit.Framework.Assert.AreEqual(MergeStatus.MERGED, mergeRes.GetMergeStatus());
NUnit.Framework.Assert.AreEqual("[d/1, mode:100644, content:modified]", IndexState
(CONTENT));
}
protected void RaiseMergeResults(RepositoryEntry repositoryEntry, MergeCommandResult mergeResults)
{
Debug.Assert(Args is IGitConflictsClientArgs, "Merge results may only be reported on Args that implement IGitConflictsClientArgs");
// We ignore the merge results for getting a list of conflicts.
// Instead, we go to the index directly.
var conflicts = new HashSet<string>(FileSystemUtil.StringComparer);
using (repositoryEntry.Lock())
{
var repository = repositoryEntry.Repository;
var dirCache = repository.ReadDirCache();
for (int i = 0, count = dirCache.GetEntryCount(); i < count; i++)
{
var entry = dirCache.GetEntry(i);
if (entry.Stage > 0)
{
string path = entry.PathString;
if (!conflicts.Contains(path))
conflicts.Add(path);
}
}
}
if (conflicts.Count == 0)
return;
foreach (var item in conflicts)
{
string fullPath = repositoryEntry.Repository.GetAbsoluteRepositoryPath(item);
var args = new GitConflictEventArgs
{
MergedFile = fullPath,
Path = item,
ConflictReason = GitConflictReason.Edited
};
try
{
Args.OnConflict(args);
if (args.Cancel)
return;
if (args.Choice == GitAccept.Postpone)
continue;
Client.Resolve(args.MergedFile, args.Choice, new GitResolveArgs
{
ConflictArgs = args
});
}
finally
{
args.Cleanup();
}
}
}
/// <exception cref="System.Exception"></exception>
private void CheckMergeFailedResult(MergeCommandResult result, ResolveMerger.MergeFailureReason
reason, string indexState, FilePath fileA)
{
NUnit.Framework.Assert.AreEqual(MergeStatus.FAILED, result.GetMergeStatus());
NUnit.Framework.Assert.AreEqual(reason, result.GetFailingPaths().Get("a"));
NUnit.Framework.Assert.AreEqual("a(modified)", Read(fileA));
NUnit.Framework.Assert.IsFalse(new FilePath(db.WorkTree, "b").Exists());
NUnit.Framework.Assert.AreEqual("c", Read(new FilePath(db.WorkTree, "c")));
NUnit.Framework.Assert.AreEqual(indexState, IndexState(CONTENT));
NUnit.Framework.Assert.AreEqual(null, result.GetConflicts());
NUnit.Framework.Assert.AreEqual(RepositoryState.SAFE, db.GetRepositoryState());
}
internal static string GetMergeResultErrorDetail (MergeCommandResult result)
{
string msg = "";
if (result.GetFailingPaths () != null) {
foreach (var f in result.GetFailingPaths ()) {
if (msg.Length > 0)
msg += "\n";
switch (f.Value) {
case NGit.Merge.ResolveMerger.MergeFailureReason.DIRTY_WORKTREE: msg += GettextCatalog.GetString ("The file '{0}' has unstaged changes", f.Key); break;
case NGit.Merge.ResolveMerger.MergeFailureReason.DIRTY_INDEX: msg += GettextCatalog.GetString ("The file '{0}' has staged changes", f.Key); break;
case NGit.Merge.ResolveMerger.MergeFailureReason.COULD_NOT_DELETE: msg += GettextCatalog.GetString ("The file '{0}' could not be deleted", f.Key); break;
}
}
}
return msg;
}
public static void ReportStashResult (IProgressMonitor monitor, MergeCommandResult result)
{
if (result.GetMergeStatus () == NGit.Api.MergeStatus.FAILED) {
string msg = GettextCatalog.GetString ("Stash operation failed.");
DispatchService.GuiDispatch (delegate {
IdeApp.Workbench.StatusBar.ShowWarning (msg);
});
string txt = msg + "\n\n" + GetMergeResultErrorDetail (result);
monitor.ReportError (txt, null);
}
else if (result.GetMergeStatus () == NGit.Api.MergeStatus.NOT_SUPPORTED) {
string msg = GettextCatalog.GetString ("Operation not supported");
monitor.ReportError (msg, null);
DispatchService.GuiDispatch (delegate {
IdeApp.Workbench.StatusBar.ShowWarning (msg);
});
}
else if (result.GetMergeStatus () == NGit.Api.MergeStatus.CONFLICTING) {
string msg = GettextCatalog.GetString ("Stash applied with conflicts");
DispatchService.GuiDispatch (delegate {
IdeApp.Workbench.StatusBar.ShowWarning (msg);
});
}
else {
string msg = GettextCatalog.GetString ("Stash successfully applied");
DispatchService.GuiDispatch (delegate {
IdeApp.Workbench.StatusBar.ShowMessage (msg);
});
}
}
public bool Rebase ()
{
NGit.Api.Git git = new NGit.Api.Git (repo);
if (aborted)
return false;
if (starting) {
ObjectId headId = repo.Resolve (Constants.HEAD + "^{commit}");
RevCommit headCommit = rw.ParseCommit (headId);
oldHead = headCommit;
ObjectId upstreamId = repo.Resolve (upstreamRef);
RevCommit upstreamCommit = rw.ParseCommit (upstreamId);
oldHead = headCommit;
lastGoodHead = upstreamId;
commitChain = new List<RevCommit> ();
LogCommand cmd = new NGit.Api.Git(repo).Log().AddRange(upstreamId, headCommit);
foreach (RevCommit commit in cmd.Call())
commitChain.Add(commit);
commitChain.Reverse ();
currentMergeIndex = 0;
// Checkout the upstream commit
// Reset head to upstream
GitUtil.HardReset (repo, upstreamRef);
string rebaseDir = Path.Combine (repo.Directory, "rebase-apply");
if (!Directory.Exists (rebaseDir))
Directory.CreateDirectory (rebaseDir);
string rebasingFile = Path.Combine (rebaseDir, "rebasing");
if (!File.Exists (rebasingFile))
File.WriteAllBytes (rebasingFile, new byte[0]);
starting = false;
monitor.BeginTask ("Applying local commits", commitChain.Count);
}
else {
// Conflicts resolved. Continue.
NGit.Api.AddCommand cmd = git.Add ();
var conflicts = LastMergeResult.GetConflicts ();
foreach (string conflictFile in conflicts.Keys) {
cmd.AddFilepattern (conflictFile);
}
cmd.Call ();
NGit.Api.CommitCommand commit = git.Commit ();
commit.SetMessage (currentMergeCommit.GetFullMessage ());
commit.SetAuthor (currentMergeCommit.GetAuthorIdent ());
commit.SetCommitter (currentMergeCommit.GetCommitterIdent ());
commit.Call();
}
// Merge commit by commit until the current head
while (currentMergeIndex < commitChain.Count) {
currentMergeCommit = commitChain[currentMergeIndex++];
mergeResult = GitUtil.CherryPick (repo, currentMergeCommit);
monitor.Log.WriteLine ("Applied '{0}'", currentMergeCommit.GetShortMessage ());
monitor.Step (1);
if (mergeResult.GetMergeStatus () == MergeStatus.CONFLICTING || mergeResult.GetMergeStatus () == MergeStatus.FAILED)
return false;
lastGoodHead = mergeResult.GetNewHead ();
}
monitor.EndTask ();
CleanRebaseFile ();
return true;
}
