Introduce low level Index/Tree operations

Author: alexdima

LibGit2Sharp.Tests/IndexFixture.cs

@@ -278,5 +278,67 @@ public void CanCopeWithExternalChangesToTheIndex()
                 Assert.Equal(2, repoRead.Index.Count);
             }
         }
+
+        [Fact]
+        public void CanResetFullyMergedIndexFromTree()
+        {
+            string path = CloneStandardTestRepo();
+
+            const string testFile = "new_tracked_file.txt";
+
+            // It is sufficient to check just one of the stage area changes, such as the added file,
+            // to verify that the index has indeed been read from the tree.
+            using (var repo = new Repository(path))
+            {
+                const string headIndexTreeSha = "e5d221fc5da11a3169bf503d76497c81be3207b6";
+
+                Assert.True(repo.Index.IsFullyMerged);
+                Assert.Equal(FileStatus.Added, repo.Index.RetrieveStatus(testFile));
+
+                var headIndexTree = repo.Lookup<Tree>(headIndexTreeSha);
+                Assert.NotNull(headIndexTree);
+                repo.Index.Reset(headIndexTree);
+
+                Assert.True(repo.Index.IsFullyMerged);
+                Assert.Equal(FileStatus.Untracked, repo.Index.RetrieveStatus(testFile));
+            }
+
+            // Check that the index was persisted to disk.
+            using (var repo = new Repository(path))
+            {
+                Assert.Equal(FileStatus.Untracked, repo.Index.RetrieveStatus(testFile));
+            }
+        }
+
+        [Fact]
+        public void CanResetIndexWithUnmergedEntriesFromTree()
+        {
+            string path = CloneMergedTestRepo();
+
+            const string testFile = "one.txt";
+
+            // It is sufficient to check just one of the stage area changes, such as the modified file,
+            // to verify that the index has indeed been read from the tree.
+            using (var repo = new Repository(path))
+            {
+                const string headIndexTreeSha = "1cb365141a52dfbb24933515820eb3045fbca12b";
+
+                Assert.False(repo.Index.IsFullyMerged);
+                Assert.Equal(FileStatus.Staged, repo.Index.RetrieveStatus(testFile));
+
+                var headIndexTree = repo.Lookup<Tree>(headIndexTreeSha);
+                Assert.NotNull(headIndexTree);
+                repo.Index.Reset(headIndexTree);
+
+                Assert.True(repo.Index.IsFullyMerged);
+                Assert.Equal(FileStatus.Modified, repo.Index.RetrieveStatus(testFile));
+            }
+
+            // Check that the index was persisted to disk.
+            using (var repo = new Repository(path))
+            {
+                Assert.Equal(FileStatus.Modified, repo.Index.RetrieveStatus(testFile));
+            }
+        }
     }
 }

LibGit2Sharp.Tests/ObjectDatabaseFixture.cs

@@ -360,6 +360,40 @@ public void CannotCreateATreeContainingABlobFromARelativePathAgainstABareReposit
             }
         }
 
+        [Fact]
+        public void CreatingATreeFromIndexWithUnmergedEntriesThrows()
+        {
+            using (var repo = new Repository(MergedTestRepoWorkingDirPath))
+            {
+                Assert.False(repo.Index.IsFullyMerged);
+
+                Assert.Throws<UnmergedIndexEntriesException>(
+                    () => repo.ObjectDatabase.CreateTree(repo.Index));
+            }
+        }
+
+        [Fact]
+        public void CanCreateATreeFromIndex()
+        {
+            string path = CloneStandardTestRepo();
+
+            using (var repo = new Repository(path))
+            {
+                const string expectedIndexTreeSha = "0fe0fd1943a1b63ecca36fa6bbe9bbe045f791a4";
+
+                // The tree representing the index is not in the db.
+                Assert.Null(repo.Lookup(expectedIndexTreeSha));
+
+                var tree = repo.ObjectDatabase.CreateTree(repo.Index);
+                Assert.NotNull(tree);
+                Assert.Equal(expectedIndexTreeSha, tree.Id.Sha);
+
+                // The tree representing the index is now in the db.
+                tree = repo.Lookup<Tree>(expectedIndexTreeSha);
+                Assert.NotNull(tree);
+            }
+        }
+
         [Fact]
         public void CanCreateACommit()
         {

LibGit2Sharp/Core/NativeMethods.cs

@@ -609,6 +609,9 @@ internal static extern IndexReucEntrySafeHandle git_index_reuc_get_bypath(
         [DllImport(libgit2)]
         internal static extern int git_index_write_tree(out GitOid treeOid, IndexSafeHandle index);
 
+        [DllImport(libgit2)]
+        internal static extern int git_index_read_tree(IndexSafeHandle index, GitObjectSafeHandle tree);
+
         [DllImport(libgit2)]
         internal static extern int git_merge_base_many(
             out GitOid mergeBase,

LibGit2Sharp/Core/Proxy.cs

@@ -984,6 +984,15 @@ public static ObjectId git_tree_create_fromindex(Index index)
             }
         }
 
+        public static void git_index_read_fromtree(Index index, GitObjectSafeHandle tree)
+        {
+            using (ThreadAffinity())
+            {
+                int res = NativeMethods.git_index_read_tree(index.Handle, tree);
+                Ensure.ZeroResult(res);
+            }
+        }
+
         #endregion
 
         #region git_merge_

LibGit2Sharp/Index.cs

@@ -458,6 +458,23 @@ private void RemoveFilesAndFolders(IEnumerable<string> pathsList)
             }
         }
 
+        /// <summary>
+        /// Replaces entries in the staging area with entries from the specified tree.
+        /// <para>
+        ///   This overwrites all existing state in the staging area.
+        /// </para>
+        /// </summary>
+        /// <param name="source">The <see cref="Tree"/> to read the entries from.</param>
+        public virtual void Reset(Tree source)
+        {
+            using (var obj = new ObjectSafeWrapper(source.Id, repo.Handle))
+            {
+                Proxy.git_index_read_fromtree(this, obj.ObjectPtr);
+            }
+
+            UpdatePhysicalIndex();
+        }
+
         private IDictionary<Tuple<string, FileStatus>, Tuple<string, FileStatus>> PrepareBatch(IEnumerable<string> leftPaths, IEnumerable<string> rightPaths)
         {
             IDictionary<Tuple<string, FileStatus>, Tuple<string, FileStatus>> dic = new Dictionary<Tuple<string, FileStatus>, Tuple<string, FileStatus>>();

LibGit2Sharp/ObjectDatabase.cs

@@ -245,6 +245,25 @@ public virtual Tree CreateTree(TreeDefinition treeDefinition)
             return treeDefinition.Build(repo);
         }
 
+        /// <summary>
+        /// Inserts a <see cref="Tree"/> into the object database, created from the <see cref="Index"/>.
+        /// <para>
+        ///   It recursively creates tree objects for each of the subtrees stored in the index, but only returns the root tree.
+        /// </para>
+        /// <para>
+        ///   The index must be fully merged.
+        /// </para>
+        /// </summary>
+        /// <param name="index">The <see cref="Index"/>.</param>
+        /// <returns>The created <see cref="Tree"/>. This can be used e.g. to create a <see cref="Commit"/>.</returns>
+        public virtual Tree CreateTree(Index index)
+        {
+            Ensure.ArgumentNotNull(index, "index");
+
+            var treeId = Proxy.git_tree_create_fromindex(index);
+            return this.repo.Lookup<Tree>(treeId);
+        }
+
         /// <summary>
         /// Inserts a <see cref="Commit"/> into the object database, referencing an existing <see cref="Tree"/>.
         /// <para>