public override void Checkout (FilePath targetLocalPath, Revision rev, bool recurse, IProgressMonitor monitor)
{
CloneCommand cmd = NGit.Api.Git.CloneRepository ();
cmd.SetURI (Url);
cmd.SetRemote ("origin");
cmd.SetBranch ("refs/heads/master");
cmd.SetDirectory ((string)targetLocalPath);
using (var gm = new GitMonitor (monitor, 4)) {
cmd.SetProgressMonitor (gm);
cmd.Call ();
}
}
public void Rebase (string upstreamRef, bool saveLocalChanges, IProgressMonitor monitor)
{
StashCollection stashes = GitUtil.GetStashes (RootRepository);
Stash stash = null;
try
{
if (saveLocalChanges) {
monitor.BeginTask (GettextCatalog.GetString ("Rebasing"), 3);
monitor.Log.WriteLine (GettextCatalog.GetString ("Saving local changes"));
using (var gm = new GitMonitor (monitor))
stash = stashes.Create (gm, GetStashName ("_tmp_"));
monitor.Step (1);
}
NGit.Api.Git git = new NGit.Api.Git (RootRepository);
RebaseCommand rebase = git.Rebase ();
rebase.SetOperation (RebaseCommand.Operation.BEGIN);
rebase.SetUpstream (upstreamRef);
var gmonitor = new GitMonitor (monitor);
rebase.SetProgressMonitor (gmonitor);
bool aborted = false;
try {
var result = rebase.Call ();
while (!aborted && result.GetStatus () == RebaseResult.Status.STOPPED) {
rebase = git.Rebase ();
rebase.SetProgressMonitor (gmonitor);
rebase.SetOperation (RebaseCommand.Operation.CONTINUE);
bool commitChanges = true;
var conflicts = GitUtil.GetConflictedFiles (RootRepository);
foreach (string conflictFile in conflicts) {
ConflictResult res = ResolveConflict (RootRepository.FromGitPath (conflictFile));
if (res == ConflictResult.Abort) {
aborted = true;
commitChanges = false;
rebase.SetOperation (RebaseCommand.Operation.ABORT);
break;
} else if (res == ConflictResult.Skip) {
rebase.SetOperation (RebaseCommand.Operation.SKIP);
commitChanges = false;
break;
}
}
if (commitChanges) {
NGit.Api.AddCommand cmd = git.Add ();
foreach (string conflictFile in conflicts)
cmd.AddFilepattern (conflictFile);
cmd.Call ();
}
result = rebase.Call ();
}
} catch {
if (!aborted) {
rebase = git.Rebase ();
rebase.SetOperation (RebaseCommand.Operation.ABORT);
rebase.SetProgressMonitor (gmonitor);
rebase.Call ();
}
throw;
} finally {
gmonitor.Dispose ();
}
} finally {
if (saveLocalChanges)
monitor.Step (1);
// Restore local changes
if (stash != null) {
monitor.Log.WriteLine (GettextCatalog.GetString ("Restoring local changes"));
using (var gm = new GitMonitor (monitor))
stash.Apply (gm);
stashes.Remove (stash);
monitor.EndTask ();
}
}
}
public void Merge (string branch, bool saveLocalChanges, IProgressMonitor monitor)
{
IEnumerable<DiffEntry> statusList = null;
Stash stash = null;
StashCollection stashes = GetStashes (RootRepository);
monitor.BeginTask (null, 4);
try {
// Get a list of files that are different in the target branch
statusList = GitUtil.GetChangedFiles (RootRepository, branch);
monitor.Step (1);
if (saveLocalChanges) {
monitor.BeginTask (GettextCatalog.GetString ("Merging"), 3);
monitor.Log.WriteLine (GettextCatalog.GetString ("Saving local changes"));
using (var gm = new GitMonitor (monitor))
stash = stashes.Create (gm, GetStashName ("_tmp_"));
monitor.Step (1);
}
// Apply changes
ObjectId branchId = RootRepository.Resolve (branch);
NGit.Api.Git git = new NGit.Api.Git (RootRepository);
MergeCommandResult mergeResult = git.Merge ().SetStrategy (MergeStrategy.RESOLVE).Include (branchId).Call ();
if (mergeResult.GetMergeStatus () == MergeStatus.CONFLICTING || mergeResult.GetMergeStatus () == MergeStatus.FAILED) {
var conflicts = mergeResult.GetConflicts ();
bool commit = true;
if (conflicts != null) {
foreach (string conflictFile in conflicts.Keys) {
ConflictResult res = ResolveConflict (RootRepository.FromGitPath (conflictFile));
if (res == ConflictResult.Abort) {
GitUtil.HardReset (RootRepository, GetHeadCommit (RootRepository));
commit = false;
break;
} else if (res == ConflictResult.Skip) {
Revert (RootRepository.FromGitPath (conflictFile), false, monitor);
break;
}
}
}
if (commit)
git.Commit ().Call ();
}
} finally {
if (saveLocalChanges)
monitor.Step (1);
// Restore local changes
if (stash != null) {
monitor.Log.WriteLine (GettextCatalog.GetString ("Restoring local changes"));
using (var gm = new GitMonitor (monitor))
stash.Apply (gm);
stashes.Remove (stash);
monitor.EndTask ();
}
}
monitor.Step (1);
// Notify changes
if (statusList != null)
NotifyFileChanges (monitor, statusList);
monitor.EndTask ();
}
public void SwitchToBranch (IProgressMonitor monitor, string branch)
{
monitor.BeginTask (GettextCatalog.GetString ("Switching to branch {0}", branch), GitService.StashUnstashWhenSwitchingBranches ? 4 : 2);
// Get a list of files that are different in the target branch
IEnumerable<DiffEntry> statusList = GitUtil.GetChangedFiles (RootRepository, branch);
StashCollection stashes = null;
Stash stash = null;
if (GitService.StashUnstashWhenSwitchingBranches) {
stashes = GitUtil.GetStashes (RootRepository);
// Remove the stash for this branch, if exists
string currentBranch = GetCurrentBranch ();
stash = GetStashForBranch (stashes, currentBranch);
if (stash != null)
stashes.Remove (stash);
// Create a new stash for the branch. This allows switching branches
// without losing local changes
using (var gm = new GitMonitor (monitor))
stash = stashes.Create (gm, GetStashName (currentBranch));
monitor.Step (1);
}
// Switch to the target branch
DirCache dc = RootRepository.LockDirCache ();
try {
RevWalk rw = new RevWalk (RootRepository);
ObjectId branchHeadId = RootRepository.Resolve (branch);
if (branchHeadId == null)
throw new InvalidOperationException ("Branch head commit not found");
RevCommit branchCommit = rw.ParseCommit (branchHeadId);
DirCacheCheckout checkout = new DirCacheCheckout (RootRepository, null, dc, branchCommit.Tree);
checkout.Checkout ();
RefUpdate u = RootRepository.UpdateRef(Constants.HEAD);
u.Link ("refs/heads/" + branch);
monitor.Step (1);
} catch {
dc.Unlock ();
if (GitService.StashUnstashWhenSwitchingBranches) {
// If something goes wrong, restore the work tree status
using (var gm = new GitMonitor (monitor))
stash.Apply (gm);
stashes.Remove (stash);
}
throw;
}
// Restore the branch stash
if (GitService.StashUnstashWhenSwitchingBranches) {
stash = GetStashForBranch (stashes, branch);
if (stash != null) {
using (var gm = new GitMonitor (monitor))
stash.Apply (gm);
stashes.Remove (stash);
}
monitor.Step (1);
}
// Notify file changes
NotifyFileChanges (monitor, statusList);
if (BranchSelectionChanged != null)
BranchSelectionChanged (this, EventArgs.Empty);
monitor.EndTask ();
}
public override void Update (FilePath[] localPaths, bool recurse, IProgressMonitor monitor)
{
IEnumerable<DiffEntry> statusList = null;
monitor.BeginTask (GettextCatalog.GetString ("Updating"), 5);
// Fetch remote commits
string remote = GetCurrentRemote ();
if (remote == null)
throw new InvalidOperationException ("No remotes defined");
monitor.Log.WriteLine (GettextCatalog.GetString ("Fetching from '{0}'", remote));
RemoteConfig remoteConfig = new RemoteConfig (RootRepository.GetConfig (), remote);
Transport tn = Transport.Open (RootRepository, remoteConfig);
using (var gm = new GitMonitor (monitor))
tn.Fetch (gm, null);
monitor.Step (1);
string upstreamRef = GitUtil.GetUpstreamSource (RootRepository, GetCurrentBranch ());
if (upstreamRef == null)
upstreamRef = GetCurrentRemote () + "/" + GetCurrentBranch ();
if (GitService.UseRebaseOptionWhenPulling)
Rebase (upstreamRef, GitService.StashUnstashWhenUpdating, monitor);
else
Merge (upstreamRef, GitService.StashUnstashWhenUpdating, monitor);
monitor.Step (1);
// Notify changes
if (statusList != null)
NotifyFileChanges (monitor, statusList);
monitor.EndTask ();
}
public static IAsyncOperation ApplyStash (Stash s)
{
MessageDialogProgressMonitor monitor = new MessageDialogProgressMonitor (true, false, false, true);
var statusTracker = IdeApp.Workspace.GetFileStatusTracker ();
ThreadPool.QueueUserWorkItem (delegate {
try {
NGit.Api.MergeCommandResult result;
using (var gm = new GitMonitor (monitor))
result = s.Apply (gm);
ReportStashResult (monitor, result);
} catch (Exception ex) {
string msg = GettextCatalog.GetString ("Stash operation failed.");
monitor.ReportError (msg, ex);
}
finally {
monitor.Dispose ();
statusTracker.NotifyChanges ();
}
});
return monitor.AsyncOperation;
}
public void Push (IProgressMonitor monitor, string remote, string remoteBranch)
{
RemoteConfig remoteConfig = new RemoteConfig (RootRepository.GetConfig (), remote);
Transport tp = Transport.Open (RootRepository, remoteConfig);
string remoteRef = "refs/heads/" + remoteBranch;
RemoteRefUpdate rr = new RemoteRefUpdate (RootRepository, RootRepository.GetBranch (), remoteRef, false, null, null);
List<RemoteRefUpdate> list = new List<RemoteRefUpdate> ();
list.Add (rr);
using (var gm = new GitMonitor (monitor))
tp.Push (gm, list);
switch (rr.GetStatus ()) {
case RemoteRefUpdate.Status.UP_TO_DATE: monitor.ReportSuccess (GettextCatalog.GetString ("Remote branch is up to date.")); break;
case RemoteRefUpdate.Status.REJECTED_NODELETE: monitor.ReportError (GettextCatalog.GetString ("The server is configured to deny deletion of the branch"), null); break;
case RemoteRefUpdate.Status.REJECTED_NONFASTFORWARD: monitor.ReportError (GettextCatalog.GetString ("The update is a non-fast-forward update. Merge the remote changes before pushing again."), null); break;
case RemoteRefUpdate.Status.OK:
monitor.ReportSuccess (GettextCatalog.GetString ("Push operation successfully completed."));
// Update the remote branch
ObjectId headId = rr.GetNewObjectId ();
RefUpdate updateRef = RootRepository.UpdateRef (Constants.R_REMOTES + remote + "/" + remoteBranch);
updateRef.SetNewObjectId(headId);
updateRef.Update();
break;
default:
string msg = rr.GetMessage ();
msg = !string.IsNullOrEmpty (msg) ? msg : GettextCatalog.GetString ("Push operation failed");
monitor.ReportError (msg, null);
break;
}
}
public void Rebase (string upstreamRef, GitUpdateOptions options, IProgressMonitor monitor)
{
StashCollection stashes = GitUtil.GetStashes (RootRepository);
Stash stash = null;
NGit.Api.Git git = new NGit.Api.Git (RootRepository);
try
{
monitor.BeginTask (GettextCatalog.GetString ("Rebasing"), 5);
List<string> UpdateSubmodules = new List<string> ();
// TODO: Fix stash so we don't have to do update before the main repo update.
if ((options & GitUpdateOptions.UpdateSubmodules) == GitUpdateOptions.UpdateSubmodules) {
monitor.Log.WriteLine (GettextCatalog.GetString ("Checking repository submodules"));
if (!GetSubmodulesToUpdate (UpdateSubmodules))
return;
monitor.Log.WriteLine (GettextCatalog.GetString ("Updating repository submodules"));
var submoduleUpdate = git.SubmoduleUpdate ();
foreach (var submodule in UpdateSubmodules)
submoduleUpdate.AddPath (submodule);
submoduleUpdate.Call ();
monitor.Step (1);
}
if ((options & GitUpdateOptions.SaveLocalChanges) != GitUpdateOptions.SaveLocalChanges) {
const VersionStatus unclean = VersionStatus.Modified | VersionStatus.ScheduledAdd | VersionStatus.ScheduledDelete;
bool modified = false;
if (GetDirectoryVersionInfo (RootPath, false, true).Any (v => (v.Status & unclean) != VersionStatus.Unversioned))
modified = true;
if (modified) {
if (MessageService.GenericAlert (
MonoDevelop.Ide.Gui.Stock.Question,
GettextCatalog.GetString ("You have uncommitted changes"),
GettextCatalog.GetString ("What do you want to do?"),
AlertButton.Cancel,
new AlertButton ("Stash")) == AlertButton.Cancel)
return;
options |= GitUpdateOptions.SaveLocalChanges;
}
}
if ((options & GitUpdateOptions.SaveLocalChanges) == GitUpdateOptions.SaveLocalChanges) {
monitor.Log.WriteLine (GettextCatalog.GetString ("Saving local changes"));
using (var gm = new GitMonitor (monitor))
stash = stashes.Create (gm, GetStashName ("_tmp_"));
monitor.Step (1);
}
RebaseCommand rebase = git.Rebase ();
rebase.SetOperation (RebaseCommand.Operation.BEGIN);
rebase.SetUpstream (upstreamRef);
var gmonitor = new GitMonitor (monitor);
rebase.SetProgressMonitor (gmonitor);
bool aborted = false;
try {
var result = rebase.Call ();
while (!aborted && result.GetStatus () == RebaseResult.Status.STOPPED) {
rebase = git.Rebase ();
rebase.SetProgressMonitor (gmonitor);
rebase.SetOperation (RebaseCommand.Operation.CONTINUE);
bool commitChanges = true;
var conflicts = GitUtil.GetConflictedFiles (RootRepository);
foreach (string conflictFile in conflicts) {
ConflictResult res = ResolveConflict (RootRepository.FromGitPath (conflictFile));
if (res == ConflictResult.Abort) {
aborted = true;
commitChanges = false;
rebase.SetOperation (RebaseCommand.Operation.ABORT);
break;
} else if (res == ConflictResult.Skip) {
rebase.SetOperation (RebaseCommand.Operation.SKIP);
commitChanges = false;
break;
}
}
if (commitChanges) {
NGit.Api.AddCommand cmd = git.Add ();
foreach (string conflictFile in conflicts)
cmd.AddFilepattern (conflictFile);
cmd.Call ();
}
result = rebase.Call ();
}
if ((options & GitUpdateOptions.UpdateSubmodules) == GitUpdateOptions.UpdateSubmodules) {
monitor.Log.WriteLine (GettextCatalog.GetString ("Updating repository submodules"));
var submoduleUpdate = git.SubmoduleUpdate ();
foreach (var submodule in UpdateSubmodules)
submoduleUpdate.AddPath (submodule);
submoduleUpdate.Call ();
}
} catch {
if (!aborted) {
rebase = git.Rebase ();
rebase.SetOperation (RebaseCommand.Operation.ABORT);
rebase.SetProgressMonitor (gmonitor);
rebase.Call ();
}
throw;
} finally {
gmonitor.Dispose ();
}
} finally {
if ((options & GitUpdateOptions.SaveLocalChanges) == GitUpdateOptions.SaveLocalChanges)
monitor.Step (1);
// Restore local changes
if (stash != null) {
monitor.Log.WriteLine (GettextCatalog.GetString ("Restoring local changes"));
using (var gm = new GitMonitor (monitor))
stash.Apply (gm);
stashes.Remove (stash);
}
monitor.EndTask ();
}
}
public void Merge (string branch, GitUpdateOptions options, IProgressMonitor monitor)
{
IEnumerable<DiffEntry> statusList = null;
Stash stash = null;
StashCollection stashes = GetStashes (RootRepository);
NGit.Api.Git git = new NGit.Api.Git (RootRepository);
try {
monitor.BeginTask (GettextCatalog.GetString ("Merging"), 5);
List<string> UpdateSubmodules = new List<string> ();
// TODO: Fix stash so we don't have to do update before the main repo update.
if ((options & GitUpdateOptions.UpdateSubmodules) == GitUpdateOptions.UpdateSubmodules) {
monitor.Log.WriteLine (GettextCatalog.GetString ("Checking repository submodules"));
if (!GetSubmodulesToUpdate (UpdateSubmodules))
return;
monitor.Log.WriteLine (GettextCatalog.GetString ("Updating repository submodules"));
var submoduleUpdate = git.SubmoduleUpdate ();
foreach (var submodule in UpdateSubmodules)
submoduleUpdate.AddPath (submodule);
submoduleUpdate.Call ();
monitor.Step (1);
}
// Get a list of files that are different in the target branch
statusList = GitUtil.GetChangedFiles (RootRepository, branch);
monitor.Step (1);
if ((options & GitUpdateOptions.SaveLocalChanges) != GitUpdateOptions.SaveLocalChanges) {
const VersionStatus unclean = VersionStatus.Modified | VersionStatus.ScheduledAdd | VersionStatus.ScheduledDelete;
bool modified = false;
if (GetDirectoryVersionInfo (RootPath, false, true).Any (v => (v.Status & unclean) != VersionStatus.Unversioned))
modified = true;
if (modified) {
if (MessageService.GenericAlert (
MonoDevelop.Ide.Gui.Stock.Question,
GettextCatalog.GetString ("You have uncommitted changes"),
GettextCatalog.GetString ("What do you want to do?"),
AlertButton.Cancel,
new AlertButton ("Stash")) == AlertButton.Cancel)
return;
options |= GitUpdateOptions.SaveLocalChanges;
}
}
if ((options & GitUpdateOptions.SaveLocalChanges) == GitUpdateOptions.SaveLocalChanges) {
monitor.Log.WriteLine (GettextCatalog.GetString ("Saving local changes"));
using (var gm = new GitMonitor (monitor))
stash = stashes.Create (gm, GetStashName ("_tmp_"));
monitor.Step (1);
}
// Apply changes
ObjectId branchId = RootRepository.Resolve (branch);
MergeCommandResult mergeResult = git.Merge ().SetStrategy (MergeStrategy.RESOLVE).Include (branchId).Call ();
if (mergeResult.GetMergeStatus () == MergeStatus.CONFLICTING || mergeResult.GetMergeStatus () == MergeStatus.FAILED) {
var conflicts = mergeResult.GetConflicts ();
bool commit = true;
if (conflicts != null) {
foreach (string conflictFile in conflicts.Keys) {
ConflictResult res = ResolveConflict (RootRepository.FromGitPath (conflictFile));
if (res == ConflictResult.Abort) {
GitUtil.HardReset (RootRepository, GetHeadCommit (RootRepository));
commit = false;
break;
} else if (res == ConflictResult.Skip) {
Revert (RootRepository.FromGitPath (conflictFile), false, monitor);
break;
}
}
}
if (commit)
git.Commit ().Call ();
}
if ((options & GitUpdateOptions.UpdateSubmodules) == GitUpdateOptions.UpdateSubmodules) {
monitor.Log.WriteLine (GettextCatalog.GetString ("Updating repository submodules"));
var submoduleUpdate = git.SubmoduleUpdate ();
foreach (var submodule in CachedSubmodules)
submoduleUpdate.AddPath (submodule.Item1);
submoduleUpdate.Call ();
monitor.Step (1);
}
} finally {
if ((options & GitUpdateOptions.SaveLocalChanges) == GitUpdateOptions.SaveLocalChanges)
monitor.Step (1);
// Restore local changes
if (stash != null) {
monitor.Log.WriteLine (GettextCatalog.GetString ("Restoring local changes"));
using (var gm = new GitMonitor (monitor))
stash.Apply (gm);
stashes.Remove (stash);
monitor.Step (1);
}
monitor.EndTask ();
}
// Notify changes
if (statusList != null)
NotifyFileChanges (monitor, statusList);
}
public void SwitchToBranch (IProgressMonitor monitor, string branch)
{
monitor.BeginTask (GettextCatalog.GetString ("Switching to branch {0}", branch), GitService.StashUnstashWhenSwitchingBranches ? 4 : 2);
// Get a list of files that are different in the target branch
IEnumerable<DiffEntry> statusList = GitUtil.GetChangedFiles (RootRepository, branch);
StashCollection stashes = null;
Stash stash = null;
if (GitService.StashUnstashWhenSwitchingBranches) {
stashes = GitUtil.GetStashes (RootRepository);
// Remove the stash for this branch, if exists
string currentBranch = GetCurrentBranch ();
stash = GetStashForBranch (stashes, currentBranch);
if (stash != null)
stashes.Remove (stash);
// Create a new stash for the branch. This allows switching branches
// without losing local changes
using (var gm = new GitMonitor (monitor))
stash = stashes.Create (gm, GetStashName (currentBranch));
monitor.Step (1);
}
// Replace with NGit.Api.Git ().Checkout ()
// Switch to the target branch
var checkout = new NGit.Api.Git (RootRepository).Checkout ();
checkout.SetName (branch);
try {
checkout.Call ();
} finally {
// Restore the branch stash
if (GitService.StashUnstashWhenSwitchingBranches) {
stash = GetStashForBranch (stashes, branch);
if (stash != null) {
using (var gm = new GitMonitor (monitor))
stash.Apply (gm);
stashes.Remove (stash);
}
monitor.Step (1);
}
}
// Notify file changes
NotifyFileChanges (monitor, statusList);
if (BranchSelectionChanged != null)
BranchSelectionChanged (this, EventArgs.Empty);
monitor.EndTask ();
}
public void Fetch (IProgressMonitor monitor)
{
string remote = GetCurrentRemote ();
if (remote == null)
throw new InvalidOperationException ("No remotes defined");
monitor.Log.WriteLine (GettextCatalog.GetString ("Fetching from '{0}'", remote));
var fetch = new NGit.Api.Git (RootRepository).Fetch ();
using (var gm = new GitMonitor (monitor)) {
fetch.SetRemote (remote);
fetch.SetProgressMonitor (gm);
fetch.Call ();
}
monitor.Step (1);
}
public void Push (IProgressMonitor monitor, string remote, string remoteBranch)
{
string remoteRef = "refs/heads/" + remoteBranch;
IEnumerable<PushResult> res;
var push = new NGit.Api.Git (RootRepository).Push ();
// We only have one pushed branch.
push.SetRemote (remote).SetRefSpecs (new RefSpec (remoteRef));
using (var gm = new GitMonitor (monitor)) {
push.SetProgressMonitor (gm);
res = push.Call ();
}
foreach (var pr in res) {
var remoteUpdate = pr.GetRemoteUpdate (remoteRef);
switch (remoteUpdate.GetStatus ()) {
case RemoteRefUpdate.Status.UP_TO_DATE: monitor.ReportSuccess (GettextCatalog.GetString ("Remote branch is up to date.")); break;
case RemoteRefUpdate.Status.REJECTED_NODELETE: monitor.ReportError (GettextCatalog.GetString ("The server is configured to deny deletion of the branch"), null); break;
case RemoteRefUpdate.Status.REJECTED_NONFASTFORWARD: monitor.ReportError (GettextCatalog.GetString ("The update is a non-fast-forward update. Merge the remote changes before pushing again."), null); break;
case RemoteRefUpdate.Status.OK:
monitor.ReportSuccess (GettextCatalog.GetString ("Push operation successfully completed."));
// Update the remote branch
ObjectId headId = remoteUpdate.GetNewObjectId ();
RefUpdate updateRef = RootRepository.UpdateRef (Constants.R_REMOTES + remote + "/" + remoteBranch);
updateRef.SetNewObjectId(headId);
updateRef.Update();
break;
default:
string msg = remoteUpdate.GetMessage ();
msg = !string.IsNullOrEmpty (msg) ? msg : GettextCatalog.GetString ("Push operation failed");
monitor.ReportError (msg, null);
break;
}
}
}
public void Fetch (IProgressMonitor monitor)
{
string remote = GetCurrentRemote ();
if (remote == null)
throw new InvalidOperationException ("No remotes defined");
monitor.Log.WriteLine (GettextCatalog.GetString ("Fetching from '{0}'", remote));
RemoteConfig remoteConfig = new RemoteConfig (RootRepository.GetConfig (), remote);
Transport tn = Transport.Open (RootRepository, remoteConfig);
using (var gm = new GitMonitor (monitor))
tn.Fetch (gm, null);
monitor.Step (1);
}
public void Rebase (string upstreamRef, GitUpdateOptions options, IProgressMonitor monitor)
{
StashCollection stashes = GitUtil.GetStashes (RootRepository);
Stash stash = null;
NGit.Api.Git git = new NGit.Api.Git (RootRepository);
try
{
monitor.BeginTask (GettextCatalog.GetString ("Rebasing"), 5);
List<string> UpdateSubmodules = new List<string> ();
// TODO: Fix stash so we don't have to do update before the main repo update.
if ((options & GitUpdateOptions.UpdateSubmodules) == GitUpdateOptions.UpdateSubmodules) {
monitor.Log.WriteLine (GettextCatalog.GetString ("Checking repository submodules"));
if (!GetSubmodulesToUpdate (UpdateSubmodules))
return;
monitor.Log.WriteLine (GettextCatalog.GetString ("Updating repository submodules"));
var submoduleUpdate = git.SubmoduleUpdate ();
foreach (var submodule in UpdateSubmodules)
submoduleUpdate.AddPath (submodule);
submoduleUpdate.Call ();
monitor.Step (1);
}
if ((options & GitUpdateOptions.SaveLocalChanges) == GitUpdateOptions.SaveLocalChanges) {
monitor.Log.WriteLine (GettextCatalog.GetString ("Saving local changes"));
using (var gm = new GitMonitor (monitor))
stash = stashes.Create (gm, GetStashName ("_tmp_"));
monitor.Step (1);
}
RebaseCommand rebase = git.Rebase ();
rebase.SetOperation (RebaseCommand.Operation.BEGIN);
rebase.SetUpstream (upstreamRef);
var gmonitor = new GitMonitor (monitor);
rebase.SetProgressMonitor (gmonitor);
bool aborted = false;
try {
var result = rebase.Call ();
while (!aborted && result.GetStatus () == RebaseResult.Status.STOPPED) {
rebase = git.Rebase ();
rebase.SetProgressMonitor (gmonitor);
rebase.SetOperation (RebaseCommand.Operation.CONTINUE);
bool commitChanges = true;
var conflicts = GitUtil.GetConflictedFiles (RootRepository);
foreach (string conflictFile in conflicts) {
ConflictResult res = ResolveConflict (RootRepository.FromGitPath (conflictFile));
if (res == ConflictResult.Abort) {
aborted = true;
commitChanges = false;
rebase.SetOperation (RebaseCommand.Operation.ABORT);
break;
} else if (res == ConflictResult.Skip) {
rebase.SetOperation (RebaseCommand.Operation.SKIP);
commitChanges = false;
break;
}
}
if (commitChanges) {
NGit.Api.AddCommand cmd = git.Add ();
foreach (string conflictFile in conflicts)
cmd.AddFilepattern (conflictFile);
cmd.Call ();
}
result = rebase.Call ();
}
if ((options & GitUpdateOptions.UpdateSubmodules) == GitUpdateOptions.UpdateSubmodules) {
monitor.Log.WriteLine (GettextCatalog.GetString ("Updating repository submodules"));
var submoduleUpdate = git.SubmoduleUpdate ();
foreach (var submodule in UpdateSubmodules)
submoduleUpdate.AddPath (submodule);
submoduleUpdate.Call ();
monitor.Step (1);
}
} catch {
if (!aborted) {
rebase = git.Rebase ();
rebase.SetOperation (RebaseCommand.Operation.ABORT);
rebase.SetProgressMonitor (gmonitor);
rebase.Call ();
}
throw;
} finally {
gmonitor.Dispose ();
}
} finally {
if ((options & GitUpdateOptions.SaveLocalChanges) == GitUpdateOptions.SaveLocalChanges)
monitor.Step (1);
// Restore local changes
if (stash != null) {
monitor.Log.WriteLine (GettextCatalog.GetString ("Restoring local changes"));
using (var gm = new GitMonitor (monitor))
stash.Apply (gm);
stashes.Remove (stash);
}
monitor.EndTask ();
}
}
protected override void Run ()
{
var stashes = Repository.GetStashes ();
NewStashDialog dlg = new NewStashDialog ();
if (MessageService.RunCustomDialog (dlg) == (int) Gtk.ResponseType.Ok) {
string comment = dlg.Comment;
MessageDialogProgressMonitor monitor = new MessageDialogProgressMonitor (true, false, false, true);
var statusTracker = IdeApp.Workspace.GetFileStatusTracker ();
ThreadPool.QueueUserWorkItem (delegate {
try {
using (var gm = new GitMonitor (monitor))
stashes.Create (gm, comment);
} catch (Exception ex) {
MessageService.ShowException (ex);
}
finally {
monitor.Dispose ();
statusTracker.NotifyChanges ();
}
});
}
dlg.Destroy ();
}
protected override void OnCheckout (FilePath targetLocalPath, Revision rev, bool recurse, IProgressMonitor monitor)
{
CloneCommand cmd = NGit.Api.Git.CloneRepository ();
cmd.SetURI (Url);
cmd.SetRemote ("origin");
cmd.SetBranch ("refs/heads/master");
cmd.SetDirectory ((string)targetLocalPath);
cmd.SetCloneSubmodules (true);
using (var gm = new GitMonitor (monitor, 4)) {
cmd.SetProgressMonitor (gm);
try {
cmd.Call ();
} catch (NGit.Api.Errors.JGitInternalException e) {
// We cancelled and NGit throws.
// Or URL is wrong.
if (e.InnerException is NGit.Errors.MissingObjectException ||
e.InnerException is NGit.Errors.TransportException ||
e.InnerException is NGit.Errors.NotSupportedException) {
FileService.DeleteDirectory (targetLocalPath);
throw new VersionControlException ("Checkout failed. Supplied URL is invalid.");
}
}
}
}
protected override void Run ()
{
var stashes = Repository.GetStashes ();
MessageDialogProgressMonitor monitor = new MessageDialogProgressMonitor (true, false, false, true);
var statusTracker = IdeApp.Workspace.GetFileStatusTracker ();
ThreadPool.QueueUserWorkItem (delegate {
try {
NGit.Api.MergeCommandResult result;
using (var gm = new GitMonitor (monitor))
result = stashes.Pop (gm);
GitService.ReportStashResult (monitor, result);
} catch (Exception ex) {
MessageService.ShowException (ex);
}
finally {
monitor.Dispose ();
statusTracker.NotifyChanges ();
}
});
}
public override void Update (FilePath[] localPaths, bool recurse, IProgressMonitor monitor)
{
IEnumerable<Change> statusList = null;
StashCollection stashes = GitUtil.GetStashes (repo);
Stash stash = null;
monitor.BeginTask (GettextCatalog.GetString ("Updating"), 5);
try {
// Fetch remote commits
string remote = GetCurrentRemote ();
if (remote == null)
throw new InvalidOperationException ("No remotes defined");
monitor.Log.WriteLine (GettextCatalog.GetString ("Fetching from '{0}'", remote));
RemoteConfig remoteConfig = new RemoteConfig (repo.GetConfig (), remote);
Transport tn = Transport.Open (repo, remoteConfig);
tn.Fetch (new GitMonitor (monitor), null);
monitor.Step (1);
string upstreamRef = GitUtil.GetUpstreamSource (repo, GetCurrentBranch ());
if (upstreamRef == null)
upstreamRef = GetCurrentRemote () + "/" + GetCurrentBranch ();
ObjectId upstreamId = repo.Resolve (upstreamRef);
if (upstreamId == null)
throw new UserException (GettextCatalog.GetString ("Branch '{0}' not found. Please set a valid upstream reference to be tracked by branch '{1}'", upstreamRef, GetCurrentBranch ()));
// Get a list of files that are different in the target branch
statusList = GitUtil.GetChangedFiles (repo, upstreamRef);
monitor.Step (1);
// Save local changes
monitor.Log.WriteLine (GettextCatalog.GetString ("Saving local changes"));
stash = stashes.Create (GetStashName ("_tmp_"));
monitor.Step (1);
GitMonitor gmonitor = new GitMonitor (monitor);
NGit.Api.Git git = new NGit.Api.Git (repo);
RebaseCommand rebase = git.Rebase ();
rebase.SetOperation (RebaseCommand.Operation.BEGIN);
rebase.SetUpstream (upstreamRef);
rebase.SetProgressMonitor (gmonitor);
bool aborted = false;
try {
var result = rebase.Call ();
while (!aborted && result.GetStatus () == RebaseResult.Status.STOPPED) {
rebase = git.Rebase ();
rebase.SetProgressMonitor (gmonitor);
rebase.SetOperation (RebaseCommand.Operation.CONTINUE);
bool commitChanges = true;
var conflicts = GitUtil.GetConflictedFiles (repo);
foreach (string conflictFile in conflicts) {
ConflictResult res = ResolveConflict (FromGitPath (conflictFile));
if (res == ConflictResult.Abort) {
aborted = true;
commitChanges = false;
rebase.SetOperation (RebaseCommand.Operation.ABORT);
break;
} else if (res == ConflictResult.Skip) {
rebase.SetOperation (RebaseCommand.Operation.SKIP);
commitChanges = false;
break;
}
}
if (commitChanges) {
NGit.Api.AddCommand cmd = git.Add ();
foreach (string conflictFile in conflicts)
cmd.AddFilepattern (conflictFile);
cmd.Call ();
}
result = rebase.Call ();
}
} catch {
if (!aborted) {
rebase = git.Rebase ();
rebase.SetOperation (RebaseCommand.Operation.ABORT);
rebase.SetProgressMonitor (gmonitor);
rebase.Call ();
}
throw;
}
} finally {
// Restore local changes
if (stash != null) {
monitor.Log.WriteLine (GettextCatalog.GetString ("Restoring local changes"));
stash.Apply ();
stashes.Remove (stash);
}
}
monitor.Step (1);
// Notify changes
if (statusList != null)
NotifyFileChanges (monitor, statusList);
monitor.EndTask ();
}
