Add git-based detection of tags at HEAD to improve PublicRelease detection

src/NerdBank.GitVersioning/GitContext.cs

@@ -100,6 +100,11 @@ public string RepoRelativeProjectDirectory
     /// </summary>
     public abstract string? HeadCanonicalName { get; }
 
+    /// <summary>
+    /// Gets a collection of the tags that reference HEAD.
+    /// </summary>
+    public abstract IReadOnlyCollection<string>? HeadTags { get; }
+
     /// <summary>
     /// Gets the path to the .git folder.
     /// </summary>

src/NerdBank.GitVersioning/LibGit2/LibGit2Context.cs

@@ -14,6 +14,11 @@ namespace Nerdbank.GitVersioning.LibGit2;
 [DebuggerDisplay("{" + nameof(DebuggerDisplay) + ",nq}")]
 public class LibGit2Context : GitContext
 {
+    /// <summary>
+    /// Caching field behind <see cref="HeadTags" /> property.
+    /// </summary>
+    private IReadOnlyCollection<string>? headTags;
+
     internal LibGit2Context(string workingTreeDirectory, string dotGitPath, string? committish = null)
         : base(workingTreeDirectory, dotGitPath)
     {
@@ -51,6 +56,20 @@ internal LibGit2Context(string workingTreeDirectory, string dotGitPath, string?
     /// <inheritdoc />
     public override string HeadCanonicalName => this.Repository.Head.CanonicalName;
 
+    /// <inheritdoc />
+    public override IReadOnlyCollection<string>? HeadTags
+    {
+        get
+        {
+            return this.headTags ??= this.Commit is not null
+                ? this.Repository.Tags
+                    .Where(tag => tag.Target.Sha.Equals(this.Commit.Sha))
+                    .Select(tag => tag.CanonicalName)
+                    .ToList()
+                : null;
+        }
+    }
+
     private string DebuggerDisplay => $"\"{this.WorkingTreePath}\" (libgit2)";
 
     /// <summary>Initializes a new instance of the <see cref="LibGit2Context"/> class.</summary>

src/NerdBank.GitVersioning/Managed/ManagedGitContext.cs

@@ -15,6 +15,11 @@ namespace Nerdbank.GitVersioning.Managed;
 [DebuggerDisplay("{" + nameof(DebuggerDisplay) + ",nq}")]
 public class ManagedGitContext : GitContext
 {
+    /// <summary>
+    /// Caching field behind <see cref="HeadTags" /> property.
+    /// </summary>
+    private IReadOnlyCollection<string>? headTags;
+
     internal ManagedGitContext(string workingDirectory, string dotGitPath, string? committish = null)
         : base(workingDirectory, dotGitPath)
     {
@@ -53,6 +58,12 @@ internal ManagedGitContext(string workingDirectory, string dotGitPath, string? c
     /// <inheritdoc />
     public override string HeadCanonicalName => this.Repository.GetHeadAsReferenceOrSha().ToString() ?? throw new InvalidOperationException("Unable to determine the HEAD position.");
 
+    /// <inheritdoc />
+    public override IReadOnlyCollection<string>? HeadTags
+    {
+        get => this.headTags ??= this.Repository.Lookup("HEAD") is GitObjectId head ? this.Repository.LookupTags(head) : null;
+    }
+
     private string DebuggerDisplay => $"\"{this.WorkingTreePath}\" (managed)";
 
     /// <summary>Initializes a new instance of the <see cref="ManagedGitContext"/> class.</summary>

src/NerdBank.GitVersioning/ManagedGit/GitAnnotatedTag.cs

@@ -0,0 +1,53 @@
+// Copyright (c) .NET Foundation and Contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+#nullable enable
+
+using System.Collections;
+
+namespace Nerdbank.GitVersioning.ManagedGit;
+
+/// <summary>
+/// Represents a Git annotated tag, as stored in the Git object database.
+/// </summary>
+public struct GitAnnotatedTag : IEquatable<GitAnnotatedTag>
+{
+    /// <summary>
+    /// Gets or sets the <see cref="GitObjectId"/> of object this tag is pointing at.
+    /// </summary>
+    public GitObjectId Object { get; set; }
+
+    /// <summary>
+    /// Gets or sets a <see cref="GitObjectId"/> which uniquely identifies the <see cref="GitAnnotatedTag"/>.
+    /// </summary>
+    public GitObjectId Sha { get; set; }
+
+    /// <summary>
+    /// Gets or sets the tag name of this annotated tag.
+    /// </summary>
+    public string Tag { get; set; }
+
+    /// <summary>
+    /// Gets or sets the type of the object this tag is pointing to, e.g. "commit" or, for nested tags, "tag".
+    /// </summary>
+    public string Type { get; set; }
+
+    public static bool operator ==(GitAnnotatedTag left, GitAnnotatedTag right) => left.Equals(right);
+
+    public static bool operator !=(GitAnnotatedTag left, GitAnnotatedTag right) => !(left == right);
+
+    /// <inheritdoc/>
+    public override bool Equals(object? obj) => obj is GitAnnotatedTag tag ? this.Equals(tag) : false;
+
+    /// <inheritdoc/>
+    public bool Equals(GitAnnotatedTag other) => this.Sha.Equals(other.Sha);
+
+    /// <inheritdoc/>
+    public override int GetHashCode() => this.Sha.GetHashCode();
+
+    /// <inheritdoc/>
+    public override string ToString()
+    {
+        return $"Git Tag: {this.Tag} with id {this.Sha}";
+    }
+}

src/NerdBank.GitVersioning/ManagedGit/GitAnnotatedTagReader.cs

@@ -0,0 +1,133 @@
+// Copyright (c) .NET Foundation and Contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+#nullable enable
+
+using System.Buffers;
+using System.Diagnostics;
+using System.Xml.Linq;
+using LibGit2Sharp;
+using Validation;
+
+namespace Nerdbank.GitVersioning.ManagedGit;
+
+/// <summary>
+/// Reads a <see cref="GitAnnotatedTag"/> object.
+/// </summary>
+public static class GitAnnotatedTagReader
+{
+    private const int ObjectLineLength = 48;
+
+    private static readonly byte[] ObjectStart = GitRepository.Encoding.GetBytes("object ");
+    private static readonly byte[] TypeStart = GitRepository.Encoding.GetBytes("type ");
+    private static readonly byte[] TagStart = GitRepository.Encoding.GetBytes("tag ");
+
+    /// <summary>
+    /// Reads a <see cref="GitAnnotatedTag"/> object from a <see cref="Stream"/>.
+    /// </summary>
+    /// <param name="stream">
+    /// A <see cref="Stream"/> which contains the <see cref="GitAnnotatedTag"/> in its text representation.
+    /// </param>
+    /// <param name="sha">
+    /// The <see cref="GitObjectId"/> of the commit.
+    /// </param>
+    /// <returns>
+    /// The <see cref="GitAnnotatedTag"/>.
+    /// </returns>
+    public static GitAnnotatedTag Read(Stream stream, GitObjectId sha)
+    {
+        Requires.NotNull(stream, nameof(stream));
+
+        byte[] buffer = ArrayPool<byte>.Shared.Rent(checked((int)stream.Length));
+
+        try
+        {
+            Span<byte> span = buffer.AsSpan(0, (int)stream.Length);
+            stream.ReadAll(span);
+
+            return Read(span, sha);
+        }
+        finally
+        {
+            ArrayPool<byte>.Shared.Return(buffer);
+        }
+    }
+
+    /// <summary>
+    /// Reads a <see cref="GitAnnotatedTag"/> object from a <see cref="ReadOnlySpan{T}"/>.
+    /// </summary>
+    /// <param name="tag">
+    /// A <see cref="ReadOnlySpan{T}"/> which contains the <see cref="GitAnnotatedTag"/> in its text representation.
+    /// </param>
+    /// <param name="sha">
+    /// The <see cref="GitObjectId"/> of the annotated tag.
+    /// </param>
+    /// <returns>
+    /// The <see cref="GitAnnotatedTag"/>.
+    /// </returns>
+    public static GitAnnotatedTag Read(ReadOnlySpan<byte> tag, GitObjectId sha)
+    {
+        ReadOnlySpan<byte> buffer = tag;
+
+        GitObjectId obj = ReadObject(buffer.Slice(0, ObjectLineLength));
+        buffer = buffer.Slice(ObjectLineLength);
+
+        (string type, int typeLen) = ReadType(buffer);
+        buffer = buffer.Slice(typeLen);
+
+        (string tagName, _) = ReadTag(buffer);
+
+        return new GitAnnotatedTag
+        {
+            Sha = sha,
+            Object = obj,
+            Type = type,
+            Tag = tagName,
+        };
+    }
+
+    private static GitObjectId ReadObject(ReadOnlySpan<byte> line)
+    {
+        // Format: object d8329fc1cc938780ffdd9f94e0d364e0ea74f579\n
+        // 48 bytes:
+        //  object: 6 bytes
+        //  space: 1 byte
+        //  hash: 40 bytes
+        //  \n: 1 byte
+        Debug.Assert(line.Slice(0, ObjectStart.Length).SequenceEqual(ObjectStart));
+        Debug.Assert(line[ObjectLineLength - 1] == (byte)'\n');
+
+        return GitObjectId.ParseHex(line.Slice(ObjectStart.Length, 40));
+    }
+
+    private static (string Content, int BytesRead) ReadPrefixedString(ReadOnlySpan<byte> remaining, byte[] prefix)
+    {
+        Debug.Assert(remaining.Slice(0, prefix.Length).SequenceEqual(prefix));
+
+        int lineEnd = remaining.IndexOf((byte)'\n');
+        ReadOnlySpan<byte> type = remaining.Slice(prefix.Length, lineEnd - prefix.Length);
+        return (GitRepository.GetString(type), lineEnd + 1);
+    }
+
+    private static (string Content, int BytesRead) ReadType(ReadOnlySpan<byte> remaining)
+    {
+        // Format: type commit\n
+        // <variable> bytes:
+        //  type: 4 bytes
+        //  space: 1 byte
+        //  <type e.g. commit>: <variable> bytes
+        //  \n: 1 byte
+        return ReadPrefixedString(remaining, TypeStart);
+    }
+
+    private static (string Content, int BytesRead) ReadTag(ReadOnlySpan<byte> remaining)
+    {
+        // Format: tag someAnnotatedTag\n
+        // <variable> bytes:
+        //  tag: 3 bytes
+        //  space: 1 byte
+        //  <tag name e.g. someAnnotatedTag>: <variable> bytes
+        //  \n: 1 byte
+        return ReadPrefixedString(remaining, TagStart);
+    }
+}

src/NerdBank.GitVersioning/ManagedGit/GitCommitReader.cs

@@ -123,8 +123,8 @@ public static GitCommit Read(ReadOnlySpan<byte> commit, GitObjectId sha, bool re
     private static GitObjectId ReadTree(ReadOnlySpan<byte> line)
     {
         // Format: tree d8329fc1cc938780ffdd9f94e0d364e0ea74f579\n
-        // 47 bytes:
-        //  tree: 5 bytes
+        // 46 bytes:
+        //  tree: 4 bytes
         //  space: 1 byte
         //  hash: 40 bytes
         //  \n: 1 byte

src/NerdBank.GitVersioning/ManagedGit/GitPack.cs

@@ -3,6 +3,7 @@
 
 #nullable enable
 
+using System.Diagnostics.CodeAnalysis;
 using System.IO.MemoryMappedFiles;
 using System.Text;
 
@@ -141,7 +142,7 @@ public GitPack(GetObjectFromRepositoryDelegate getObjectFromRepositoryDelegate,
     /// <returns>
     /// <see langword="true"/> if the object was found; otherwise, <see langword="false"/>.
     /// </returns>
-    public bool TryGetObject(GitObjectId objectId, string objectType, out Stream? value)
+    public bool TryGetObject(GitObjectId objectId, string objectType, [NotNullWhen(true)] out Stream? value)
     {
         long? offset = this.GetOffset(objectId);
 
@@ -152,8 +153,19 @@ public bool TryGetObject(GitObjectId objectId, string objectType, out Stream? va
         }
         else
         {
-            value = this.GetObject(offset.Value, objectType);
-            return true;
+            // This try-catch should probably be replaced by a non-throwing GetObject implementation.
+            // This is in turn dependend on a proper GitPackReader.TryGetObject implementation.
+            try
+            {
+                value = this.GetObject(offset.Value, objectType);
+                return true;
+            }
+            catch (GitException gexc)
+            when (gexc.ErrorCode == GitException.ErrorCodes.ObjectNotFound)
+            {
+                value = null;
+                return false;
+            }
         }
     }
 
@@ -199,6 +211,10 @@ public Stream GetObject(long offset, string objectType)
                 packObjectType = GitPackObjectType.OBJ_BLOB;
                 break;
 
+            case "tag":
+                packObjectType = GitPackObjectType.OBJ_TAG;
+                break;
+
             default:
                 throw new GitException($"The object type '{objectType}' is not supported by the {nameof(GitPack)} class.");
         }