Add a managed Git implementation

src/Directory.Build.props

@@ -4,7 +4,7 @@
     <BaseIntermediateOutputPath>$(MSBuildThisFileDirectory)..\obj\$(MSBuildProjectName)\</BaseIntermediateOutputPath>
     <OutputPath>$(MSBuildThisFileDirectory)..\bin\$(MSBuildProjectName)\$(Configuration)\</OutputPath>
     <DocumentationRootFolder>$(MSBuildThisFileDirectory)..\wiki\api</DocumentationRootFolder>
-    <LangVersion>7.3</LangVersion>
+    <LangVersion>8.0</LangVersion>
 
     <SignAssembly>true</SignAssembly>
     <AssemblyOriginatorKeyFile>$(MSBuildThisFileDirectory)strongname.snk</AssemblyOriginatorKeyFile>

src/NerdBank.GitVersioning.Benchmarks/GetVersionBenchmarks.cs

@@ -0,0 +1,44 @@
+using System;
+using System.IO;
+using BenchmarkDotNet.Attributes;
+using Nerdbank.GitVersioning;
+using NerdBank.GitVersioning.Managed;
+
+namespace NerdBank.GitVersioning.Benchmarks
+{
+    public class GetVersionBenchmarks
+    {
+        [Params(
+            "xunit;version.json",
+            "Cuemon;version.json",
+            "SuperSocket;version.json",
+            "NerdBank.GitVersioning;version.json")]
+        public string TestData;
+
+        public string RepositoryName => this.TestData.Split(';')[0];
+
+        public string VersionPath => this.TestData.Split(';')[1];
+
+        public string RepositoryPath => Path.Combine(
+                Environment.GetFolderPath(Environment.SpecialFolder.UserProfile),
+                @"Source\Repos",
+                this.RepositoryName);
+
+        public Version Version
+        { get; set; }
+
+        [Benchmark(Baseline = true)]
+        public void GetVersionLibGit2()
+        {
+            var oracle = LibGit2VersionOracle.CreateLibGit2(this.RepositoryPath);
+            this.Version = oracle.Version;
+        }
+
+        [Benchmark]
+        public void GetVersionManaged()
+        {
+            var oracle = ManagedVersionOracle.CreateManaged(this.RepositoryPath);
+            this.Version = oracle.Version;
+        }
+    }
+}

src/NerdBank.GitVersioning.Benchmarks/NerdBank.GitVersioning.Benchmarks.csproj

@@ -0,0 +1,27 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netcoreapp3.1</TargetFramework>
+    <OutputType>Exe</OutputType>
+  </PropertyGroup>
+
+  <PropertyGroup>
+    <PlatformTarget>AnyCPU</PlatformTarget>
+    <DebugType>portable</DebugType>
+    <DebugSymbols>true</DebugSymbols>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <Optimize>true</Optimize>
+    <Configuration>Release</Configuration>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="BenchmarkDotNet" Version="0.12.0" />
+    <PackageReference Include="BenchmarkDotNet.Diagnostics.Windows" Version="0.12.0" />
+    <PackageReference Include="Nerdbank.GitVersioning.LKG" Version="3.1.93" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="../NerdBank.GitVersioning/NerdBank.GitVersioning.csproj" />
+  </ItemGroup>
+
+</Project>

src/NerdBank.GitVersioning.Benchmarks/Program.cs

@@ -0,0 +1,13 @@
+using System;
+using BenchmarkDotNet.Running;
+
+namespace NerdBank.GitVersioning.Benchmarks
+{
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            var summary = BenchmarkRunner.Run<GetVersionBenchmarks>();
+        }
+    }
+}

src/NerdBank.GitVersioning.Tests/Managed/.gitattributes

@@ -0,0 +1,2 @@
+commit-* text eol=lf
+tree-* text eol=lf

src/NerdBank.GitVersioning.Tests/Managed/DeltaStreamReaderTests.cs

@@ -0,0 +1,92 @@
+using System.Collections.ObjectModel;
+using System.IO;
+using NerdBank.GitVersioning.Managed;
+using Xunit;
+
+namespace NerdBank.GitVersioning.Tests.Managed
+{
+    // Test case borrowed from https://stefan.saasen.me/articles/git-clone-in-haskell-from-the-bottom-up/#format-of-the-delta-representation
+    public class DeltaStreamReaderTests
+    {
+        [Fact]
+        public void ReadCopyInstruction()
+        {
+            using (Stream stream = new MemoryStream(
+                new byte[]
+                {
+                    0b_10110000,
+                    0b_11010001,
+                    0b_00000001
+                }))
+            {
+                var instruction = DeltaStreamReader.Read(stream).Value;
+
+                Assert.Equal(DeltaInstructionType.Copy, instruction.InstructionType);
+                Assert.Equal(0, instruction.Offset);
+                Assert.Equal(465, instruction.Size);
+            }
+        }
+
+        [Fact]
+        public void ReadInsertInstruction()
+        {
+            using (Stream stream = new MemoryStream(new byte[] { 0b_00010111 }))
+            {
+                var instruction = DeltaStreamReader.Read(stream).Value;
+
+                Assert.Equal(DeltaInstructionType.Insert, instruction.InstructionType);
+                Assert.Equal(0, instruction.Offset);
+                Assert.Equal(23, instruction.Size);
+            }
+        }
+
+        [Fact]
+        public void ReadStreamTest()
+        {
+            using (Stream stream = new MemoryStream(
+                new byte[]
+                {
+                    0b_10110011, 0b_11001110, 0b_00000001, 0b_00100111, 0b_00000001,
+                    0b_10110011, 0b_01011111, 0b_00000011, 0b_01101100, 0b_00010000, 0b_10010011,
+                    0b_11110101, 0b_00000010, 0b_01101011, 0b_10110011, 0b_11001011, 0b_00010011,
+                    0b_01000110, 0b_00000011}))
+            {
+                Collection<DeltaInstruction> instructions = new Collection<DeltaInstruction>();
+
+                DeltaInstruction? current;
+
+                while ((current = DeltaStreamReader.Read(stream)) != null)
+                {
+                    instructions.Add(current.Value);
+                }
+
+                Assert.Collection(
+                    instructions,
+                    instruction =>
+                    {
+                        Assert.Equal(DeltaInstructionType.Copy, instruction.InstructionType);
+                        Assert.Equal(462, instruction.Offset);
+                        Assert.Equal(295, instruction.Size);
+                    },
+                    instruction =>
+                    {
+                        Assert.Equal(DeltaInstructionType.Copy, instruction.InstructionType);
+                        Assert.Equal(863, instruction.Offset);
+                        Assert.Equal(4204, instruction.Size);
+                    },
+                    instruction =>
+                    {
+                        Assert.Equal(DeltaInstructionType.Copy, instruction.InstructionType);
+                        Assert.Equal(757, instruction.Offset);
+                        Assert.Equal(107, instruction.Size);
+                    },
+                    instruction =>
+                    {
+                        Assert.Equal(DeltaInstructionType.Copy, instruction.InstructionType);
+                        Assert.Equal(5067, instruction.Offset);
+                        Assert.Equal(838, instruction.Size);
+                    });
+            }
+        }
+    }
+}

src/NerdBank.GitVersioning.Tests/Managed/GitCommitReaderTests.cs

@@ -0,0 +1,33 @@
+using System;
+using System.IO;
+using NerdBank.GitVersioning.Managed;
+using Xunit;
+
+namespace NerdBank.GitVersioning.Tests.Managed
+{
+    public class GitCommitReaderTests
+    {
+        [Fact]
+        public void ReadTest()
+        {
+            using (Stream stream = TestUtilities.GetEmbeddedResource(@"Managed\commit-d56dc3ed179053abef2097d1120b4507769bcf1a"))
+            {
+                var commit = GitCommitReader.Read(stream, GitObjectId.Parse("d56dc3ed179053abef2097d1120b4507769bcf1a"));
+
+                Assert.Equal("d56dc3ed179053abef2097d1120b4507769bcf1a", commit.Sha.ToString());
+                Assert.Equal("f914b48023c7c804a4f3be780d451f31aef74ac1", commit.Tree.ToString());
+
+                Assert.Collection(
+                    commit.Parents,
+                    c => Assert.Equal("4497b0eaaa89abf0e6d70961ad5f04fd3a49cbc6", c.ToString()),
+                    c => Assert.Equal("0989e8fe0cd0e0900173b26decdfb24bc0cc8232", c.ToString()));
+
+                Assert.Equal("Andrew Arnott", commit.Author.Name);
+                Assert.Equal(new DateTimeOffset(2020, 10, 6, 13, 40, 09, TimeSpan.FromHours(-6)), commit.Author.Date);
+                Assert.Equal("[email protected]", commit.Author.Email);
+
+                // Committer and commit message are not read
+            }
+        }
+    }
+}

src/NerdBank.GitVersioning.Tests/Managed/GitCommitTests.cs

@@ -0,0 +1,98 @@
+using NerdBank.GitVersioning.Managed;
+using Xunit;
+
+namespace NerdBank.GitVersioning.Tests.Managed
+{
+    public class GitCommitTests
+    {
+        private readonly byte[] shaAsByteArray = new byte[] { 0x4e, 0x91, 0x27, 0x36, 0xc2, 0x7e, 0x40, 0xb3, 0x89, 0x90, 0x4d, 0x04, 0x6d, 0xc6, 0x3d, 0xc9, 0xf5, 0x78, 0x11, 0x7f };
+
+        [Fact]
+        public void EqualsObjectTest()
+        {
+            var commit = new GitCommit()
+            {
+                Sha = GitObjectId.Parse(this.shaAsByteArray),
+            };
+
+            var commit2 = new GitCommit()
+            {
+                Sha = GitObjectId.Parse(this.shaAsByteArray),
+            };
+
+            var emptyCommit = new GitCommit()
+            {
+                Sha = GitObjectId.Empty,
+            };
+
+            // Must be equal to itself
+            Assert.True(commit.Equals((object)commit));
+            Assert.True(commit.Equals((object)commit2));
+
+            // Not equal to null
+            Assert.False(commit.Equals(null));
+
+            // Not equal to other representations of the commit
+            Assert.False(commit.Equals(this.shaAsByteArray));
+            Assert.False(commit.Equals(commit.Sha));
+
+            // Not equal to other object ids
+            Assert.False(commit.Equals((object)emptyCommit));
+        }
+
+        [Fact]
+        public void EqualsCommitTest()
+        {
+            var commit = new GitCommit()
+            {
+                Sha = GitObjectId.Parse(this.shaAsByteArray),
+            };
+
+            var commit2 = new GitCommit()
+            {
+                Sha = GitObjectId.Parse(this.shaAsByteArray),
+            };
+
+            var emptyCommit = new GitCommit()
+            {
+                Sha = GitObjectId.Empty,
+            };
+
+            // Must be equal to itself
+            Assert.True(commit.Equals(commit2));
+            Assert.True(commit.Equals(commit2));
+
+            // Not equal to other object ids
+            Assert.False(commit.Equals(emptyCommit));
+        }
+
+        [Fact]
+        public void GetHashCodeTest()
+        {
+            var commit = new GitCommit()
+            {
+                Sha = GitObjectId.Parse(this.shaAsByteArray),
+            };
+
+            var emptyCommit = new GitCommit()
+            {
+                Sha = GitObjectId.Empty,
+            };
+
+            // The hash code is the int32 representation of the first 4 bytes of the SHA hash
+            Assert.Equal(0x3627914e, commit.GetHashCode());
+            Assert.Equal(0, emptyCommit.GetHashCode());
+        }
+
+        [Fact]
+        public void ToStringTest()
+        {
+            var commit = new GitCommit()
+            {
+                Sha = GitObjectId.Parse(this.shaAsByteArray),
+            };
+
+            Assert.Equal("Git Commit: 4e912736c27e40b389904d046dc63dc9f578117f", commit.ToString());
+        }
+    }
+}