Add TreeDefinition.Add(path, gitLink)

Author: dahlbyk

LibGit2Sharp.Tests/TreeDefinitionFixture.cs

@@ -111,6 +111,27 @@ public void CanAddAnExistingTreeEntryDefinition(string sourcePath, string target
             }
         }
 
+        [Fact]
+        public void CanAddAnExistingGitLinkTreeEntryDefinition()
+        {
+            const string sourcePath = "sm_unchanged";
+            const string targetPath = "sm_from_td";
+
+            using (var repo = new Repository(SubmoduleTestRepoWorkingDirPath))
+            {
+                TreeDefinition td = TreeDefinition.From(repo.Head.Tip.Tree);
+                Assert.Null(td[targetPath]);
+
+                TreeEntryDefinition ted = td[sourcePath];
+                td.Add(targetPath, ted);
+
+                TreeEntryDefinition fetched = td[targetPath];
+                Assert.NotNull(fetched);
+
+                Assert.Equal(ted, fetched);
+            }
+        }
+
         [Theory]
         [InlineData("a8233120f6ad708f843d861ce2b7228ec4e3dec6", "README_TOO")]
         [InlineData("a8233120f6ad708f843d861ce2b7228ec4e3dec6", "1/README")]
@@ -136,6 +157,29 @@ public void CanAddAnExistingBlob(string blobSha, string targetPath)
             }
         }
 
+        [Fact]
+        public void CanAddAnExistingGitLink()
+        {
+            const string targetPath = "sm_from_td";
+
+            using (var repo = new Repository(SubmoduleTestRepoWorkingDirPath))
+            {
+                TreeDefinition td = TreeDefinition.From(repo.Head.Tip.Tree);
+                Assert.Null(td[targetPath]);
+
+                var gitLink = repo.Submodules["sm_unchanged"].GitLink;
+
+                td.Add(targetPath, gitLink);
+
+                TreeEntryDefinition fetched = td[targetPath];
+                Assert.NotNull(fetched);
+
+                Assert.Equal(gitLink.Id, fetched.TargetId);
+                Assert.Equal(GitObjectType.Commit, fetched.Type);
+                Assert.Equal(Mode.GitLink, fetched.Mode);
+            }
+        }
+
         [Fact]
         public void CanAddAnExistingTree()
         {
@@ -217,6 +261,111 @@ public void CanReplaceAnExistingBlobWithATree(string targetPath)
             }
         }
 
+        [Fact]
+        public void CanReplaceAnExistingTreeWithAGitLink()
+        {
+            const string targetPath = "just_a_dir";
+
+            using (var repo = new Repository(SubmoduleTestRepoWorkingDirPath))
+            {
+                TreeDefinition td = TreeDefinition.From(repo.Head.Tip.Tree);
+                Assert.Equal(GitObjectType.Tree, td[targetPath].Type);
+
+                var gitLink = repo.Submodules["sm_unchanged"].GitLink;
+
+                Assert.NotNull(td["just_a_dir/contents"]);
+
+                td.Add(targetPath, gitLink);
+
+                TreeEntryDefinition fetched = td[targetPath];
+                Assert.NotNull(fetched);
+
+                Assert.Equal(gitLink.Id, fetched.TargetId);
+                Assert.Equal(GitObjectType.Commit, fetched.Type);
+                Assert.Equal(Mode.GitLink, fetched.Mode);
+
+                Assert.Null(td["just_a_dir/contents"]);
+            }
+        }
+
+        [Fact]
+        public void CanReplaceAnExistingGitLinkWithATree()
+        {
+            const string treeSha = "607d96653d4d0a4f733107f7890c2e67b55b620d";
+            const string targetPath = "sm_unchanged";
+
+            using (var repo = new Repository(SubmoduleTestRepoWorkingDirPath))
+            {
+                TreeDefinition td = TreeDefinition.From(repo.Head.Tip.Tree);
+                Assert.NotNull(td[targetPath]);
+                Assert.Equal(GitObjectType.Commit, td[targetPath].Type);
+                Assert.Equal(Mode.GitLink, td[targetPath].Mode);
+
+                var objectId = new ObjectId(treeSha);
+                var tree = repo.Lookup<Tree>(objectId);
+
+                td.Add(targetPath, tree);
+
+                TreeEntryDefinition fetched = td[targetPath];
+                Assert.NotNull(fetched);
+
+                Assert.Equal(objectId, fetched.TargetId);
+                Assert.Equal(GitObjectType.Tree, fetched.Type);
+                Assert.Equal(Mode.Directory, fetched.Mode);
+            }
+        }
+
+        [Fact]
+        public void CanReplaceAnExistingBlobWithAGitLink()
+        {
+            const string targetPath = "just_a_file";
+
+            using (var repo = new Repository(SubmoduleTestRepoWorkingDirPath))
+            {
+                TreeDefinition td = TreeDefinition.From(repo.Head.Tip.Tree);
+                Assert.NotNull(td[targetPath]);
+                Assert.Equal(GitObjectType.Blob, td[targetPath].Type);
+
+                var gitLink = repo.Submodules["sm_unchanged"].GitLink;
+
+                td.Add(targetPath, gitLink);
+
+                TreeEntryDefinition fetched = td[targetPath];
+                Assert.NotNull(fetched);
+
+                Assert.Equal(GitObjectType.Commit, td[targetPath].Type);
+                Assert.Equal(gitLink.Id, fetched.TargetId);
+                Assert.Equal(Mode.GitLink, fetched.Mode);
+            }
+        }
+
+        [Fact]
+        public void CanReplaceAnExistingGitLinkWithABlob()
+        {
+            const string blobSha = "42cfb95cd01bf9225b659b5ee3edcc78e8eeb478";
+            const string targetPath = "sm_unchanged";
+
+            using (var repo = new Repository(SubmoduleTestRepoWorkingDirPath))
+            {
+                TreeDefinition td = TreeDefinition.From(repo.Head.Tip.Tree);
+                Assert.NotNull(td[targetPath]);
+                Assert.Equal(GitObjectType.Commit, td[targetPath].Type);
+                Assert.Equal(Mode.GitLink, td[targetPath].Mode);
+
+                var objectId = new ObjectId(blobSha);
+                var blob = repo.Lookup<Blob>(objectId);
+
+                td.Add(targetPath, blob, Mode.NonExecutableFile);
+
+                TreeEntryDefinition fetched = td[targetPath];
+                Assert.NotNull(fetched);
+
+                Assert.Equal(objectId, fetched.TargetId);
+                Assert.Equal(GitObjectType.Blob, fetched.Type);
+                Assert.Equal(Mode.NonExecutableFile, fetched.Mode);
+            }
+        }
+
         [Fact]
         public void CanNotReplaceAnExistingTreeWithATreeBeingAssembled()
         {

LibGit2Sharp/TreeDefinition.cs

@@ -159,6 +159,21 @@ public virtual TreeDefinition Add(string targetTreeEntryPath, string filePath, M
             return Add(targetTreeEntryPath, ted);
         }
 
+        /// <summary>
+        ///   Adds or replaces a <see cref="TreeEntryDefinition"/>, dynamically built from the provided <see cref="GitLink"/>, at the specified <paramref name="targetTreeEntryPath"/> location.
+        /// </summary>
+        /// <param name="targetTreeEntryPath">The path within this <see cref="TreeDefinition"/>.</param>
+        /// <param name="gitLink">The <see cref="GitLink"/> to be stored at the described location.</param>
+        /// <returns>The current <see cref="TreeDefinition"/>.</returns>
+        public virtual TreeDefinition Add(string targetTreeEntryPath, GitLink gitLink)
+        {
+            Ensure.ArgumentNotNull(gitLink, "gitLink");
+
+            var ted = TreeEntryDefinition.From(gitLink.Id);
+
+            return Add(targetTreeEntryPath, ted);
+        }
+
         /// <summary>
         ///   Adds or replaces a <see cref="TreeEntryDefinition"/>, dynamically built from the provided <see cref="Tree"/>, at the specified <paramref name="targetTreeEntryPath"/> location.
         /// </summary>
@@ -195,6 +210,7 @@ private TreeDefinition RetrieveOrBuildTreeDefinition(string treeName, bool shoul
                         break;
 
                     case GitObjectType.Blob:
+                    case GitObjectType.Commit:
                         if (shouldOverWrite)
                         {
                             td = new TreeDefinition();

LibGit2Sharp/TreeEntryDefinition.cs

@@ -76,6 +76,17 @@ internal static TreeEntryDefinition TransientBlobFrom(string filePath, Mode mode
                        };
         }
 
+        internal static TreeEntryDefinition From(ObjectId objectId)
+        {
+            return new TreeEntryDefinition
+                       {
+                           Mode = Mode.GitLink,
+                           Type = GitObjectType.Commit,
+                           TargetId = objectId,
+                           target = new Lazy<GitObject>(() => { throw new InvalidOperationException("Shouldn't be necessary."); }),
+                       };
+        }
+
         internal static TreeEntryDefinition From(Tree tree)
         {
             return new TreeEntryDefinition