Various fixups following rebase

Author: nulltoken

LibGit2Sharp.Tests/RebaseFixture.cs

@@ -1,9 +1,5 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
+using System.Collections.Generic;
 using System.Linq;
-using System.Text;
-using LibGit2Sharp.Core;
 using LibGit2Sharp.Tests.TestHelpers;
 using Xunit;
 using Xunit.Extensions;
@@ -56,7 +52,7 @@ public void CanRebase(string initialBranchName,
 
                 RebaseOptions options = new RebaseOptions()
                 {
-                    RebaseStepStarting =  x => 
+                    RebaseStepStarting =  x =>
                     {
                         beforeStepCallCount++;
                         PreRebaseCommits.Add(x.StepInfo.Commit);
@@ -346,7 +342,7 @@ public void CanAbortRebase()
                 Assert.Equal(0, rebaseResult.CompletedStepCount);
                 Assert.Equal(3, rebaseResult.TotalStepCount);
 
-                repo.Rebase.Abort(Constants.Signature);
+                repo.Rebase.Abort();
                 Assert.False(repo.RetrieveStatus().IsDirty);
                 Assert.True(repo.Index.IsFullyMerged);
                 Assert.Equal(CurrentOperation.None, repo.Info.CurrentOperation);
@@ -396,7 +392,7 @@ public void RebaseOperationsWithoutRebasingThrow()
                     repo.Rebase.Continue(Constants.Signature, new RebaseOptions()));
 
                 Assert.Throws<NotFoundException>(() =>
-                    repo.Rebase.Abort(Constants.Signature));
+                    repo.Rebase.Abort());
             }
         }
 
@@ -447,7 +443,7 @@ public void CanRebaseHandlePatchAlreadyApplied()
 
                 RebaseOptions options = new RebaseOptions()
                 {
-                    RebaseStepCompleted = x => 
+                    RebaseStepCompleted = x =>
                     {
                         rebaseResults.Add(new CompletedRebaseStepInfo(x.Commit, x.WasPatchAlreadyApplied));
                     }
@@ -519,7 +515,7 @@ private void ConstructRebaseTestRepository(Repository repo)
             repo.Stage(filePathC);
             commit = repo.Commit("commit 3", Constants.Signature, Constants.Signature, new CommitOptions());
 
-            Branch masterBranch1 = repo.CreateBranch(masterBranch1Name, commit, Constants.Signature);
+            Branch masterBranch1 = repo.CreateBranch(masterBranch1Name, commit);
 
             Touch(workdir, filePathB, string.Join(lineEnding, fileContentB1, fileContentB2));
             repo.Stage(filePathB);
@@ -533,7 +529,7 @@ private void ConstructRebaseTestRepository(Repository repo)
             repo.Stage(filePathB);
             commit = repo.Commit("commit 6", Constants.Signature, Constants.Signature, new CommitOptions());
 
-            repo.CreateBranch(topicBranch1Name, commit, Constants.Signature);
+            repo.CreateBranch(topicBranch1Name, commit);
 
             Touch(workdir, filePathC, string.Join(lineEnding, fileContentC1, fileContentC2));
             repo.Stage(filePathC);
@@ -547,7 +543,7 @@ private void ConstructRebaseTestRepository(Repository repo)
             repo.Stage(filePathC);
             commit = repo.Commit("commit 9", Constants.Signature, Constants.Signature, new CommitOptions());
 
-            repo.CreateBranch(topicBranch2Name, commit, Constants.Signature);
+            repo.CreateBranch(topicBranch2Name, commit);
 
             repo.Checkout(masterBranch1.Tip);
             Touch(workdir, filePathD, fileContentD1);
@@ -562,13 +558,13 @@ private void ConstructRebaseTestRepository(Repository repo)
             repo.Stage(filePathD);
             commit = repo.Commit("commit 12", Constants.Signature, Constants.Signature, new CommitOptions());
 
-            repo.CreateBranch(masterBranch2Name, commit, Constants.Signature);
+            repo.CreateBranch(masterBranch2Name, commit);
 
             // Create commit / branch that conflicts with T1 and T2
             Touch(workdir, filePathB, string.Join(lineEnding, fileContentB1, fileContentB2 + fileContentB3 + fileContentB4));
             repo.Stage(filePathB);
             commit = repo.Commit("commit 13", Constants.Signature, Constants.Signature, new CommitOptions());
-            repo.CreateBranch(conflictBranch1Name, commit, Constants.Signature);
+            repo.CreateBranch(conflictBranch1Name, commit);
         }
     }
 }

LibGit2Sharp/Core/NativeMethods.cs

@@ -198,7 +198,6 @@ internal static extern int git_rebase_init(
             GitAnnotatedCommitHandle branch,
             GitAnnotatedCommitHandle upstream,
             GitAnnotatedCommitHandle onto,
-            GitSignature signature,
             ref GitRebaseOptions options);
 
         [DllImport(libgit2)]
@@ -236,8 +235,7 @@ internal static extern int git_rebase_commit(
 
         [DllImport(libgit2)]
         internal static extern int git_rebase_abort(
-            RebaseSafeHandle rebase,
-            SignatureSafeHandle signature);
+            RebaseSafeHandle rebase);
 
         [DllImport(libgit2)]
         internal static extern int git_rebase_finish(

LibGit2Sharp/Core/Proxy.cs

@@ -1609,14 +1609,13 @@ public static RebaseSafeHandle git_rebase_init(
             GitAnnotatedCommitHandle branch,
             GitAnnotatedCommitHandle upstream,
             GitAnnotatedCommitHandle onto,
-            GitSignature signature,
             ref GitRebaseOptions options)
         {
             RebaseSafeHandle rebase = null;
 
             using (ThreadAffinity())
             {
-                int result = NativeMethods.git_rebase_init(out rebase, repo, branch, upstream, onto, signature, ref options);
+                int result = NativeMethods.git_rebase_init(out rebase, repo, branch, upstream, onto, ref options);
                 Ensure.ZeroResult(result);
             }
 
@@ -1707,7 +1706,7 @@ public static GitRebaseCommitResult git_rebase_commit(
                 try
                 {
                     committerHandle = committer.BuildHandle();
-                    authorHandle = author == null ? 
+                    authorHandle = author == null ?
                         new SignatureSafeHandle() : author.BuildHandle();
 
                     int result = NativeMethods.git_rebase_commit(ref commitResult.CommitId, rebase, authorHandle, committerHandle, IntPtr.Zero, IntPtr.Zero);
@@ -1753,16 +1752,13 @@ public struct GitRebaseCommitResult
         }
 
         public static void git_rebase_abort(
-            RebaseSafeHandle rebase,
-            Signature signature)
+            RebaseSafeHandle rebase)
         {
             Ensure.ArgumentNotNull(rebase, "rebase");
-            Ensure.ArgumentNotNull(signature, "signature");
 
             using (ThreadAffinity())
-            using (var signatureHandle = signature.BuildHandle())
             {
-                int result = NativeMethods.git_rebase_abort(rebase, signatureHandle);
+                int result = NativeMethods.git_rebase_abort(rebase);
             }
         }
 

LibGit2Sharp/Rebase.cs

@@ -128,10 +128,10 @@ public virtual RebaseResult Start(Branch branch, Branch upstream, Branch onto, S
                     annotatedBranchCommitHandle,
                     annotatedUpstreamRefPtrCommitHandle,
                     annotatedOntoRefPtrCommitHandle,
-                    null, ref gitRebaseOptions);
+                    ref gitRebaseOptions);
 
                 RebaseResult rebaseResult =
-                    RebaseOperationImpl.Run(rebaseOperationHandle, 
+                    RebaseOperationImpl.Run(rebaseOperationHandle,
                                             this.repository,
                                             committer,
                                             options,
@@ -213,16 +213,13 @@ public virtual RebaseResult Continue(Signature committer, RebaseOptions options)
         /// <summary>
         /// Abort the rebase operation.
         /// </summary>
-        /// <param name="signature">The <see cref="Signature"/> of who is reborting the rebase.</param>
-        public virtual void Abort(Signature signature)
+        public virtual void Abort()
         {
-            Ensure.ArgumentNotNull(signature, "signature");
-
             RebaseSafeHandle rebase = null;
             try
             {
                 rebase = Proxy.git_rebase_open(repository.Handle);
-                Proxy.git_rebase_abort(rebase, signature);
+                Proxy.git_rebase_abort(rebase);
             }
             finally
             {