Insert new reflog entry on commit

Fix #371

Insert entry on HEAD and target direct reference on commit
Tag as initial the first commit

Author: Saaman

LibGit2Sharp.Tests/CommitFixture.cs

@@ -614,14 +614,23 @@ public void CanCommitALittleBit()
                 Assert.Null(repo.Head[relativeFilepath]);
 
                 var author = DummySignature;
-                Commit commit = repo.Commit("Initial egotistic commit", author, author);
+                const string commitMessage = "Initial egotistic commit";
+                Commit commit = repo.Commit(commitMessage, author, author);
 
                 AssertBlobContent(repo.Head[relativeFilepath], "nulltoken\n");
                 AssertBlobContent(commit[relativeFilepath], "nulltoken\n");
 
                 Assert.Equal(0, commit.Parents.Count());
                 Assert.False(repo.Info.IsHeadOrphaned);
 
+                // Assert a reflog entry is created
+                Assert.Equal(1, repo.Refs.Log("HEAD").Count());
+                var reflogEntry = repo.Refs.Log("HEAD").First();
+                Assert.Equal(author, reflogEntry.Commiter);
+                Assert.Equal(commit.Id, reflogEntry.To);
+                Assert.Equal(ObjectId.Zero, reflogEntry.From);
+                Assert.Equal(string.Format("commit (initial): {0}", commitMessage), reflogEntry.Message);
+
                 File.WriteAllText(filePath, "nulltoken commits!\n");
                 repo.Index.Stage(relativeFilepath);
 
@@ -634,6 +643,10 @@ public void CanCommitALittleBit()
                 Assert.Equal(1, commit2.Parents.Count());
                 Assert.Equal(commit.Id, commit2.Parents.First().Id);
 
+                // Assert the reflog is shifted
+                Assert.Equal(2, repo.Refs.Log("HEAD").Count());
+                Assert.Equal(reflogEntry.To, repo.Refs.Log("HEAD").First().From);
+
                 Branch firstCommitBranch = repo.CreateBranch("davidfowl-rules", commit);
                 repo.Checkout(firstCommitBranch);
 
@@ -731,10 +744,17 @@ public void CanAmendACommitWithMoreThanOneParent()
                 repo.Reset(ResetOptions.Soft, mergedCommit.Sha);
 
                 CreateAndStageANewFile(repo);
+                const string commitMessage = "I'm rewriting the history!";
 
-                Commit amendedCommit = repo.Commit("I'm rewriting the history!", DummySignature, DummySignature, true);
+                Commit amendedCommit = repo.Commit(commitMessage, DummySignature, DummySignature, true);
 
                 AssertCommitHasBeenAmended(repo, amendedCommit, mergedCommit);
+
+                // Assert a reflog entry is created
+                var reflogEntry = repo.Refs.Log("HEAD").First();
+                Assert.Equal(amendedCommit.Committer, reflogEntry.Commiter);
+                Assert.Equal(amendedCommit.Id, reflogEntry.To);
+                Assert.Equal(string.Format("commit (amend): {0}", commitMessage), reflogEntry.Message);
             }
         }
 

LibGit2Sharp.Tests/ReflogFixture.cs

@@ -1,4 +1,5 @@
-using LibGit2Sharp.Tests.TestHelpers;
+using System.IO;
+using LibGit2Sharp.Tests.TestHelpers;
 using System.Linq;
 using Xunit;
 
@@ -37,5 +38,69 @@ public void CannotReadReflogOnUnknownReference()
                 Assert.Throws<InvalidSpecificationException>(() => repo.Refs.Log("toto").Count());
             }
         }
+
+        [Fact]
+        public void CommitShouldCreateReflogEntryOnHeadandOnTargetedDirectReference()
+        {
+            SelfCleaningDirectory scd = BuildSelfCleaningDirectory();
+
+            using (var repo = Repository.Init(scd.DirectoryPath))
+            {
+                // setup refs as HEAD => unit_test => master
+                var newRef = repo.Refs.Add("refs/heads/unit_test", "refs/heads/master");
+                Assert.NotNull(newRef);
+                repo.Refs.UpdateTarget(repo.Refs.Head, newRef);
+
+                const string relativeFilepath = "new.txt";
+                string filePath = Path.Combine(repo.Info.WorkingDirectory, relativeFilepath);
+
+                File.WriteAllText(filePath, "content\n");
+                repo.Index.Stage(relativeFilepath);
+
+                var author = DummySignature;
+                const string commitMessage = "Hope reflog behaves as it should";
+                Commit commit = repo.Commit(commitMessage, author, author);
+
+                // Assert a reflog entry is created on HEAD
+                Assert.Equal(1, repo.Refs.Log("HEAD").Count());
+                var reflogEntry = repo.Refs.Log("HEAD").First();
+                Assert.Equal(author, reflogEntry.Commiter);
+                Assert.Equal(commit.Id, reflogEntry.To);
+                Assert.Equal(ObjectId.Zero, reflogEntry.From);
+
+                // Assert the same reflog entry is created on refs/heads/master
+                Assert.Equal(1, repo.Refs.Log("refs/heads/master").Count());
+                reflogEntry = repo.Refs.Log("HEAD").First();
+                Assert.Equal(author, reflogEntry.Commiter);
+                Assert.Equal(commit.Id, reflogEntry.To);
+                Assert.Equal(ObjectId.Zero, reflogEntry.From);
+
+                // Assert no reflog entry is created on refs/heads/unit_test
+                Assert.Equal(0, repo.Refs.Log("refs/heads/unit_test").Count());
+            }
+        }
+
+        [Fact]
+        public void CommitOnUnbornReferenceShouldCreateReflogEntryWithInitialTag()
+        {
+            SelfCleaningDirectory scd = BuildSelfCleaningDirectory();
+
+            using (var repo = Repository.Init(scd.DirectoryPath))
+            {
+                const string relativeFilepath = "new.txt";
+                string filePath = Path.Combine(repo.Info.WorkingDirectory, relativeFilepath);
+
+                File.WriteAllText(filePath, "content\n");
+                repo.Index.Stage(relativeFilepath);
+
+                var author = DummySignature;
+                const string commitMessage = "First commit should be logged as initial";
+                repo.Commit(commitMessage, author, author);
+
+                // Assert the reflog entry message is correct
+                Assert.Equal(1, repo.Refs.Log("HEAD").Count());
+                Assert.Equal(string.Format("commit (initial): {0}", commitMessage), repo.Refs.Log("HEAD").First().Message);
+            }
+        }
     }
 }

LibGit2Sharp/Core/NativeMethods.cs

@@ -729,6 +729,16 @@ internal static extern OidSafeHandle git_reflog_entry_id_new(
         internal static extern IntPtr git_reflog_entry_committer(
             SafeHandle entry);
 
+        [DllImport(libgit2)]
+        internal static extern int git_reflog_append(
+            ReflogSafeHandle reflog,
+            ref GitOid id,
+            SignatureSafeHandle committer,
+            [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(Utf8Marshaler))] string msg);
+
+        [DllImport(libgit2)]
+        internal static extern int git_reflog_write(ReflogSafeHandle reflog);
+
         [DllImport(libgit2)]
         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(Utf8NoCleanupMarshaler))]
         internal static extern string git_reflog_entry_message(SafeHandle entry);

LibGit2Sharp/Core/Proxy.cs

@@ -1317,6 +1317,21 @@ public static string git_reflog_entry_message(SafeHandle entry)
             return NativeMethods.git_reflog_entry_message(entry);
         }
 
+        public static void git_reflog_append(ReflogSafeHandle reflog, ObjectId commit_id, Signature committer, string message)
+        {
+            using (ThreadAffinity())
+            using (SignatureSafeHandle committerHandle = committer.BuildHandle())
+            {
+                var oid = commit_id.Oid;
+
+                int res = NativeMethods.git_reflog_append(reflog, ref oid, committerHandle, message);
+                Ensure.ZeroResult(res);
+
+                res = NativeMethods.git_reflog_write(reflog);
+                Ensure.ZeroResult(res);
+            }
+        }
+
         #endregion
 
         #region git_refspec

LibGit2Sharp/ReflogCollection.cs

@@ -1,5 +1,4 @@
-using System;
-using System.Collections;
+using System.Collections;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Globalization;
@@ -87,5 +86,22 @@ private string DebuggerDisplay
                     "Count = {0}", this.Count());
             }
         }
+
+        /// <summary>
+        ///   Add a new <see cref="ReflogEntry"/> to the current <see cref="ReflogCollection"/>. It will be created as first item of the collection
+        ///   The native reflog object will be saved right after inserting the entry.
+        /// </summary>
+        /// <param name="objectId">the <see cref="ObjectId"/> of the new commit the <see cref="Reference"/> will point out.</param>
+        /// <param name="committer"><see cref="Signature"/> of the author of the new commit.</param>
+        /// <param name="message">the message associated with the new <see cref="ReflogEntry"/>.</param>
+        internal virtual void Append(ObjectId objectId, Signature committer, string message)
+        {
+            using (ReferenceSafeHandle reference = Proxy.git_reference_lookup(repo.Handle, canonicalName, true))
+            using (ReflogSafeHandle reflog = Proxy.git_reflog_read(reference))
+            {
+                string prettifiedMessage = Proxy.git_message_prettify(message);
+                Proxy.git_reflog_append(reflog, objectId, committer, prettifiedMessage);
+            }
+        }
     }
 }

LibGit2Sharp/Repository.cs

@@ -684,9 +684,39 @@ public Commit Commit(string message, Signature author, Signature committer, bool
 
             Proxy.git_repository_merge_cleanup(handle);
 
+            // Insert reflog entry
+            LogCommit(result, amendPreviousCommit, parents.Count() == 0);
+
             return result;
         }
 
+        private void LogCommit(Commit commit, bool amendPreviousCommit, bool isInitialCommit)
+        {
+            // Compute reflog message
+            string reflogMessage = "commit";
+            if (isInitialCommit)
+            {
+                reflogMessage += " (initial)";
+            }
+            else if(amendPreviousCommit)
+            {
+                reflogMessage += " (amend)";
+            }
+
+            reflogMessage = string.Format("{0}: {1}", reflogMessage, commit.Message);
+
+            var headRef = Refs.Head;
+
+            // in case HEAD targets a symbolic reference, log commit on the targeted direct reference
+            if(headRef is SymbolicReference)
+            {
+                Refs.Log(headRef.ResolveToDirectReference()).Append(commit.Id, commit.Committer, reflogMessage);
+            }
+
+            // Log commit on HEAD
+            Refs.Log(headRef).Append(commit.Id, commit.Committer, reflogMessage);
+        }
+
         private IEnumerable<Commit> RetrieveParentsOfTheCommitBeingCreated(bool amendPreviousCommit)
         {
             if (amendPreviousCommit)