Added worktree detection.

kekyo · kekyo · commit 0a11f3e65bc8 · 2025-03-05T17:34:24.000+09:00
diff --git a/GitReader.Core/Internal/RepositoryAccessor.cs b/GitReader.Core/Internal/RepositoryAccessor.cs
@@ -173,6 +173,65 @@ public static async Task<CandidateRepositoryPaths> DetectLocalRepositoryPathAsyn
         }
     }
 
+    internal readonly struct CandidateFilePath
+    {
+        public readonly string GitPath;
+        public readonly string BasePath;
+        public readonly string Path;
+        
+        public CandidateFilePath(string gitPath, string basePath, string path)
+        {
+            this.GitPath = gitPath;
+            this.BasePath = basePath;
+            this.Path = path;
+        }
+    }
+
+#if NET45_OR_GREATER || NETSTANDARD || NETCOREAPP
+    public static async ValueTask<CandidateFilePath?> GetCandidateFilePathAsync(
+#else
+    public static async Task<CandidateFilePath?> GetCandidateFilePathAsync(
+#endif
+        Repository repository,
+        string relativePathFromGitPath,
+        CancellationToken ct)
+    {
+        foreach (var gitPath in repository.TryingPathList)
+        {
+            var candidatePath = repository.fileSystem.Combine(gitPath, relativePathFromGitPath);
+            if (await repository.fileSystem.IsFileExistsAsync(candidatePath, ct))
+            {
+                return new(gitPath, repository.fileSystem.GetDirectoryPath(candidatePath), candidatePath);
+            }
+        }
+        return null;
+    }
+
+#if NET45_OR_GREATER || NETSTANDARD || NETCOREAPP
+    public static async ValueTask<CandidateFilePath[]> GetCandidateFilePathsAsync(
+#else
+    public static async Task<CandidateFilePath[]> GetCandidateFilePathsAsync(
+#endif
+        Repository repository,
+        string relativePathFromGitPath,
+        string match,
+        CancellationToken ct) =>
+        (await Utilities.WhenAll(repository.TryingPathList.
+#if NET45_OR_GREATER || NETSTANDARD || NETCOREAPP
+            Select((Func<string, ValueTask<CandidateFilePath[]>>)(async gitPath =>
+#else
+            Select((async gitPath =>
+#endif
+        {
+            var basePath = repository.fileSystem.Combine(gitPath, relativePathFromGitPath);
+            var candidatePaths = await repository.fileSystem.GetFilesAsync(basePath, match, ct);
+            return candidatePaths.
+                Select(candidatePath => new CandidateFilePath(gitPath, basePath, candidatePath)).
+                ToArray();
+        })))).
+        SelectMany(paths => paths).
+        ToArray();
+
     public static string GetReferenceTypeName(ReferenceTypes type) =>
         type switch
         {
@@ -216,13 +275,12 @@ public static async Task<ReadOnlyDictionary<string, string>> ReadRemoteReference
         Repository repository,
         CancellationToken ct)
     {
-        var path = repository.fileSystem.Combine(repository.GitPath, "config");
-        if (!await repository.fileSystem.IsFileExistsAsync(path, ct))
+        if (await GetCandidateFilePathAsync(repository, "config", ct) is not { } cp)
         {
             return new(new());
         }
 
-        using var fs = await repository.fileSystem.OpenAsync(path, false, ct);
+        using var fs = await repository.fileSystem.OpenAsync(cp.Path, false, ct);
         var tr = new AsyncTextReader(fs);
 
         var remotes = new Dictionary<string, string>();
@@ -264,13 +322,12 @@ public static async Task<ReferenceCache> ReadFetchHeadsAsync(
         var remoteNameByUrl = repository.remoteUrls.
             ToDictionary(entry => entry.Value, entry => entry.Key);
 
-        var path = repository.fileSystem.Combine(repository.GitPath, "FETCH_HEAD");
-        if (!await repository.fileSystem.IsFileExistsAsync(path, ct))
+        if (await GetCandidateFilePathAsync(repository, "FETCH_HEAD", ct) is not { } cp)
         {
             return new(new(new()), new(new()), new(new()));
         }
 
-        using var fs = await repository.fileSystem.OpenAsync(path, false, ct);
+        using var fs = await repository.fileSystem.OpenAsync(cp.Path, false, ct);
         var tr = new AsyncTextReader(fs);
 
         var remoteBranches = new Dictionary<string, Hash>();
@@ -356,13 +413,12 @@ public static async Task<ReferenceCache> ReadPackedRefsAsync(
         Repository repository,
         CancellationToken ct)
     {
-        var path = repository.fileSystem.Combine(repository.GitPath, "packed-refs");
-        if (!await repository.fileSystem.IsFileExistsAsync(path, ct))
+        if (await GetCandidateFilePathAsync(repository, "packed-refs", ct) is not { } cp)
         {
             return new(new(new()), new(new()), new(new()));
         }
 
-        using var fs = await repository.fileSystem.OpenAsync(path, false, ct);
+        using var fs = await repository.fileSystem.OpenAsync(cp.Path, false, ct);
         var tr = new AsyncTextReader(fs);
 
         var branches = new Dictionary<string, Hash>();
@@ -469,10 +525,8 @@ public static async Task<ReferenceCache> ReadPackedRefsAsync(
                 Replace("refs/tags/", string.Empty);
             names.Add(name);
 
-            var path = repository.fileSystem.Combine(
-                repository.GitPath,
-                currentLocation.Replace('/', Path.DirectorySeparatorChar));
-            if (!await repository.fileSystem.IsFileExistsAsync(path, ct))
+            if (await GetCandidateFilePathAsync(
+                repository, currentLocation.Replace('/', Path.DirectorySeparatorChar), ct) is not { } cp)
             {
                 if (currentLocation.StartsWith("refs/heads/"))
                 {
@@ -498,7 +552,7 @@ public static async Task<ReferenceCache> ReadPackedRefsAsync(
                 return null;
             }
 
-            using var fs = await repository.fileSystem.OpenAsync(path, false, ct);
+            using var fs = await repository.fileSystem.OpenAsync(cp.Path, false, ct);
             var tr = new AsyncTextReader(fs);
 
             var line = await tr.ReadLineAsync(ct);
@@ -528,14 +582,13 @@ public static Task<PrimitiveReflogEntry[]> ReadReflogEntriesAsync(
     public static async Task<PrimitiveReflogEntry[]> ReadReflogEntriesAsync(
         Repository repository, string refRelativePath, CancellationToken ct)
     {
-        var path = repository.fileSystem.Combine(
-            repository.GitPath, "logs", refRelativePath);
-        if (!await repository.fileSystem.IsFileExistsAsync(path, ct))
+        if (await GetCandidateFilePathAsync(
+            repository, repository.fileSystem.Combine("logs", refRelativePath), ct) is not { } cp)
         {
             return new PrimitiveReflogEntry[]{};
         }
 
-        using var fs = await repository.fileSystem.OpenAsync(path, false, ct);
+        using var fs = await repository.fileSystem.OpenAsync(cp.Path, false, ct);
         var tr = new AsyncTextReader(fs);
 
         var entries = new List<PrimitiveReflogEntry>();
@@ -561,37 +614,32 @@ public static async Task<PrimitiveReference[]> ReadReferencesAsync(
         ReferenceTypes type,
         CancellationToken ct)
     {
-        var headsPath = repository.fileSystem.Combine(
-            repository.GitPath, "refs", GetReferenceTypeName(type));
-        var files = await repository.fileSystem.GetFilesAsync(
-            headsPath, "*", ct);
+        var candidatePaths = await GetCandidateFilePathsAsync(
+            repository, repository.fileSystem.Combine("refs", GetReferenceTypeName(type)), "*", ct);
         var references = (await Utilities.WhenAll(
-            files.
+            candidatePaths.
 #if NET45_OR_GREATER || NETSTANDARD || NETCOREAPP
-            Select((Func<string, ValueTask<PrimitiveReference?>>)(async path =>
+            Select((Func<CandidateFilePath, ValueTask<PrimitiveReference?>>)(async cp =>
 #else
-            Select(async path =>
+            Select((async cp =>
 #endif
             {
                 if (await ReadHashAsync(
                     repository,
-                    path.Substring(repository.GitPath.Length + 1),
+                    cp.Path.Substring(cp.GitPath.Length + 1),
                     ct) is not { } results)
                 {
                     return default(PrimitiveReference?);
                 }
                 else
                 {
                     return new(
-                        path.Substring(headsPath.Length + 1).Replace(Path.DirectorySeparatorChar, '/'),
-                        path.Substring(repository.GitPath.Length + 1).Replace(Path.DirectorySeparatorChar, '/'),
+                        cp.Path.Substring(cp.BasePath.Length + 1).Replace(Path.DirectorySeparatorChar, '/'),
+                        cp.Path.Substring(cp.GitPath.Length + 1).Replace(Path.DirectorySeparatorChar, '/'),
                         results.Hash);
                 }
             }
-#if NET45_OR_GREATER || NETSTANDARD || NETCOREAPP
-            )
-#endif
-            ))).
+            )))).
             CollectValue(reference => reference).
             ToDictionary(reference => reference.Name);
 
@@ -632,38 +680,33 @@ public static async Task<PrimitiveTagReference[]> ReadTagReferencesAsync(
         Repository repository,
         CancellationToken ct)
     {
-        var headsPath = repository.fileSystem.Combine(
-            repository.GitPath, "refs", "tags");
-        var files = await repository.fileSystem.GetFilesAsync(
-            headsPath, "*", ct);
+        var candidatePaths = await GetCandidateFilePathsAsync(
+            repository, repository.fileSystem.Combine("refs", "tags"), "*", ct);
         var references = (await Utilities.WhenAll(
-            files.
+            candidatePaths.
 #if NET45_OR_GREATER || NETSTANDARD || NETCOREAPP
-            Select((Func<string, ValueTask<PrimitiveTagReference?>>)(async path =>
+            Select((Func<CandidateFilePath, ValueTask<PrimitiveTagReference?>>)(async cp =>
 #else
-            Select(async path =>
+            Select((async cp =>
 #endif
             {
                 if (await ReadHashAsync(
                     repository,
-                    path.Substring(repository.GitPath.Length + 1),
+                    cp.Path.Substring(cp.GitPath.Length + 1),
                     ct) is not { } results)
                 {
                     return default(PrimitiveTagReference?);
                 }
                 else
                 {
                     return new(
-                        path.Substring(headsPath.Length + 1).Replace(Path.DirectorySeparatorChar, '/'),
-                        path.Substring(repository.GitPath.Length + 1).Replace(Path.DirectorySeparatorChar, '/'),
+                        cp.Path.Substring(cp.BasePath.Length + 1).Replace(Path.DirectorySeparatorChar, '/'),
+                        cp.Path.Substring(cp.GitPath.Length + 1).Replace(Path.DirectorySeparatorChar, '/'),
                         results.Hash,
                         null);
                 }
             }
-#if NET45_OR_GREATER || NETSTANDARD || NETCOREAPP
-            )
-#endif
-            ))).
+            )))).
             CollectValue(reference => reference).
             ToDictionary(reference => reference.Name);
 
@@ -765,7 +808,6 @@ private static ObjectAccessor GetObjectAccessor(
         }
     }
 
-
     public static async Task<PrimitiveCommit?> ReadCommitAsync(
         Repository repository,
         Hash hash, CancellationToken ct)
diff --git a/GitReader.Core/Primitive/PrimitiveRepositoryFacade.cs b/GitReader.Core/Primitive/PrimitiveRepositoryFacade.cs
@@ -130,17 +130,16 @@ public static async Task<PrimitiveRepository> OpenSubModuleAsync(
         {
             throw new ArgumentException($"Could not use non-submodule entry: {treePath[treePath.Length - 1]}");
         }
-
-        var repositoryPath = repository.fileSystem.Combine(
-            repository.GitPath, "modules",
-            repository.fileSystem.Combine(treePath.Select(tree => tree.Name).ToArray()));
-
-        if (!await repository.fileSystem.IsFileExistsAsync(
-            repository.fileSystem.Combine(repositoryPath, "config"), ct))
+        
+        if (await RepositoryAccessor.GetCandidateFilePathAsync(
+            repository, repository.fileSystem.Combine(
+                "modules",
+                repository.fileSystem.Combine(treePath.Select(tree => tree.Name).ToArray()),
+                "config"), ct) is not { } cp)
         {
             throw new ArgumentException("Submodule repository does not exist.");
         }
 
-        return await InternalOpenPrimitiveAsync(repositoryPath, [], repository.fileSystem, ct);
+        return await InternalOpenPrimitiveAsync(cp.BasePath, [], repository.fileSystem, ct);
     }
 }
diff --git a/GitReader.Core/Repository.cs b/GitReader.Core/Repository.cs
@@ -11,7 +11,11 @@
 using GitReader.Internal;
 using GitReader.IO;
 using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Linq;
 using System.Threading;
+using System.Threading.Tasks;
 
 namespace GitReader;
 
@@ -30,7 +34,7 @@ private protected Repository(
         IFileSystem fileSystem)
     {
         this.GitPath = gitPath;
-        this.GitPaths = [..alternativeGitPaths, gitPath];
+        this.TryingPathList = [..alternativeGitPaths, gitPath];
         this.fileSystem = fileSystem;
         this.fileStreamCache = new(this.fileSystem);
         this.objectAccessor = new(this.pool, this.fileSystem, this.fileStreamCache, gitPath);
@@ -49,8 +53,9 @@ public void Dispose()
     }
 
     public string GitPath { get; }
-    
-    internal string[] GitPaths { get; }
+
+    [EditorBrowsable(EditorBrowsableState.Advanced)]
+    public string[] TryingPathList { get; }
 
     public ReadOnlyDictionary<string, string> RemoteUrls =>
         this.remoteUrls;
diff --git a/GitReader.Core/Structures/StructuredRepositoryFacade.cs b/GitReader.Core/Structures/StructuredRepositoryFacade.cs
@@ -424,22 +424,20 @@ public static async Task<StructuredRepository> OpenSubModuleAsync(
     {
         var (repository, _) = GetRelatedRepository(subModule);
 
-        var repositoryPath = repository.fileSystem.Combine(
-            repository.GitPath,
-            "modules",
-            repository.fileSystem.Combine(subModule.
-                Traverse<TreeEntry>(tree => tree.Parent as TreeEntry).
-                Select(tree => tree.Name).
-                Reverse().
-                ToArray()));
-
-        if (!await repository.fileSystem.IsFileExistsAsync(
-            repository.fileSystem.Combine(repositoryPath, "config"), ct))
+        if (await RepositoryAccessor.GetCandidateFilePathAsync(
+            repository, repository.fileSystem.Combine(
+                "modules",
+                repository.fileSystem.Combine(subModule.
+                    Traverse<TreeEntry>(tree => tree.Parent as TreeEntry).
+                    Select(tree => tree.Name).
+                    Reverse().
+                    ToArray()),
+                "config"), ct) is not { } cp)
         {
             throw new ArgumentException("Submodule repository does not exist.");
         }
 
-        return await InternalOpenStructuredAsync(repositoryPath, [], repository.fileSystem, ct);
+        return await InternalOpenStructuredAsync(cp.BasePath, [], repository.fileSystem, ct);
     }
 
     public static Task<Stream> OpenBlobAsync(
diff --git a/GitReader.Tests/Internal/RepositoryAccessorTests.cs b/GitReader.Tests/Internal/RepositoryAccessorTests.cs
@@ -40,7 +40,8 @@ public async Task DetectLocalRepositoryPath(int depth)
             new StandardFileSystem(65536),
             default);
 
-        Assert.AreEqual(Path.Combine(basePath, ".git"), actual);
+        Assert.AreEqual(Path.Combine(basePath, ".git"), actual.GitPath);
+        Assert.AreEqual(0, actual.AlternativePaths.Length);
     }
 
     [Test]
@@ -61,6 +62,29 @@ public async Task DetectLocalRepositoryPathFromDotGitFile()
             new StandardFileSystem(65536),
             default);
 
-        Assert.AreEqual(Path.Combine(basePath, ".git", "modules", "GitReader"), actual);
+        Assert.AreEqual(Path.Combine(basePath, ".git", "modules", "GitReader"), actual.GitPath);
+        Assert.AreEqual(0, actual.AlternativePaths.Length);
+    }
+
+    [Test]
+    public async Task DetectLocalRepositoryPathFromWorkTree()
+    {
+        var basePath = Path.GetFullPath(
+            RepositoryTestsSetUp.GetBasePath(
+                $"DetectLocalRepositoryPathFromWorkTree"));
+
+        ZipFile.ExtractToDirectory(
+            Path.Combine("artifacts", "test6.zip"),
+            basePath);
+
+        var innerPath = Path.Combine(basePath, "worktree");
+
+        var actual = await RepositoryAccessor.DetectLocalRepositoryPathAsync(
+            innerPath,
+            new StandardFileSystem(65536),
+            default);
+
+        Assert.AreEqual(Path.Combine(basePath, "root", ".git"), actual.GitPath);
+        Assert.AreEqual(new[] { Path.Combine(basePath, "root", ".git", "worktrees", "worktree") }, actual.AlternativePaths);
     }
 }
diff --git a/GitReader.Tests/artifacts/test6.zip b/GitReader.Tests/artifacts/test6.zip
diff --git a/README.md b/README.md
@@ -638,6 +638,8 @@ Apache-v2
 
 ## History
 
+* 1.10.0:
+  * Added Git worktree detection. (#15)
 * 1.9.0:
   * Supported multiple same named branches.
   * Added .NET 9.0 tfm.
diff --git a/samples/gitlog/Properties/launchSettings.json b/samples/gitlog/Properties/launchSettings.json

Original file line number	Diff line number	Diff line change
`@@ -130,17 +130,16 @@ public static async Task<PrimitiveRepository> OpenSubModuleAsync(`
`130`	`130`	`{`
`131`	`131`	`throw new ArgumentException($"Could not use non-submodule entry: {treePath[treePath.Length - 1]}");`
`132`	`132`	`}`
`133`		`-`
`134`		`- var repositoryPath = repository.fileSystem.Combine(`
`135`		`- repository.GitPath, "modules",`
`136`		`- repository.fileSystem.Combine(treePath.Select(tree => tree.Name).ToArray()));`
`137`		`-`
`138`		`- if (!await repository.fileSystem.IsFileExistsAsync(`
`139`		`- repository.fileSystem.Combine(repositoryPath, "config"), ct))`
	`133`	`+`
	`134`	`+ if (await RepositoryAccessor.GetCandidateFilePathAsync(`
	`135`	`+ repository, repository.fileSystem.Combine(`
	`136`	`+ "modules",`
	`137`	`+ repository.fileSystem.Combine(treePath.Select(tree => tree.Name).ToArray()),`
	`138`	`+ "config"), ct) is not { } cp)`
`140`	`139`	`{`
`141`	`140`	`throw new ArgumentException("Submodule repository does not exist.");`
`142`	`141`	`}`
`143`	`142`
`144`		`- return await InternalOpenPrimitiveAsync(repositoryPath, [], repository.fileSystem, ct);`
	`143`	`+ return await InternalOpenPrimitiveAsync(cp.BasePath, [], repository.fileSystem, ct);`
`145`	`144`	`}`
`146`	`145`	`}`