GitRepository: Implement Lookup() for partial Git object IDs

Author: qmfrederik

src/NerdBank.GitVersioning.Tests/GitContextTests.cs

@@ -75,6 +75,10 @@ public void SelectCommitByPartialId(bool fromPack)
             {
                 TestUtilities.DeleteDirectory(obDirectory);
             }
+
+            // The managed git context always assumes read-only access. It won't detect a new Git pack file being
+            // created on the fly, so we have to re-initialize.
+            this.Context = this.CreateGitContext(this.RepoPath, null);
         }
 
         Assert.True(this.Context.TrySelectCommit(this.Context.GitCommitId.Substring(0, 12)));

src/NerdBank.GitVersioning.Tests/ManagedGit/GitPackIndexMappedReaderTests.cs

@@ -10,7 +10,7 @@ public class GitPackIndexMappedReaderTests
         [Fact]
         public void ConstructorNullTest()
         {
-            Assert.Throws<ArgumentNullException>(() => new GitPackIndexStreamReader(null));
+            Assert.Throws<ArgumentNullException>(() => new GitPackIndexMappedReader(null));
         }
 
         [Fact]
@@ -45,5 +45,45 @@ public void GetOffsetTest()
             }
 
         }
+
+        [Fact]
+        public void GetOffsetFromPartialTest()
+        {
+            var indexFile = Path.GetTempFileName();
+
+            using (Stream resourceStream = TestUtilities.GetEmbeddedResource(@"ManagedGit\pack-7d6b2c56ffb97eedb92f4e28583c093f7ee4b3d9.idx"))
+            using (FileStream stream = File.Open(indexFile, FileMode.Open))
+            {
+                resourceStream.CopyTo(stream);
+            }
+
+            using (FileStream stream = File.OpenRead(indexFile))
+            using (var reader = new GitPackIndexMappedReader(stream))
+            {
+                // Offset of an object which is present
+                (var offset, var objectId) = reader.GetOffset(new byte[] { 0xf5, 0xb4, 0x01, 0xf4 });
+                Assert.Equal(12, offset);
+                Assert.Equal(GitObjectId.Parse("f5b401f40ad83f13030e946c9ea22cb54cb853cd"), objectId);
+
+                (offset, objectId) = reader.GetOffset(new byte[] { 0xd6, 0x78, 0x15, 0x52 });
+                Assert.Equal(317, offset);
+                Assert.Equal(GitObjectId.Parse("d6781552a0a94adbf73ed77696712084754dc274"), objectId);
+
+                // null for an object which is not present
+                (offset, objectId) = reader.GetOffset(new byte[] { 0x00, 0x00, 0x00, 0x00 });
+                Assert.Null(offset);
+                Assert.Null(objectId);
+            }
+
+            try
+            {
+                File.Delete(indexFile);
+            }
+            catch (UnauthorizedAccessException)
+            {
+                // TBD: Figure out what's keeping a lock on the file. Seems to be unique to Windows.
+            }
+
+        }
     }
 }

src/NerdBank.GitVersioning/ManagedGit/GitPack.cs

@@ -124,6 +124,22 @@ public GitPack(GetObjectFromRepositoryDelegate getObjectFromRepositoryDelegate,
         /// </summary>
         public GetObjectFromRepositoryDelegate GetObjectFromRepository { get; private set; }
 
+        /// <summary>
+        /// Finds a git object using a partial object ID.
+        /// </summary>
+        /// <param name="objectId">
+        /// A partial object ID.
+        /// </param>
+        /// <returns>
+        /// If found, a full object ID which matches the partial object ID.
+        /// Otherwise, <see langword="false"/>.
+        /// </returns>
+        public GitObjectId? Lookup(Span<byte> objectId)
+        {
+            (var _, var actualObjectId) = this.indexReader.Value.GetOffset(objectId);
+            return actualObjectId;
+        }
+
         /// <summary>
         /// Attempts to retrieve a Git object from this Git pack.
         /// </summary>

src/NerdBank.GitVersioning/ManagedGit/GitPackIndexMappedReader.cs

@@ -51,13 +51,11 @@ private Span<byte> Value
         }
 
         /// <inheritdoc/>
-        public override long? GetOffset(GitObjectId objectId)
+        public override (long?, GitObjectId?) GetOffset(Span<byte> objectName)
         {
             this.Initialize();
 
             Span<byte> buffer = stackalloc byte[4];
-            Span<byte> objectName = stackalloc byte[20];
-            objectId.CopyTo(objectName);
 
             var packStart = this.fanoutTable[objectName[0]];
             var packEnd = this.fanoutTable[objectName[0] + 1];
@@ -84,7 +82,7 @@ private Span<byte> Value
             {
                 i = (packStart + packEnd) / 2;
 
-                order = table.Slice(20 * i, 20).SequenceCompareTo(objectName);
+                order = table.Slice(20 * i, objectName.Length).SequenceCompareTo(objectName);
 
                 if (order < 0)
                 {
@@ -102,7 +100,7 @@ private Span<byte> Value
 
             if (order != 0)
             {
-                return null;
+                return (null, null);
             }
 
             // Get the offset value. It's located at:
@@ -113,7 +111,7 @@ private Span<byte> Value
 
             if (offsetBuffer[0] < 128)
             {
-                return offset;
+                return (offset, GitObjectId.Parse(table.Slice(20 * i, 20)));
             }
             else
             {
@@ -123,7 +121,7 @@ private Span<byte> Value
 
                 offsetBuffer = this.Value.Slice(offsetTableStart + 4 * objectCount + 8 * (int)offset, 8);
                 var offset64 = BinaryPrimitives.ReadInt64BigEndian(offsetBuffer);
-                return offset64;
+                return (offset64, GitObjectId.Parse(table.Slice(20 * i, 20)));
             }
         }
 

src/NerdBank.GitVersioning/ManagedGit/GitPackIndexReader.cs

@@ -1,6 +1,4 @@
 using System;
-using System.Collections.Generic;
-using System.Text;
 
 namespace Nerdbank.GitVersioning.ManagedGit
 {
@@ -25,7 +23,25 @@ public abstract class GitPackIndexReader : IDisposable
         /// If found, the offset of the Git object in the index file; otherwise,
         /// <see langword="null"/>.
         /// </returns>
-        public abstract long? GetOffset(GitObjectId objectId);
+        public long? GetOffset(GitObjectId objectId)
+        {
+            Span<byte> name = stackalloc byte[20];
+            objectId.CopyTo(name);
+            (var offset, var _) = this.GetOffset(name);
+            return offset;
+        }
+
+        /// <summary>
+        /// Gets the offset of a Git object in the index file.
+        /// </summary>
+        /// <param name="objectId">
+        /// A partial or full Git object id, in its binary representation.
+        /// </param>
+        /// <returns>
+        /// If found, the offset of the Git object in the index file; otherwise,
+        /// <see langword="null"/>.
+        /// </returns>
+        public abstract (long?, GitObjectId?) GetOffset(Span<byte> objectId);
 
         /// <inheritdoc/>
         public abstract void Dispose();

src/NerdBank.GitVersioning/ManagedGit/GitRepository.cs

@@ -1,9 +1,9 @@
 #nullable enable
 
 using System;
-using System.Buffers;
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
+using System.Globalization;
 using System.IO;
 using System.Linq;
 using System.Text;
@@ -374,6 +374,44 @@ public GitCommit GetCommit(GitObjectId sha, bool readAuthor = false)
                 return GitObjectId.Parse(objectish);
             }
 
+            var possibleObjectIds = new List<GitObjectId>();
+            if (objectish.Length > 2 && objectish.Length < 40)
+            {
+                // Search for _any_ object whose id starts with objectish in the object database
+                var directory = Path.Combine(this.ObjectDirectory, objectish.Substring(0, 2));
+
+                if (Directory.Exists(directory))
+                {
+                    var files = Directory.GetFiles(directory, $"{objectish.Substring(2)}*");
+
+                    foreach (var file in files)
+                    {
+                        var objectId = $"{objectish.Substring(0, 2)}{Path.GetFileName(file)}";
+                        possibleObjectIds.Add(GitObjectId.Parse(objectId));
+                    }
+                }
+
+                // Search for _any_ object whose id starts with objectish in the packfile
+                var hex = ConvertHexStringToByteArray(objectish);
+
+                foreach (var pack in this.packs.Value)
+                {
+                    var objectId = pack.Lookup(hex);
+
+                    // It's possible for the same object to be present in both the object database and the pack files,
+                    // or in multiple pack files.
+                    if (objectId != null && !possibleObjectIds.Contains(objectId.Value))
+                    {
+                        possibleObjectIds.Add(objectId.Value);
+                    }
+                }
+            }
+
+            if (possibleObjectIds.Count == 1)
+            {
+                return possibleObjectIds[0];
+            }
+
             return null;
         }
 
@@ -652,6 +690,24 @@ private static string TrimEndingDirectorySeparator(string path)
 #endif
         }
 
+        private static byte[] ConvertHexStringToByteArray(string hexString)
+        {
+            // https://stackoverflow.com/questions/321370/how-can-i-convert-a-hex-string-to-a-byte-array
+            if (hexString.Length % 2 != 0)
+            {
+                throw new ArgumentException(string.Format(CultureInfo.InvariantCulture, "The binary key cannot have an odd number of digits: {0}", hexString));
+            }
+
+            byte[] data = new byte[hexString.Length / 2];
+            for (int index = 0; index < data.Length; index++)
+            {
+                string byteValue = hexString.Substring(index * 2, 2);
+                data[index] = byte.Parse(byteValue, NumberStyles.HexNumber, CultureInfo.InvariantCulture);
+            }
+
+            return data;
+        }
+
         /// <summary>
         /// Decodes a sequence of bytes from the specified byte array into a <see cref="string"/>.
         /// </summary>