Rebase abort should support options parameter

Author: jamill

LibGit2Sharp.Tests/RebaseFixture.cs

@@ -191,17 +191,48 @@ public void VerifyRebaseDetailed()
                 Assert.False(repo.RetrieveStatus().IsDirty);
 
                 bool wasCheckoutProgressCalled = false;
+                bool wasCheckoutProgressCalledForResetingHead = false;
                 bool wasCheckoutNotifyCalled = false;
+                bool wasCheckoutNotifyCalledForResetingHead = false;
+
+                bool startedApplyingSteps = false;
 
                 RebaseOptions options = new RebaseOptions()
                 {
-                    OnCheckoutProgress = (x, y, z) => wasCheckoutProgressCalled = true,
-                    OnCheckoutNotify = (x, y) => { wasCheckoutNotifyCalled = true; return true; },
+                    OnCheckoutProgress = (x, y, z) =>
+                    {
+                        if (startedApplyingSteps)
+                        {
+                            wasCheckoutProgressCalled = true;
+                        }
+                        else
+                        {
+                            wasCheckoutProgressCalledForResetingHead = true;
+                        }
+                    },
+                    OnCheckoutNotify = (x, y) =>
+                    {
+                        if (startedApplyingSteps)
+                        {
+                            wasCheckoutNotifyCalled = true;
+                        }
+                        else
+                        {
+                            wasCheckoutNotifyCalledForResetingHead = true;
+                        }
+
+                        return true;
+                    },
                     CheckoutNotifyFlags = CheckoutNotifyFlags.Updated,
+
+                    RebaseStepStarting = x => startedApplyingSteps = true,
+
                 };
 
                 repo.Rebase.Start(null, upstreamBranch, null, Constants.Signature2, options);
 
+                Assert.Equal(true, wasCheckoutNotifyCalledForResetingHead);
+                Assert.Equal(true, wasCheckoutProgressCalledForResetingHead);
                 Assert.Equal(true, wasCheckoutNotifyCalled);
                 Assert.Equal(true, wasCheckoutProgressCalled);
 
@@ -261,7 +292,7 @@ public void CanContinueRebase()
                     RebaseStepCompleted = x => afterStepCallCount++,
                     OnCheckoutProgress = (x, y, z) => wasCheckoutProgressCalled = true,
                     OnCheckoutNotify = (x, y) => { wasCheckoutNotifyCalled = true; return true; },
-                    CheckoutNotifyFlags = CheckoutNotifyFlags.Updated | CheckoutNotifyFlags.Conflict,
+                    CheckoutNotifyFlags = CheckoutNotifyFlags.Updated,
                 };
 
                 RebaseResult rebaseResult = repo.Rebase.Start(branch, upstream, onto, Constants.Signature, options);
@@ -368,10 +399,24 @@ public void CanAbortRebase()
                 Assert.Equal(0, rebaseResult.CompletedStepCount);
                 Assert.Equal(3, rebaseResult.TotalStepCount);
 
-                repo.Rebase.Abort();
-                Assert.False(repo.RetrieveStatus().IsDirty);
-                Assert.True(repo.Index.IsFullyMerged);
+                // Set up the callbacks to verify that checkout progress / notify
+                // callbacks are called.
+                bool wasCheckoutProgressCalled = false;
+                bool wasCheckoutNotifyCalled = false;
+                RebaseOptions options = new RebaseOptions()
+                {
+                    OnCheckoutProgress = (x, y, z) => wasCheckoutProgressCalled = true,
+                    OnCheckoutNotify = (x, y) => { wasCheckoutNotifyCalled = true; return true; },
+                    CheckoutNotifyFlags = CheckoutNotifyFlags.Updated,
+                };
+
+                repo.Rebase.Abort(options);
+                Assert.False(repo.RetrieveStatus().IsDirty, "Repository workdir is dirty after Rebase.Abort.");
+                Assert.True(repo.Index.IsFullyMerged, "Repository index is not fully merged after Rebase.Abort.");
                 Assert.Equal(CurrentOperation.None, repo.Info.CurrentOperation);
+
+                Assert.True(wasCheckoutProgressCalled, "Checkout progress callback was not called during Rebase.Abort.");
+                Assert.True(wasCheckoutNotifyCalled, "Checkout notify callback was not called during Rebase.Abort.");
             }
         }
 

LibGit2Sharp/Rebase.cs

@@ -70,8 +70,8 @@ internal Rebase(Repository repo)
         /// <param name="branch">The branch to rebase.</param>
         /// <param name="upstream">The starting commit to rebase.</param>
         /// <param name="onto">The branch to rebase onto.</param>
-        /// <param name="committer"></param>
-        /// <param name="options"></param>
+        /// <param name="committer">The <see cref="Signature"/> of who added the change to the repository.</param>
+        /// <param name="options">The <see cref="RebaseOptions"/> that specify the rebase behavior.</param>
         /// <returns>true if completed successfully, false if conflicts encountered.</returns>
         public virtual RebaseResult Start(Branch branch, Branch upstream, Branch onto, Signature committer, RebaseOptions options)
         {
@@ -133,7 +133,7 @@ public virtual RebaseResult Start(Branch branch, Branch upstream, Branch onto, S
         /// Continue the current rebase.
         /// </summary>
         /// <param name="committer">The <see cref="Signature"/> of who added the change to the repository.</param>
-        /// <param name="options">The <see cref="RebaseOptions"/> that specify the commit behavior.</param>
+        /// <param name="options">The <see cref="RebaseOptions"/> that specify the rebase behavior.</param>
         public virtual RebaseResult Continue(Signature committer, RebaseOptions options)
         {
             Ensure.ArgumentNotNull(committer, "committer");
@@ -190,11 +190,28 @@ public virtual RebaseResult Continue(Signature committer, RebaseOptions options)
         /// </summary>
         public virtual void Abort()
         {
-            GitRebaseOptions gitRebaseOptions = new GitRebaseOptions();
+            Abort(null);
+        }
 
-            using (RebaseSafeHandle rebase = Proxy.git_rebase_open(repository.Handle, gitRebaseOptions))
+        /// <summary>
+        /// Abort the rebase operation.
+        /// </summary>
+        /// <param name="options">The <see cref="RebaseOptions"/> that specify the rebase behavior.</param>
+        public virtual void Abort(RebaseOptions options)
+        {
+            options = options ?? new RebaseOptions();
+
+            using (GitCheckoutOptsWrapper checkoutOptionsWrapper = new GitCheckoutOptsWrapper(options))
             {
-                Proxy.git_rebase_abort(rebase);
+                GitRebaseOptions gitRebaseOptions = new GitRebaseOptions()
+                {
+                    checkout_options = checkoutOptionsWrapper.Options,
+                };
+
+                using (RebaseSafeHandle rebase = Proxy.git_rebase_open(repository.Handle, gitRebaseOptions))
+                {
+                    Proxy.git_rebase_abort(rebase);
+                }
             }
         }
 

LibGit2Sharp/RebaseOptions.cs

@@ -1,8 +1,4 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using LibGit2Sharp.Core;
+using LibGit2Sharp.Core;
 using LibGit2Sharp.Handlers;
 
 namespace LibGit2Sharp