Rebase should use Identity instead of Signature

jamill · jamill · commit 37713d7ec13b · 2015-05-29T16:55:23.000-04:00
diff --git a/LibGit2Sharp.Tests/RebaseFixture.cs b/LibGit2Sharp.Tests/RebaseFixture.cs
@@ -65,7 +65,7 @@ public void CanRebase(string initialBranchName,
                     },
                 };
 
-                RebaseResult rebaseResult = repo.Rebase.Start(branch, upstream, onto, Constants.Signature, options);
+                RebaseResult rebaseResult = repo.Rebase.Start(branch, upstream, onto, Constants.Identity, options);
 
                 // Validation:
                 Assert.Equal(RebaseStatus.Complete, rebaseResult.Status);
@@ -114,7 +114,7 @@ public void CanRebaseBranchOntoItself()
                 repo.Checkout(topicBranch2Name);
                 Branch b = repo.Branches[topicBranch2Name];
 
-                RebaseResult result = repo.Rebase.Start(b, b, null, Constants.Signature, new RebaseOptions());
+                RebaseResult result = repo.Rebase.Start(b, b, null, Constants.Identity, new RebaseOptions());
                 Assert.Equal(0, result.TotalStepCount);
                 Assert.Equal(RebaseStatus.Complete, result.Status);
                 Assert.Equal(0, result.CompletedStepCount);
@@ -229,7 +229,7 @@ public void VerifyRebaseDetailed()
 
                 };
 
-                repo.Rebase.Start(null, upstreamBranch, null, Constants.Signature2, options);
+                repo.Rebase.Start(null, upstreamBranch, null, Constants.Identity2, options);
 
                 Assert.Equal(true, wasCheckoutNotifyCalledForResetingHead);
                 Assert.Equal(true, wasCheckoutProgressCalledForResetingHead);
@@ -295,7 +295,7 @@ public void CanContinueRebase()
                     CheckoutNotifyFlags = CheckoutNotifyFlags.Updated,
                 };
 
-                RebaseResult rebaseResult = repo.Rebase.Start(branch, upstream, onto, Constants.Signature, options);
+                RebaseResult rebaseResult = repo.Rebase.Start(branch, upstream, onto, Constants.Identity, options);
 
                 // Verify that we have a conflict.
                 Assert.Equal(CurrentOperation.RebaseMerge, repo.Info.CurrentOperation);
@@ -326,7 +326,7 @@ public void CanContinueRebase()
 
                 // Clear the flags:
                 wasCheckoutProgressCalled = false; wasCheckoutNotifyCalled = false;
-                RebaseResult continuedRebaseResult = repo.Rebase.Continue(Constants.Signature, options);
+                RebaseResult continuedRebaseResult = repo.Rebase.Continue(Constants.Identity, options);
 
                 Assert.NotNull(continuedRebaseResult);
                 Assert.Equal(RebaseStatus.Complete, continuedRebaseResult.Status);
@@ -358,7 +358,7 @@ public void CanQueryRebaseOperation()
                 Branch upstream = repo.Branches[conflictBranch1Name];
                 Branch onto = repo.Branches[conflictBranch1Name];
 
-                RebaseResult rebaseResult = repo.Rebase.Start(branch, upstream, onto, Constants.Signature, null);
+                RebaseResult rebaseResult = repo.Rebase.Start(branch, upstream, onto, Constants.Identity, null);
 
                 // Verify that we have a conflict.
                 Assert.Equal(RebaseStatus.Conflicts, rebaseResult.Status);
@@ -390,7 +390,7 @@ public void CanAbortRebase()
                 Branch upstream = repo.Branches[conflictBranch1Name];
                 Branch onto = repo.Branches[conflictBranch1Name];
 
-                RebaseResult rebaseResult = repo.Rebase.Start(branch, upstream, onto, Constants.Signature, null);
+                RebaseResult rebaseResult = repo.Rebase.Start(branch, upstream, onto, Constants.Identity, null);
 
                 // Verify that we have a conflict.
                 Assert.Equal(RebaseStatus.Conflicts, rebaseResult.Status);
@@ -436,15 +436,15 @@ public void RebaseWhileAlreadyRebasingThrows()
                 Branch upstream = repo.Branches[conflictBranch1Name];
                 Branch onto = repo.Branches[conflictBranch1Name];
 
-                RebaseResult rebaseResult = repo.Rebase.Start(branch, upstream, onto, Constants.Signature, null);
+                RebaseResult rebaseResult = repo.Rebase.Start(branch, upstream, onto, Constants.Identity, null);
 
                 // Verify that we have a conflict.
                 Assert.Equal(RebaseStatus.Conflicts, rebaseResult.Status);
                 Assert.True(repo.RetrieveStatus().IsDirty);
                 Assert.Equal(CurrentOperation.RebaseMerge, repo.Info.CurrentOperation);
 
                 Assert.Throws<LibGit2SharpException>(() =>
-                    repo.Rebase.Start(branch, upstream, onto, Constants.Signature, null));
+                    repo.Rebase.Start(branch, upstream, onto, Constants.Identity, null));
             }
         }
 
@@ -460,7 +460,7 @@ public void RebaseOperationsWithoutRebasingThrow()
                 repo.Checkout(topicBranch1Name);
 
                 Assert.Throws<NotFoundException>(() =>
-                    repo.Rebase.Continue(Constants.Signature, new RebaseOptions()));
+                    repo.Rebase.Continue(Constants.Identity, new RebaseOptions()));
 
                 Assert.Throws<NotFoundException>(() =>
                     repo.Rebase.Abort());
@@ -520,15 +520,22 @@ public void CanRebaseHandlePatchAlreadyApplied()
                     }
                 };
 
-                repo.Rebase.Start(null, upstreamBranch, null, Constants.Signature2, options);
+                repo.Rebase.Start(null, upstreamBranch, null, Constants.Identity2, options);
+                ObjectId secondCommitExpectedTreeId = new ObjectId("ac04bf04980c9be72f64ba77fd0d9088a40ed681");
+                Signature secondCommitAuthorSignature = Constants.Signature;
+                Identity secondCommitCommiterIdentity = Constants.Identity2;
 
-                List<CompletedRebaseStepInfo> expectedRebaseResults = new List<CompletedRebaseStepInfo>()
-                {
-                    new CompletedRebaseStepInfo(null, true),
-                    new CompletedRebaseStepInfo(repo.Lookup<Commit>("ebdea37ecf583fb7fa5c806a1c00b82f3987fbaa"), false),
-                };
+                Assert.Equal(2, rebaseResults.Count);
+                Assert.True(rebaseResults[0].WasPatchAlreadyApplied);
+
+                Assert.False(rebaseResults[1].WasPatchAlreadyApplied);
+                Assert.NotNull(rebaseResults[1].Commit);
 
-                Assert.Equal<CompletedRebaseStepInfo>(expectedRebaseResults, rebaseResults, new CompletedRebaseStepInfoEqualityComparer());
+                // This is the expected tree ID of the new commit.
+                Assert.True(ObjectId.Equals(secondCommitExpectedTreeId, rebaseResults[1].Commit.Tree.Id));
+                Assert.True(Signature.Equals(secondCommitAuthorSignature, rebaseResults[1].Commit.Author));
+                Assert.Equal<string>(secondCommitCommiterIdentity.Name, rebaseResults[1].Commit.Committer.Name, StringComparer.Ordinal);
+                Assert.Equal<string>(secondCommitCommiterIdentity.Email, rebaseResults[1].Commit.Committer.Email, StringComparer.Ordinal);
             }
         }
 
diff --git a/LibGit2Sharp.Tests/TestHelpers/Constants.cs b/LibGit2Sharp.Tests/TestHelpers/Constants.cs
@@ -11,8 +11,10 @@ public static class Constants
         public static readonly string TemporaryReposPath = BuildPath();
         public const string UnknownSha = "deadbeefdeadbeefdeadbeefdeadbeefdeadbeef";
         public static readonly Identity Identity = new Identity("A. U. Thor", "thor@valhalla.asgard.com");
+        public static readonly Identity Identity2 = new Identity("nulltoken", "emeric.fermas@gmail.com");
+
         public static readonly Signature Signature = new Signature(Identity, new DateTimeOffset(2011, 06, 16, 10, 58, 27, TimeSpan.FromHours(2)));
-        public static readonly Signature Signature2 = new Signature("nulltoken", "emeric.fermas@gmail.com", DateTimeOffset.Parse("Wed, Dec 14 2011 08:29:03 +0100"));
+        public static readonly Signature Signature2 = new Signature(Identity2, DateTimeOffset.Parse("Wed, Dec 14 2011 08:29:03 +0100"));
 
         // Populate these to turn on live credential tests:  set the
         // PrivateRepoUrl to the URL of a repository that requires
diff --git a/LibGit2Sharp/Core/NativeMethods.cs b/LibGit2Sharp/Core/NativeMethods.cs
@@ -1394,6 +1394,12 @@ internal static extern int git_signature_new(
             long time,
             int offset);
 
+        [DllImport(libgit2)]
+        internal static extern int git_signature_now(
+            out SignatureSafeHandle signature,
+            [MarshalAs(UnmanagedType.CustomMarshaler, MarshalCookie = UniqueId.UniqueIdentifier, MarshalTypeRef = typeof(StrictUtf8Marshaler))] string name,
+            [MarshalAs(UnmanagedType.CustomMarshaler, MarshalCookie = UniqueId.UniqueIdentifier, MarshalTypeRef = typeof(StrictUtf8Marshaler))] string email);
+
         [DllImport(libgit2)]
         internal static extern int git_signature_dup(out IntPtr dest, IntPtr sig);
 
diff --git a/LibGit2Sharp/Core/Proxy.cs b/LibGit2Sharp/Core/Proxy.cs
@@ -1612,14 +1612,14 @@ public static GitRebaseOperation git_rebase_next(RebaseSafeHandle rebase)
 
         public static GitRebaseCommitResult git_rebase_commit(
             RebaseSafeHandle rebase,
-            Signature author,
-            Signature committer)
+            Identity author,
+            Identity committer)
         {
             Ensure.ArgumentNotNull(rebase, "rebase");
             Ensure.ArgumentNotNull(committer, "committer");
 
-            using (SignatureSafeHandle committerHandle = committer.BuildHandle())
-            using (SignatureSafeHandle authorHandle = author.SafeBuildHandle())
+            using (SignatureSafeHandle committerHandle = committer.BuildNowSignatureHandle())
+            using (SignatureSafeHandle authorHandle = author.SafeBuildNowSignatureHandle())
             {
                 GitRebaseCommitResult commitResult = new GitRebaseCommitResult();
 
@@ -1667,12 +1667,12 @@ public static void git_rebase_abort(
 
         public static void git_rebase_finish(
             RebaseSafeHandle rebase,
-            Signature signature)
+            Identity committer)
         {
             Ensure.ArgumentNotNull(rebase, "rebase");
-            Ensure.ArgumentNotNull(signature, "signature");
+            Ensure.ArgumentNotNull(committer, "committer");
 
-            using (var signatureHandle = signature.BuildHandle())
+            using (var signatureHandle = committer.BuildNowSignatureHandle())
             {
                 int result = NativeMethods.git_rebase_finish(rebase, signatureHandle);
                 Ensure.ZeroResult(result);
@@ -2567,8 +2567,16 @@ public static SignatureSafeHandle git_signature_new(string name, string email, D
             SignatureSafeHandle handle;
 
             int res = NativeMethods.git_signature_new(out handle, name, email, when.ToSecondsSinceEpoch(),
-                (int)when.Offset.TotalMinutes);
+                                                      (int)when.Offset.TotalMinutes);
+            Ensure.ZeroResult(res);
 
+            return handle;
+        }
+
+        public static SignatureSafeHandle git_signature_now(string name, string email)
+        {
+            SignatureSafeHandle handle;
+            int res = NativeMethods.git_signature_now(out handle, name, email);
             Ensure.ZeroResult(res);
 
             return handle;
diff --git a/LibGit2Sharp/Identity.cs b/LibGit2Sharp/Identity.cs
@@ -1,4 +1,5 @@
 ﻿using LibGit2Sharp.Core;
+using LibGit2Sharp.Core.Handles;
 
 namespace LibGit2Sharp
 {
@@ -41,5 +42,29 @@ public string Name
         {
             get { return _name; }
         }
+
+        internal SignatureSafeHandle BuildNowSignatureHandle()
+        {
+            return Proxy.git_signature_now(Name, Email);
+        }
+    }
+
+    internal static class IdentityHelpers
+    {
+        /// <summary>
+        /// Build the handle for the Indentity with the current time, or return a handle
+        /// to an empty signature.
+        /// </summary>
+        /// <param name="identity"></param>
+        /// <returns></returns>
+        public static SignatureSafeHandle SafeBuildNowSignatureHandle(this Identity identity)
+        {
+            if (identity == null)
+            {
+                return new SignatureSafeHandle();
+            }
+
+            return identity.BuildNowSignatureHandle();
+        }
     }
 }
diff --git a/LibGit2Sharp/Rebase.cs b/LibGit2Sharp/Rebase.cs
@@ -70,10 +70,10 @@ 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">The <see cref="Signature"/> of who added the change to the repository.</param>
+        /// <param name="committer">The <see cref="Identity"/> 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)
+        public virtual RebaseResult Start(Branch branch, Branch upstream, Branch onto, Identity committer, RebaseOptions options)
         {
             Ensure.ArgumentNotNull(upstream, "upstream");
 
@@ -132,9 +132,9 @@ public virtual RebaseResult Start(Branch branch, Branch upstream, Branch onto, S
         /// <summary>
         /// Continue the current rebase.
         /// </summary>
-        /// <param name="committer">The <see cref="Signature"/> of who added the change to the repository.</param>
+        /// <param name="committer">The <see cref="Identity"/> of who added the change to the repository.</param>
         /// <param name="options">The <see cref="RebaseOptions"/> that specify the rebase behavior.</param>
-        public virtual RebaseResult Continue(Signature committer, RebaseOptions options)
+        public virtual RebaseResult Continue(Identity committer, RebaseOptions options)
         {
             Ensure.ArgumentNotNull(committer, "committer");
 
diff --git a/LibGit2Sharp/RebaseOperationImpl.cs b/LibGit2Sharp/RebaseOperationImpl.cs
@@ -15,12 +15,12 @@ internal class RebaseOperationImpl
         /// </summary>
         /// <param name="rebaseOperationHandle">Handle to the rebase operation.</param>
         /// <param name="repository">Repository in which rebase operation is being run.</param>
-        /// <param name="committer">Committer signature to use for the rebased commits.</param>
+        /// <param name="committer">Committer Identity to use for the rebased commits.</param>
         /// <param name="options">Options controlling rebase behavior.</param>
-        /// <returns>RebaseResult - describing the result of the rebase operation.</returns>
+        /// <returns>RebaseResult that describes the result of the rebase operation.</returns>
         public static RebaseResult Run(RebaseSafeHandle rebaseOperationHandle,
             Repository repository,
-            Signature committer,
+            Identity committer,
             RebaseOptions options)
         {
             Ensure.ArgumentNotNull(rebaseOperationHandle, "rebaseOperationHandle");
@@ -53,7 +53,7 @@ public static RebaseResult Run(RebaseSafeHandle rebaseOperationHandle,
             return rebaseResult;
         }
 
-        private static RebaseResult CompleteRebase(RebaseSafeHandle rebaseOperationHandle, Signature committer, RebaseResult rebaseResult)
+        private static RebaseResult CompleteRebase(RebaseSafeHandle rebaseOperationHandle, Identity committer, RebaseResult rebaseResult)
         {
             long totalStepCount = Proxy.git_rebase_operation_entrycount(rebaseOperationHandle);
             GitRebaseOptions gitRebaseOptions = new GitRebaseOptions()
@@ -80,7 +80,7 @@ private static RebaseResult CompleteRebase(RebaseSafeHandle rebaseOperationHandl
         /// <param name="options"></param>
         /// <param name="stepToApplyInfo"></param>
         /// <returns></returns>
-        private static RebaseResult RunRebaseStep(RebaseSafeHandle rebaseOperationHandle, Repository repository, Signature committer, RebaseOptions options, RebaseStepInfo stepToApplyInfo)
+        private static RebaseResult RunRebaseStep(RebaseSafeHandle rebaseOperationHandle, Repository repository, Identity committer, RebaseOptions options, RebaseStepInfo stepToApplyInfo)
         {
             RebaseStepResult rebaseStepResult = null;
             RebaseResult rebaseSequenceResult = null;
@@ -145,7 +145,7 @@ private static RebaseResult RunRebaseStep(RebaseSafeHandle rebaseOperationHandle
             return rebaseSequenceResult;
         }
 
-        private static RebaseStepResult ApplyPickStep(RebaseSafeHandle rebaseOperationHandle, Repository repository, Signature committer, RebaseOptions options, RebaseStepInfo stepToApplyInfo)
+        private static RebaseStepResult ApplyPickStep(RebaseSafeHandle rebaseOperationHandle, Repository repository, Identity committer, RebaseOptions options, RebaseStepInfo stepToApplyInfo)
         {
             RebaseStepResult rebaseStepResult;
 
