Rebase progress / results should return the commit, instead of just the id

jamill · jamill · commit e4a390792382 · 2015-03-13T16:07:06.000-04:00
diff --git a/LibGit2Sharp.Tests/RebaseFixture.cs b/LibGit2Sharp.Tests/RebaseFixture.cs
@@ -50,7 +50,7 @@ public void CanRebase(string initialBranchName,
                 int beforeStepCallCount = 0;
                 int afterStepCallCount = 0;
 
-                List<ObjectId> PreRebaseCommits = new List<ObjectId>();
+                List<Commit> PreRebaseCommits = new List<Commit>();
                 List<CompletedRebaseStepInfo> PostRebaseResults = new List<CompletedRebaseStepInfo>();
                 ObjectId expectedParentId = upstream.Tip.Id;
 
@@ -59,12 +59,12 @@ public void CanRebase(string initialBranchName,
                     RebaseStepStarting =  x => 
                     {
                         beforeStepCallCount++;
-                        PreRebaseCommits.Add(x.StepInfo.ID);
+                        PreRebaseCommits.Add(x.StepInfo.Commit);
                     },
                     RebaseStepCompleted = x =>
                     {
                         afterStepCallCount++;
-                        PostRebaseResults.Add(new CompletedRebaseStepInfo(x.CommitId, x.WasPatchAlreadyApplied));
+                        PostRebaseResults.Add(new CompletedRebaseStepInfo(x.Commit, x.WasPatchAlreadyApplied));
                     },
                 };
 
@@ -88,31 +88,31 @@ public void CanRebase(string initialBranchName,
                     Until = expectedUntilCommit,
                     SortBy = CommitSortStrategies.Reverse | CommitSortStrategies.Topological,
                 };
-                Assert.Equal(repo.Commits.QueryBy(sourceCommitFilter).Select(c => c.Id), PreRebaseCommits);
+                Assert.Equal(repo.Commits.QueryBy(sourceCommitFilter), PreRebaseCommits);
 
                 // Verify the chain of commits that resulted from the rebase.
                 Commit expectedParent = expectedOntoCommit;
                 foreach(CompletedRebaseStepInfo stepInfo in PostRebaseResults)
                 {
-                    Commit rebasedCommit = repo.Lookup<Commit>(stepInfo.ObjectId);
+                    Commit rebasedCommit = stepInfo.Commit;
                     Assert.Equal(expectedParent.Id, rebasedCommit.Parents.First().Id);
                     Assert.False(stepInfo.WasPatchAlreadyApplied);
                     expectedParent = rebasedCommit;
                 }
 
-                Assert.Equal(repo.Head.Tip.Id, PostRebaseResults.Last().ObjectId);
+                Assert.Equal(repo.Head.Tip, PostRebaseResults.Last().Commit);
             }
         }
 
         private class CompletedRebaseStepInfo
         {
-            public CompletedRebaseStepInfo(ObjectId objectId, bool wasPatchAlreadyApplied)
+            public CompletedRebaseStepInfo(Commit commit, bool wasPatchAlreadyApplied)
             {
-                ObjectId = objectId;
+                Commit = commit;
                 WasPatchAlreadyApplied = wasPatchAlreadyApplied;
             }
 
-            public ObjectId ObjectId { get; set; }
+            public Commit Commit { get; set; }
 
             public bool WasPatchAlreadyApplied { get; set; }
         }
@@ -133,16 +133,16 @@ bool IEqualityComparer<CompletedRebaseStepInfo>.Equals(CompletedRebaseStepInfo x
                 }
 
                 return x.WasPatchAlreadyApplied == y.WasPatchAlreadyApplied &&
-                       ObjectId.Equals(x.ObjectId, y.ObjectId);
+                       ObjectId.Equals(x.Commit, y.Commit);
             }
 
             int IEqualityComparer<CompletedRebaseStepInfo>.GetHashCode(CompletedRebaseStepInfo obj)
             {
                 int hashCode = obj.WasPatchAlreadyApplied.GetHashCode();
 
-                if (obj.ObjectId != null)
+                if (obj.Commit != null)
                 {
-                    hashCode += obj.ObjectId.GetHashCode();
+                    hashCode += obj.Commit.GetHashCode();
                 }
 
                 return hashCode;
@@ -449,7 +449,7 @@ public void CanRebaseHandlePatchAlreadyApplied()
                 {
                     RebaseStepCompleted = x => 
                     {
-                        rebaseResults.Add(new CompletedRebaseStepInfo(x.CommitId, x.WasPatchAlreadyApplied));
+                        rebaseResults.Add(new CompletedRebaseStepInfo(x.Commit, x.WasPatchAlreadyApplied));
                     }
                 };
 
@@ -458,7 +458,7 @@ public void CanRebaseHandlePatchAlreadyApplied()
                 List<CompletedRebaseStepInfo> expectedRebaseResults = new List<CompletedRebaseStepInfo>()
                 {
                     new CompletedRebaseStepInfo(null, true),
-                    new CompletedRebaseStepInfo(new ObjectId("ebdea37ecf583fb7fa5c806a1c00b82f3987fbaa"), false),
+                    new CompletedRebaseStepInfo(repo.Lookup<Commit>("ebdea37ecf583fb7fa5c806a1c00b82f3987fbaa"), false),
                 };
 
                 Assert.Equal<CompletedRebaseStepInfo>(expectedRebaseResults, rebaseResults, new CompletedRebaseStepInfoEqualityComparer());
diff --git a/LibGit2Sharp/AfterRebaseStepInfo.cs b/LibGit2Sharp/AfterRebaseStepInfo.cs
@@ -16,10 +16,10 @@ public class AfterRebaseStepInfo
         protected AfterRebaseStepInfo()
         { }
 
-        internal AfterRebaseStepInfo(RebaseStepInfo stepInfo, ObjectId commitId)
+        internal AfterRebaseStepInfo(RebaseStepInfo stepInfo, Commit commit)
         {
             StepInfo = stepInfo;
-            CommitId = commitId;
+            Commit = commit;
             WasPatchAlreadyApplied = false;
         }
 
@@ -39,13 +39,13 @@ internal AfterRebaseStepInfo(RebaseStepInfo stepInfo)
         public virtual RebaseStepInfo StepInfo { get; private set; }
 
         /// <summary>
-        /// The ID of the commit generated by the step, if any.
+        /// The commit generated by the step, if any.
         /// </summary>
-        public virtual ObjectId CommitId { get; private set; }
+        public virtual Commit Commit { get; private set; }
 
         /// <summary>
         /// Was the changes for this step already applied. If so,
-        /// <see cref="AfterRebaseStepInfo.CommitId"/> will be null.
+        /// <see cref="AfterRebaseStepInfo.Commit"/> will be null.
         /// </summary>
         public virtual bool WasPatchAlreadyApplied { get; private set; }
     }
diff --git a/LibGit2Sharp/Rebase.cs b/LibGit2Sharp/Rebase.cs
@@ -184,7 +184,7 @@ public virtual RebaseResult Continue(Signature committer, RebaseOptions options)
                     GitRebaseOperation gitRebasestepInfo = Proxy.git_rebase_operation_byindex(rebase, currentStepIndex);
 
                     var stepInfo = new RebaseStepInfo(gitRebasestepInfo.type,
-                                                      new ObjectId(gitRebasestepInfo.id),
+                                                      repository.Lookup<Commit>(new ObjectId(gitRebasestepInfo.id)),
                                                       LaxUtf8NoCleanupMarshaler.FromNative(gitRebasestepInfo.exec),
                                                       currentStepIndex,
                                                       totalStepCount);
@@ -195,7 +195,7 @@ public virtual RebaseResult Continue(Signature committer, RebaseOptions options)
                     }
                     else
                     {
-                        options.RebaseStepCompleted(new AfterRebaseStepInfo(stepInfo, new ObjectId(rebaseCommitResult.CommitId)));
+                        options.RebaseStepCompleted(new AfterRebaseStepInfo(stepInfo, repository.Lookup<Commit>(new ObjectId(rebaseCommitResult.CommitId))));
                     }
                 }
 
@@ -257,7 +257,7 @@ public virtual RebaseStepInfo GetCurrentStepInfo()
                 long totalStepCount = Proxy.git_rebase_operation_entrycount(rebaseHandle);
                 GitRebaseOperation gitRebasestepInfo = Proxy.git_rebase_operation_byindex(rebaseHandle, currentStepIndex);
                 var stepInfo = new RebaseStepInfo(gitRebasestepInfo.type,
-                                                  gitRebasestepInfo.id,
+                                                  repository.Lookup<Commit>(new ObjectId(gitRebasestepInfo.id)),
                                                   LaxUtf8NoCleanupMarshaler.FromNative(gitRebasestepInfo.exec),
                                                   currentStepIndex,
                                                   totalStepCount);
diff --git a/LibGit2Sharp/RebaseOperationImpl.cs b/LibGit2Sharp/RebaseOperationImpl.cs
@@ -62,7 +62,7 @@ public static RebaseResult Run(RebaseSafeHandle rebaseOperationHandle,
                     else
                     {
                         RebaseStepInfo stepInfo = new RebaseStepInfo(rebaseOperationReport.type,
-                                                                     new ObjectId(rebaseOperationReport.id),
+                                                                     repository.Lookup<Commit>(new ObjectId(rebaseOperationReport.id)),
                                                                      LaxUtf8NoCleanupMarshaler.FromNative(rebaseOperationReport.exec),
                                                                      currentStepIndex,
                                                                      totalStepCount);
@@ -89,7 +89,7 @@ public static RebaseResult Run(RebaseSafeHandle rebaseOperationHandle,
                                         }
                                         else
                                         {
-                                            options.RebaseStepCompleted(new AfterRebaseStepInfo(stepInfo, new ObjectId(rebase_commit_result.CommitId)));
+                                            options.RebaseStepCompleted(new AfterRebaseStepInfo(stepInfo, repository.Lookup<Commit>(new ObjectId(rebase_commit_result.CommitId))));
                                         }
                                     }
                                 }
diff --git a/LibGit2Sharp/RebaseStepInfo.cs b/LibGit2Sharp/RebaseStepInfo.cs
@@ -17,10 +17,10 @@ public class RebaseStepInfo
         protected RebaseStepInfo()
         { }
 
-        internal RebaseStepInfo(RebaseStepOperation type, ObjectId id, string exec, long stepIndex, long totalStepCount)
+        internal RebaseStepInfo(RebaseStepOperation type, Commit commit, string exec, long stepIndex, long totalStepCount)
         {
             Type = type;
-            ID = id;
+            Commit = commit;
             Exec = exec;
             CurrentStep = stepIndex;
             TotalStepCount = totalStepCount;
@@ -34,7 +34,7 @@ internal RebaseStepInfo(RebaseStepOperation type, ObjectId id, string exec, long
         /// <summary>
         /// The object ID the step is operating on.
         /// </summary>
-        public virtual ObjectId ID { get; private set; }
+        public virtual Commit Commit { get; private set; }
 
         /// <summary>
         /// Command to execute, if any.

Original file line number	Diff line number	Diff line change
`@@ -50,7 +50,7 @@ public void CanRebase(string initialBranchName,`
`50`	`50`	`int beforeStepCallCount = 0;`
`51`	`51`	`int afterStepCallCount = 0;`
`52`	`52`
`53`		`- List<ObjectId> PreRebaseCommits = new List<ObjectId>();`
	`53`	`+ List<Commit> PreRebaseCommits = new List<Commit>();`
`54`	`54`	`List<CompletedRebaseStepInfo> PostRebaseResults = new List<CompletedRebaseStepInfo>();`
`55`	`55`	`ObjectId expectedParentId = upstream.Tip.Id;`
`56`	`56`
`@@ -59,12 +59,12 @@ public void CanRebase(string initialBranchName,`
`59`	`59`	`RebaseStepStarting = x =>`
`60`	`60`	`{`
`61`	`61`	`beforeStepCallCount++;`
`62`		`- PreRebaseCommits.Add(x.StepInfo.ID);`
	`62`	`+ PreRebaseCommits.Add(x.StepInfo.Commit);`
`63`	`63`	`},`
`64`	`64`	`RebaseStepCompleted = x =>`
`65`	`65`	`{`
`66`	`66`	`afterStepCallCount++;`
`67`		`- PostRebaseResults.Add(new CompletedRebaseStepInfo(x.CommitId, x.WasPatchAlreadyApplied));`
	`67`	`+ PostRebaseResults.Add(new CompletedRebaseStepInfo(x.Commit, x.WasPatchAlreadyApplied));`
`68`	`68`	`},`
`69`	`69`	`};`
`70`	`70`
`@@ -88,31 +88,31 @@ public void CanRebase(string initialBranchName,`
`88`	`88`	`Until = expectedUntilCommit,`
`89`	`89`	`SortBy = CommitSortStrategies.Reverse \| CommitSortStrategies.Topological,`
`90`	`90`	`};`
`91`		`- Assert.Equal(repo.Commits.QueryBy(sourceCommitFilter).Select(c => c.Id), PreRebaseCommits);`
	`91`	`+ Assert.Equal(repo.Commits.QueryBy(sourceCommitFilter), PreRebaseCommits);`
`92`	`92`
`93`	`93`	`// Verify the chain of commits that resulted from the rebase.`
`94`	`94`	`Commit expectedParent = expectedOntoCommit;`
`95`	`95`	`foreach(CompletedRebaseStepInfo stepInfo in PostRebaseResults)`
`96`	`96`	`{`
`97`		`- Commit rebasedCommit = repo.Lookup<Commit>(stepInfo.ObjectId);`
	`97`	`+ Commit rebasedCommit = stepInfo.Commit;`
`98`	`98`	`Assert.Equal(expectedParent.Id, rebasedCommit.Parents.First().Id);`
`99`	`99`	`Assert.False(stepInfo.WasPatchAlreadyApplied);`
`100`	`100`	`expectedParent = rebasedCommit;`
`101`	`101`	`}`
`102`	`102`
`103`		`- Assert.Equal(repo.Head.Tip.Id, PostRebaseResults.Last().ObjectId);`
	`103`	`+ Assert.Equal(repo.Head.Tip, PostRebaseResults.Last().Commit);`
`104`	`104`	`}`
`105`	`105`	`}`
`106`	`106`
`107`	`107`	`private class CompletedRebaseStepInfo`
`108`	`108`	`{`
`109`		`- public CompletedRebaseStepInfo(ObjectId objectId, bool wasPatchAlreadyApplied)`
	`109`	`+ public CompletedRebaseStepInfo(Commit commit, bool wasPatchAlreadyApplied)`
`110`	`110`	`{`
`111`		`- ObjectId = objectId;`
	`111`	`+ Commit = commit;`
`112`	`112`	`WasPatchAlreadyApplied = wasPatchAlreadyApplied;`
`113`	`113`	`}`
`114`	`114`
`115`		`- public ObjectId ObjectId { get; set; }`
	`115`	`+ public Commit Commit { get; set; }`
`116`	`116`
`117`	`117`	`public bool WasPatchAlreadyApplied { get; set; }`
`118`	`118`	`}`
`@@ -133,16 +133,16 @@ bool IEqualityComparer<CompletedRebaseStepInfo>.Equals(CompletedRebaseStepInfo x`
`133`	`133`	`}`
`134`	`134`
`135`	`135`	`return x.WasPatchAlreadyApplied == y.WasPatchAlreadyApplied &&`
`136`		`- ObjectId.Equals(x.ObjectId, y.ObjectId);`
	`136`	`+ ObjectId.Equals(x.Commit, y.Commit);`
`137`	`137`	`}`
`138`	`138`
`139`	`139`	`int IEqualityComparer<CompletedRebaseStepInfo>.GetHashCode(CompletedRebaseStepInfo obj)`
`140`	`140`	`{`
`141`	`141`	`int hashCode = obj.WasPatchAlreadyApplied.GetHashCode();`
`142`	`142`
`143`		`- if (obj.ObjectId != null)`
	`143`	`+ if (obj.Commit != null)`
`144`	`144`	`{`
`145`		`- hashCode += obj.ObjectId.GetHashCode();`
	`145`	`+ hashCode += obj.Commit.GetHashCode();`
`146`	`146`	`}`
`147`	`147`
`148`	`148`	`return hashCode;`
`@@ -449,7 +449,7 @@ public void CanRebaseHandlePatchAlreadyApplied()`
`449`	`449`	`{`
`450`	`450`	`RebaseStepCompleted = x =>`
`451`	`451`	`{`
`452`		`- rebaseResults.Add(new CompletedRebaseStepInfo(x.CommitId, x.WasPatchAlreadyApplied));`
	`452`	`+ rebaseResults.Add(new CompletedRebaseStepInfo(x.Commit, x.WasPatchAlreadyApplied));`
`453`	`453`	`}`
`454`	`454`	`};`
`455`	`455`
`@@ -458,7 +458,7 @@ public void CanRebaseHandlePatchAlreadyApplied()`
`458`	`458`	`List<CompletedRebaseStepInfo> expectedRebaseResults = new List<CompletedRebaseStepInfo>()`
`459`	`459`	`{`
`460`	`460`	`new CompletedRebaseStepInfo(null, true),`
`461`		`- new CompletedRebaseStepInfo(new ObjectId("ebdea37ecf583fb7fa5c806a1c00b82f3987fbaa"), false),`
	`461`	`+ new CompletedRebaseStepInfo(repo.Lookup<Commit>("ebdea37ecf583fb7fa5c806a1c00b82f3987fbaa"), false),`
`462`	`462`	`};`
`463`	`463`
`464`	`464`	`Assert.Equal<CompletedRebaseStepInfo>(expectedRebaseResults, rebaseResults, new CompletedRebaseStepInfoEqualityComparer());`
Original file line number	Diff line number	Diff line change
`@@ -184,7 +184,7 @@ public virtual RebaseResult Continue(Signature committer, RebaseOptions options)`
`184`	`184`	`GitRebaseOperation gitRebasestepInfo = Proxy.git_rebase_operation_byindex(rebase, currentStepIndex);`
`185`	`185`
`186`	`186`	`var stepInfo = new RebaseStepInfo(gitRebasestepInfo.type,`
`187`		`- new ObjectId(gitRebasestepInfo.id),`
	`187`	`+ repository.Lookup<Commit>(new ObjectId(gitRebasestepInfo.id)),`
`188`	`188`	`LaxUtf8NoCleanupMarshaler.FromNative(gitRebasestepInfo.exec),`
`189`	`189`	`currentStepIndex,`
`190`	`190`	`totalStepCount);`
`@@ -195,7 +195,7 @@ public virtual RebaseResult Continue(Signature committer, RebaseOptions options)`
`195`	`195`	`}`
`196`	`196`	`else`
`197`	`197`	`{`
`198`		`- options.RebaseStepCompleted(new AfterRebaseStepInfo(stepInfo, new ObjectId(rebaseCommitResult.CommitId)));`
	`198`	`+ options.RebaseStepCompleted(new AfterRebaseStepInfo(stepInfo, repository.Lookup<Commit>(new ObjectId(rebaseCommitResult.CommitId))));`
`199`	`199`	`}`
`200`	`200`	`}`
`201`	`201`
`@@ -257,7 +257,7 @@ public virtual RebaseStepInfo GetCurrentStepInfo()`
`257`	`257`	`long totalStepCount = Proxy.git_rebase_operation_entrycount(rebaseHandle);`
`258`	`258`	`GitRebaseOperation gitRebasestepInfo = Proxy.git_rebase_operation_byindex(rebaseHandle, currentStepIndex);`
`259`	`259`	`var stepInfo = new RebaseStepInfo(gitRebasestepInfo.type,`
`260`		`- gitRebasestepInfo.id,`
	`260`	`+ repository.Lookup<Commit>(new ObjectId(gitRebasestepInfo.id)),`
`261`	`261`	`LaxUtf8NoCleanupMarshaler.FromNative(gitRebasestepInfo.exec),`
`262`	`262`	`currentStepIndex,`
`263`	`263`	`totalStepCount);`
Original file line number	Diff line number	Diff line change
`@@ -62,7 +62,7 @@ public static RebaseResult Run(RebaseSafeHandle rebaseOperationHandle,`
`62`	`62`	`else`
`63`	`63`	`{`
`64`	`64`	`RebaseStepInfo stepInfo = new RebaseStepInfo(rebaseOperationReport.type,`
`65`		`- new ObjectId(rebaseOperationReport.id),`
	`65`	`+ repository.Lookup<Commit>(new ObjectId(rebaseOperationReport.id)),`
`66`	`66`	`LaxUtf8NoCleanupMarshaler.FromNative(rebaseOperationReport.exec),`
`67`	`67`	`currentStepIndex,`
`68`	`68`	`totalStepCount);`
`@@ -89,7 +89,7 @@ public static RebaseResult Run(RebaseSafeHandle rebaseOperationHandle,`
`89`	`89`	`}`
`90`	`90`	`else`
`91`	`91`	`{`
`92`		`- options.RebaseStepCompleted(new AfterRebaseStepInfo(stepInfo, new ObjectId(rebase_commit_result.CommitId)));`
	`92`	`+ options.RebaseStepCompleted(new AfterRebaseStepInfo(stepInfo, repository.Lookup<Commit>(new ObjectId(rebase_commit_result.CommitId))));`
`93`	`93`	`}`
`94`	`94`	`}`
`95`	`95`	`}`