C# Repository.ApplyTag方法代码示例

        public void CanFollowFirstParent()
        {
            string path = SandboxStandardTestRepo();
            using (var repo = new Repository(path))
            {
                var branch = repo.CreateBranch("branch");

                // Make an earlier tag on master
                repo.Commit("A", Constants.Signature, Constants.Signature, new CommitOptions { AllowEmptyCommit = true });
                repo.ApplyTag("firstParentTag");

                // Make a later tag on branch
                Commands.Checkout(repo, branch);
                repo.Commit("B", Constants.Signature, Constants.Signature, new CommitOptions { AllowEmptyCommit = true });
                repo.ApplyTag("mostRecentTag");

                Commands.Checkout(repo, "master");
                repo.Commit("C", Constants.Signature, Constants.Signature, new CommitOptions { AllowEmptyCommit = true });
                repo.Merge(branch, Constants.Signature, new MergeOptions() { FastForwardStrategy = FastForwardStrategy.NoFastForward });

                // With OnlyFollowFirstParent = false, the most recent tag reachable should be returned
                Assert.Equal("mostRecentTag-3-gf17be71", repo.Describe(repo.Head.Tip, new DescribeOptions { OnlyFollowFirstParent = false, Strategy = DescribeStrategy.Tags }));

                // With OnlyFollowFirstParent = true, the most recent tag on the current branch should be returned
                Assert.Equal("firstParentTag-2-gf17be71", repo.Describe(repo.Head.Tip, new DescribeOptions { OnlyFollowFirstParent = true, Strategy = DescribeStrategy.Tags }));

            }
        }

 protected static void AddTag(Repository repo, string tagName)
 {
     var randomFile = Path.Combine(repo.Info.WorkingDirectory, Guid.NewGuid().ToString());
     File.WriteAllText(randomFile, string.Empty);
     repo.Index.Stage(randomFile);
     var sign = SignatureBuilder.SignatureNow();
     repo.ApplyTag(tagName, repo.Head.Tip.Id.Sha, sign, "foo");
 }

        public void CanDescribeACommit()
        {
            string path = SandboxBareTestRepo();
            using (var repo = new Repository(path))
            {
                // No annotated tags can be used to describe "master"
                var masterTip = repo.Branches["master"].Tip;
                Assert.Throws<NotFoundException>(() => repo.Describe(masterTip));
                Assert.Equal("4c062a6", repo.Describe(masterTip,
                    new DescribeOptions { UseCommitIdAsFallback = true }));
                Assert.Equal("4c06", repo.Describe(masterTip,
                    new DescribeOptions { UseCommitIdAsFallback = true, MinimumCommitIdAbbreviatedSize = 2 }));

                // No lightweight tags can either be used to describe "master"
                Assert.Throws<NotFoundException>(() => repo.Describe(masterTip,
                    new DescribeOptions{ Strategy = DescribeStrategy.Tags }));

                repo.ApplyTag("myTag", "5b5b025afb0b4c913b4c338a42934a3863bf3644");
                Assert.Equal("myTag-5-g4c062a6", repo.Describe(masterTip,
                    new DescribeOptions { Strategy = DescribeStrategy.Tags }));
                Assert.Equal("myTag-5-g4c062a636", repo.Describe(masterTip,
                    new DescribeOptions { Strategy = DescribeStrategy.Tags, MinimumCommitIdAbbreviatedSize = 9 }));
                Assert.Equal("myTag-4-gbe3563a", repo.Describe(masterTip.Parents.Single(),
                    new DescribeOptions { Strategy = DescribeStrategy.Tags }));

                Assert.Equal("heads/master", repo.Describe(masterTip,
                    new DescribeOptions { Strategy = DescribeStrategy.All }));
                Assert.Equal("heads/packed-test-3-gbe3563a", repo.Describe(masterTip.Parents.Single(),
                    new DescribeOptions { Strategy = DescribeStrategy.All }));

                // "test" branch points to an annotated tag (also named "test")
                // Let's rename the branch to ease the understanding of what we
                // are exercising.

                repo.Branches.Rename(repo.Branches["test"], "ForLackOfABetterName");

                var anotherTip = repo.Branches["ForLackOfABetterName"].Tip;
                Assert.Equal("test", repo.Describe(anotherTip));
                Assert.Equal("test-0-g7b43849", repo.Describe(anotherTip,
                    new DescribeOptions{ AlwaysRenderLongFormat = true }));
            }
        }

        public void CanCreateAnAnnotatedTagPointingToATagAnnotation()
        {
            TemporaryCloneOfTestRepo path = BuildTemporaryCloneOfTestRepo();
            using (var repo = new Repository(path.RepositoryPath))
            {
                Tag annotatedTag = repo.Tags["e90810b"];
                TagAnnotation annotation = annotatedTag.Annotation;

                Tag tag = repo.ApplyTag("annotatedtag-tag", annotation.Sha, signatureNtk, "A new annotation");
                tag.ShouldNotBeNull();
                tag.IsAnnotated.ShouldBeTrue();
                tag.Annotation.Target.Id.ShouldEqual(annotation.Id);
                tag.Annotation.ShouldNotEqual(annotation);

                repo.Tags[tag.Name].ShouldEqual(tag);
            }
        }

        private static void FeedTheRepository(Repository repo)
        {
            string fullPath = Path.Combine(repo.Info.WorkingDirectory, "a.txt");
            File.WriteAllText(fullPath, "Hello\n");
            repo.Index.Stage(fullPath);
            repo.Commit("Initial commit", Constants.Signature, Constants.Signature);
            repo.ApplyTag("mytag");

            File.AppendAllText(fullPath, "World\n");
            repo.Index.Stage(fullPath);

            Signature shiftedSignature = Constants.Signature.TimeShift(TimeSpan.FromMinutes(1));
            repo.Commit("Update file", shiftedSignature, shiftedSignature);
            repo.CreateBranch("mybranch");

            repo.Checkout("mybranch");

            Assert.False(repo.Index.RetrieveStatus().IsDirty);
        }

        public void CanEnumerateCommitsFromATagWhichPointsToATree()
        {
            string path = CloneBareTestRepo();
            using (var repo = new Repository(path))
            {
                string headTreeSha = repo.Head.Tip.Tree.Sha;

                Tag tag = repo.ApplyTag("point_to_tree", headTreeSha);

                AssertEnumerationOfCommitsInRepo(repo,
                    r => new Filter { Since = tag },
                    new string[] { });
            }
        }

        public void CanCreateATagPointingToABlob()
        {
            TemporaryCloneOfTestRepo path = BuildTemporaryCloneOfTestRepo();
            using (var repo = new Repository(path.RepositoryPath))
            {
                Commit headCommit = repo.Head.Tip;
                Blob blob = headCommit.Tree.Blobs.First();

                Tag tag = repo.ApplyTag("blob-tag", blob.Sha);
                Assert.NotNull(tag);
                Assert.False(tag.IsAnnotated);
                Assert.Equal(blob.Id, tag.Target.Id);

                Assert.Equal(blob, repo.Lookup(tag.Target.Id));
                Assert.Equal(tag, repo.Tags[tag.Name]);
            }
        }

 public void CanCreateAnAnnotatedTagWithAnEmptyMessage()
 {
     TemporaryCloneOfTestRepo path = BuildTemporaryCloneOfTestRepo();
     using (var repo = new Repository(path.RepositoryPath))
     {
         Tag newTag = repo.ApplyTag("empty-annotated-tag", signatureNtk, string.Empty);
         Assert.NotNull(newTag);
         Assert.True(newTag.IsAnnotated);
         Assert.Equal(string.Empty, newTag.Annotation.Message);
     }
 }

        public void CanCreateATagUsingHead()
        {
            TemporaryCloneOfTestRepo path = BuildTemporaryCloneOfTestRepo();
            using (var repo = new Repository(path.RepositoryPath))
            {
                Tag tag = repo.ApplyTag("mytag", "HEAD");
                tag.ShouldNotBeNull();

                tag.Target.Id.ShouldEqual(repo.Head.Tip.Id);

                Tag retrievedTag = repo.Tags[tag.CanonicalName];
                tag.ShouldEqual(retrievedTag);
            }
        }

        public void CreatingALightweightTagPointingToATagAnnotationGeneratesAnAnnotatedTagReusingThePointedAtTagAnnotation()
        {
            TemporaryCloneOfTestRepo path = BuildTemporaryCloneOfTestRepo();
            using (var repo = new Repository(path.RepositoryPath))
            {
                Tag annotatedTag = repo.Tags["e90810b"];
                TagAnnotation annotation = annotatedTag.Annotation;

                Tag tag = repo.ApplyTag("lightweight-tag", annotation.Sha);
                tag.ShouldNotBeNull();
                tag.IsAnnotated.ShouldBeTrue();
                tag.Target.Id.ShouldEqual(annotation.Target.Id);
                tag.Annotation.ShouldEqual(annotation);

                repo.Lookup(tag.Annotation.Id).ShouldEqual(annotation);
                repo.Tags[tag.Name].ShouldEqual(tag);
            }
        }

        public void CreatingATagInAEmptyRepositoryThrows()
        {
            using (var scd = new SelfCleaningDirectory())
            {
                var dir = Repository.Init(scd.DirectoryPath);

                using (var repo = new Repository(dir))
                {
                    Assert.Throws<ApplicationException>(() => repo.ApplyTag("mynotag"));
                }
            }
        }

 public void CreatingATagWithANonValidNameShouldFail()
 {
     using (var path = new TemporaryCloneOfTestRepo())
     using (var repo = new Repository(path.RepositoryPath))
     {
         Assert.Throws<ArgumentException>(() => repo.ApplyTag(""));
         Assert.Throws<ApplicationException>(() => repo.ApplyTag(".othertag"));
         Assert.Throws<ApplicationException>(() => repo.ApplyTag("other tag"));
         Assert.Throws<ApplicationException>(() => repo.ApplyTag("othertag^"));
         Assert.Throws<ApplicationException>(() => repo.ApplyTag("other~tag"));
     }
 }

 public void CreatingATagForAnUnknowObjectIdShouldFail()
 {
     using (var path = new TemporaryCloneOfTestRepo())
     using (var repo = new Repository(path.RepositoryPath))
     {
         Assert.Throws<ApplicationException>(() => repo.ApplyTag("mytagnorev", Constants.UnknownSha));
     }
 }

 public void CreatingATagForAnUnknowReferenceShouldFail()
 {
     using (var path = new TemporaryCloneOfTestRepo())
     using (var repo = new Repository(path.RepositoryPath))
     {
         Assert.Throws<ApplicationException>(() => repo.ApplyTag("mytagnorev", "aaaaaaaaaaa"));
     }
 }

        public void CreatingADuplicateTagShouldFail()
        {
            using (var path = new TemporaryCloneOfTestRepo())
            using (var repo = new Repository(path.RepositoryPath))
            {
                repo.ApplyTag("mytag");

                Assert.Throws<ApplicationException>(() => repo.ApplyTag("mytag"));
            }
        }