Add subdirectory-scoped loading to LoadFromLocalFiles with tests

Copilot · Viir · Viir · commit dcf38a123c86 · 2026-03-28T20:57:11.000Z
Agent-Logs-Url: https://github.com/Viir/super-gitcore/sessions/dc5e9d94-d5f6-4842-acce-d0823d169fc2 Co-authored-by: Viir <19209696+Viir@users.noreply.github.com>
diff --git a/README.md b/README.md
@@ -9,6 +9,7 @@ Pure managed C# implementation for reading from Git repositories.
 + Reading from local Git repositories
   + Resolve HEAD and other references to commit SHAs.
   + Load all files from any commit's tree.
+  + Load files from a specific subdirectory within a commit's tree.
   + Supports both loose objects and pack files.
 + Cloning via [Git Smart HTTP](https://git-scm.com/book/en/v2/Git-on-the-Server-Smart-HTTP)
   + Efficient partial cloning of subdirectories.
@@ -34,6 +35,17 @@ var filesAtHead = GitCore.LoadFromLocalFiles.LoadTreeContentsFromHead(gitDir);
 var commitSha = GitCore.LoadFromLocalFiles.ResolveHead(gitDir);
 var filesAtCommit = GitCore.LoadFromLocalFiles.LoadTreeContentsFromCommit(gitDir, commitSha);
 
+// Load only files under a specific subdirectory (paths relative to subdirectory)
+var subdirFiles = GitCore.LoadFromLocalFiles.LoadSubdirectoryContentsFromHead(
+    gitDir,
+    ["implement", "Pine.Core"]);
+
+// Or from a specific commit
+var subdirFilesAtCommit = GitCore.LoadFromLocalFiles.LoadSubdirectoryContentsFromCommit(
+    gitDir,
+    commitSha,
+    ["implement", "Pine.Core"]);
+
 // Resolve any reference (branch, tag, etc.)
 var branchSha = GitCore.LoadFromLocalFiles.ResolveReference(gitDir, "refs/heads/main");
 
diff --git a/implement/GitCore.IntegrationTests/LoadFromLocalFilesTests.cs b/implement/GitCore.IntegrationTests/LoadFromLocalFilesTests.cs
@@ -1,7 +1,9 @@
 using AwesomeAssertions;
 using System;
+using System.Collections.Generic;
 using System.Diagnostics;
 using System.IO;
+using System.Linq;
 using System.Security.Cryptography;
 using Xunit;
 
@@ -327,6 +329,128 @@ public void Load_tree_contents_from_head()
         }
     }
 
+    [Fact]
+    public void Load_subdirectory_contents_from_known_commit()
+    {
+        var gitDir = _fixture.GitDirectory;
+
+        // Use commit 0166a832097feb94bd565354b31559ccb355e0be ("parse commit properties and add API for reading commits") on main
+        var commitSha = "0166a832097feb94bd565354b31559ccb355e0be";
+
+        var subdirContents =
+            LoadFromLocalFiles.LoadSubdirectoryContentsFromCommit(
+                gitDir,
+                commitSha,
+                ["implement", "GitCore"]);
+
+        subdirContents.Should().NotBeNull("Subdirectory contents should be loaded");
+        subdirContents.Count.Should().Be(9, "implement/GitCore should contain 9 files at this commit");
+
+        // Verify well-known files exist with paths relative to the subdirectory
+        subdirContents.Should().ContainKey(["GitCore.csproj"]);
+        subdirContents.Should().ContainKey(["README.md"]);
+        subdirContents.Should().ContainKey(["Repository.cs"]);
+        subdirContents.Should().ContainKey(["GitObjects.cs"]);
+        subdirContents.Should().ContainKey(["LoadFromUrl.cs"]);
+        subdirContents.Should().ContainKey(["PackFile.cs"]);
+        subdirContents.Should().ContainKey(["PackIndex.cs"]);
+        subdirContents.Should().ContainKey(["GitSmartHttp.cs"]);
+        subdirContents.Should().ContainKey(["Common", "EnumerableExtensions.cs"]);
+
+        // Verify SHA256 hashes of file contents
+        ComputeSha256Hex(subdirContents[["GitCore.csproj"]]).Should().Be(
+            "892f9343f5165b461aef51aefd841a78eb1faa73a1ef678d2eadeb0f6dbe2906",
+            "SHA256 of GitCore.csproj should match");
+
+        ComputeSha256Hex(subdirContents[["README.md"]]).Should().Be(
+            "141f37bb8117bbb98551399270e5b12a0da4767e27bfa63366b72c668b1ccb62",
+            "SHA256 of README.md should match");
+
+        ComputeSha256Hex(subdirContents[["Repository.cs"]]).Should().Be(
+            "9b183d06142d2fc597d5cb935850fc1770b6be1651156c8665553a13e787bfc0",
+            "SHA256 of Repository.cs should match");
+    }
+
+    [Fact]
+    public void Load_subdirectory_contents_from_head()
+    {
+        var gitDir = _fixture.GitDirectory;
+        var repoDir = _fixture.RepoDirectory;
+
+        var subdirContents =
+            LoadFromLocalFiles.LoadSubdirectoryContentsFromHead(
+                gitDir,
+                ["implement", "GitCore"]);
+
+        subdirContents.Should().NotBeNull("Subdirectory contents should be loaded from HEAD");
+        subdirContents.Count.Should().BeGreaterThan(0, "Subdirectory should contain files");
+
+        // Verify well-known files exist with paths relative to the subdirectory
+        subdirContents.Should().ContainKey(["GitCore.csproj"]);
+        subdirContents.Should().ContainKey(["README.md"]);
+
+        // Verify SHA256 hashes of file contents match git executable output
+        foreach (var fileName in new[] { "GitCore.csproj", "README.md" })
+        {
+            var gitContent = RunGitCommandBytes(repoDir, $"show HEAD:implement/GitCore/{fileName}");
+            var expectedSha256 = Convert.ToHexStringLower(SHA256.HashData(gitContent));
+
+            ComputeSha256Hex(subdirContents[[fileName]]).Should().Be(
+                expectedSha256,
+                $"SHA256 of {fileName} from GitCore should match git show output");
+        }
+    }
+
+    [Fact]
+    public void Load_subdirectory_contents_matches_full_tree_filtered()
+    {
+        var gitDir = _fixture.GitDirectory;
+
+        // Use commit 0166a832097feb94bd565354b31559ccb355e0be ("parse commit properties and add API for reading commits") on main
+        var commitSha = "0166a832097feb94bd565354b31559ccb355e0be";
+
+        // Load all files, then filter to the subdirectory
+        var allFiles = LoadFromLocalFiles.LoadTreeContentsFromCommit(gitDir, commitSha);
+
+        var filteredFiles =
+            new Dictionary<IReadOnlyList<string>, ReadOnlyMemory<byte>>(
+                comparer: GitCore.Common.EnumerableExtensions.EqualityComparer<IReadOnlyList<string>>());
+
+        foreach (var kvp in allFiles)
+        {
+            if (kvp.Key.Count >= 3 &&
+                kvp.Key[0] == "implement" &&
+                kvp.Key[1] == "GitCore")
+            {
+                filteredFiles[(IReadOnlyList<string>)kvp.Key.Skip(2).ToArray()] = kvp.Value;
+            }
+        }
+
+        // Load subdirectory contents directly
+        var subdirFiles =
+            LoadFromLocalFiles.LoadSubdirectoryContentsFromCommit(
+                gitDir,
+                commitSha,
+                ["implement", "GitCore"]);
+
+        // Both approaches should return the same number of files
+        subdirFiles.Count.Should().Be(
+            filteredFiles.Count,
+            "Subdirectory loading should return the same number of files as filtering the full tree");
+
+        // Verify each file matches
+        foreach (var kvp in filteredFiles)
+        {
+            subdirFiles.Should().ContainKey(
+                kvp.Key,
+                $"File {string.Join("/", kvp.Key)} should exist in subdirectory contents");
+
+            ComputeSha256Hex(subdirFiles[kvp.Key]).Should().Be(
+                ComputeSha256Hex(kvp.Value),
+                $"Content of {string.Join("/", kvp.Key)} should match between full tree and subdirectory loading");
+        }
+    }
+
     [Fact]
     public void FindGitDirectoryUpwards_from_repository_root_finds_git_directory()
     {
@@ -352,7 +476,9 @@ public void FindGitDirectoryUpwards_from_subdirectory_finds_git_directory()
 
         result.Should().NotBeNull("Should find .git from a subdirectory");
         result.Should().Be(_fixture.GitDirectory, "Should find the correct .git directory");
-        checkedPaths.Count.Should().BeGreaterThan(1,
+
+        checkedPaths.Count.Should().BeGreaterThan(
+            1,
             "Should have checked more than one path when starting below the repo root");
     }
 
@@ -396,9 +522,12 @@ public void FindGitDirectoryUpwards_empty_git_directory_is_skipped()
             var result = LoadFromLocalFiles.FindGitDirectoryUpwards(tempDir, out var checkedPaths);
 
             // The empty .git directory should have been checked but not returned
-            checkedPaths.Should().Contain(Path.Combine(tempDir, ".git"),
+            checkedPaths.Should().Contain(
+                Path.Combine(tempDir, ".git"),
                 "Should have checked the empty .git directory");
-            result.Should().NotBe(Path.Combine(tempDir, ".git"),
+
+            result.Should().NotBe(
+                Path.Combine(tempDir, ".git"),
                 "Should not return an empty .git directory");
         }
         finally
diff --git a/implement/GitCore/GitCore.csproj b/implement/GitCore/GitCore.csproj
@@ -11,10 +11,10 @@
   </ItemGroup>
 
   <PropertyGroup>
-    <AssemblyVersion>0.2.3</AssemblyVersion>
-    <FileVersion>0.2.3</FileVersion>
+    <AssemblyVersion>0.2.4</AssemblyVersion>
+    <FileVersion>0.2.4</FileVersion>
     <PackageId>GitCore</PackageId>
-    <Version>0.2.3</Version>
+    <Version>0.2.4</Version>
     <Description>Pure managed C# implementation for reading from Git repositories</Description>
     <PackageTags>git;clone;github;gitlab;network;transport;checkout</PackageTags>
     <RepositoryUrl>https://github.com/Viir/GitCore.git</RepositoryUrl>
diff --git a/implement/GitCore/LoadFromLocalFiles.cs b/implement/GitCore/LoadFromLocalFiles.cs
@@ -187,6 +187,73 @@ public static IReadOnlyDictionary<FilePath, ReadOnlyMemory<byte>> LoadTreeConten
         return LoadTreeContentsFromCommit(gitDirectory, commitSha);
     }
 
+    /// <summary>
+    /// Loads file contents from a subdirectory within the tree of a specific commit
+    /// in a local repository. Only blobs under the specified subdirectory are materialized.
+    /// </summary>
+    /// <param name="gitDirectory">Path to the .git directory.</param>
+    /// <param name="commitSha">
+    /// The 40-character hex SHA of the commit.
+    /// Use <see cref="ResolveReference"/> to obtain this from HEAD or a branch name.
+    /// </param>
+    /// <param name="subdirectoryPath">
+    /// Path components from the repository root to the subdirectory to load.
+    /// For example, ["implement", "GitCore"] loads only files under implement/GitCore/.
+    /// </param>
+    /// <returns>
+    /// A dictionary mapping file paths (relative to the subdirectory, as lists of path
+    /// components) to file contents. Only blob entries are included.
+    /// </returns>
+    public static IReadOnlyDictionary<FilePath, ReadOnlyMemory<byte>> LoadSubdirectoryContentsFromCommit(
+        string gitDirectory,
+        string commitSha,
+        IReadOnlyList<string> subdirectoryPath)
+    {
+        var repository = LoadRepository(gitDirectory);
+
+        var commitObject =
+            repository.GetObject(commitSha)
+            ?? throw new InvalidOperationException($"Commit {commitSha} not found in repository");
+
+        if (commitObject.Type is not PackFile.ObjectType.Commit)
+        {
+            throw new InvalidOperationException($"Object {commitSha} is not a commit");
+        }
+
+        var commit = GitObjects.ParseCommit(commitObject.Data);
+
+        return
+            GitObjects.GetFilesFromSubdirectory(
+                commit.TreeHash,
+                subdirectoryPath,
+                sha => repository.GetObject(sha));
+    }
+
+    /// <summary>
+    /// Loads file contents from a subdirectory within the tree at the current HEAD
+    /// of a local repository. Only blobs under the specified subdirectory are materialized.
+    /// This is a convenience method that resolves HEAD and then loads the subdirectory.
+    /// </summary>
+    /// <param name="gitDirectory">Path to the .git directory.</param>
+    /// <param name="subdirectoryPath">
+    /// Path components from the repository root to the subdirectory to load.
+    /// For example, ["implement", "GitCore"] loads only files under implement/GitCore/.
+    /// </param>
+    /// <returns>
+    /// A dictionary mapping file paths (relative to the subdirectory, as lists of path
+    /// components) to file contents. Only blob entries are included.
+    /// </returns>
+    public static IReadOnlyDictionary<FilePath, ReadOnlyMemory<byte>> LoadSubdirectoryContentsFromHead(
+        string gitDirectory,
+        IReadOnlyList<string> subdirectoryPath)
+    {
+        var commitSha =
+            ResolveHead(gitDirectory)
+            ?? throw new InvalidOperationException("Could not resolve HEAD to a commit SHA");
+
+        return LoadSubdirectoryContentsFromCommit(gitDirectory, commitSha, subdirectoryPath);
+    }
+
     /// <summary>
     /// Computes the SHA-1 hash of a Git tree object from its entries.
     /// This produces the same hash that Git would compute for an equivalent tree.
diff --git a/implement/GitCore/README.md b/implement/GitCore/README.md
@@ -9,6 +9,7 @@ Pure managed C# implementation for reading from Git repositories.
 + Reading from local Git repositories
   + Resolve HEAD and other references to commit SHAs.
   + Load all files from any commit's tree.
+  + Load files from a specific subdirectory within a commit's tree.
   + Supports both loose objects and pack files.
 + Cloning via [Git Smart HTTP](https://git-scm.com/book/en/v2/Git-on-the-Server-Smart-HTTP)
   + Efficient partial cloning of subdirectories.
@@ -34,6 +35,17 @@ var filesAtHead = GitCore.LoadFromLocalFiles.LoadTreeContentsFromHead(gitDir);
 var commitSha = GitCore.LoadFromLocalFiles.ResolveHead(gitDir);
 var filesAtCommit = GitCore.LoadFromLocalFiles.LoadTreeContentsFromCommit(gitDir, commitSha);
 
+// Load only files under a specific subdirectory (paths relative to subdirectory)
+var subdirFiles = GitCore.LoadFromLocalFiles.LoadSubdirectoryContentsFromHead(
+    gitDir,
+    ["implement", "Pine.Core"]);
+
+// Or from a specific commit
+var subdirFilesAtCommit = GitCore.LoadFromLocalFiles.LoadSubdirectoryContentsFromCommit(
+    gitDir,
+    commitSha,
+    ["implement", "Pine.Core"]);
+
 // Resolve any reference (branch, tag, etc.)
 var branchSha = GitCore.LoadFromLocalFiles.ResolveReference(gitDir, "refs/heads/main");
 
