refactor(paths-filter): implement path find logic in gitrepository class

Author: roeil

src/GitVersion.Core/Git/IGitRepository.cs

@@ -1,5 +1,3 @@
-using LibGit2Sharp;
-
 namespace GitVersion.Git;
 
 public interface IGitRepository : IDisposable
@@ -16,11 +14,9 @@ public interface IGitRepository : IDisposable
     IBranchCollection Branches { get; }
     ICommitCollection Commits { get; }
     IRemoteCollection Remotes { get; }
-    IQueryableCommitLog InnerCommits { get; }
-    IEnumerable<Tag> InnerTags { get; }
-    Diff InnerDiff { get; }
 
     ICommit? FindMergeBase(ICommit commit, ICommit otherCommit);
+    IEnumerable<string>? FindPatchPaths(ICommit commit, string? tagPrefix);
     int UncommittedChangesCount();
     void DiscoverRepository(string? gitDirectory);
 }

src/GitVersion.Core/PublicAPI.Unshipped.txt

@@ -1,5 +1,3 @@
 #nullable enable
 GitVersion.Configuration.IIgnoreConfiguration.Paths.get -> System.Collections.Generic.IReadOnlyCollection<string!>!
-GitVersion.Git.IGitRepository.InnerCommits.get -> LibGit2Sharp.IQueryableCommitLog!
-GitVersion.Git.IGitRepository.InnerDiff.get -> LibGit2Sharp.Diff!
-GitVersion.Git.IGitRepository.InnerTags.get -> System.Collections.Generic.IEnumerable<LibGit2Sharp.Tag!>!
+GitVersion.Git.IGitRepository.FindPatchPaths(GitVersion.Git.ICommit! commit, string? tagPrefix) -> System.Collections.Generic.IEnumerable<string!>?

src/GitVersion.Core/VersionCalculation/PathFilter.cs

@@ -1,13 +1,10 @@
 using GitVersion.Extensions;
 using GitVersion.Git;
-using LibGit2Sharp;
 
 namespace GitVersion.VersionCalculation;
 
 internal class PathFilter(IGitRepository repository, GitVersionContext context, IEnumerable<string> paths, PathFilter.PathFilterMode mode = PathFilter.PathFilterMode.Inclusive) : IVersionFilter
 {
-    private readonly static Dictionary<string, Patch> patchsCache = [];
-
     public enum PathFilterMode { Inclusive = 0, Exclusive = 1 }
 
     private readonly IEnumerable<string> paths = paths.NotNull();
@@ -24,44 +21,28 @@ public bool Exclude(IBaseVersion baseVersion, out string? reason)
         return Exclude(baseVersion.BaseVersionSource, out reason);
     }
 
-    public bool Exclude(ICommit? localCommit, out string? reason)
+    public bool Exclude(ICommit? commit, out string? reason)
     {
-        localCommit.NotNull();
-        var commit = repository.InnerCommits.First(c => c.Sha == localCommit.Sha);
-
+        commit.NotNull();
         reason = null;
 
-        var match = new System.Text.RegularExpressions.Regex($"^({context.Configuration.TagPrefixPattern}).*$",
-            System.Text.RegularExpressions.RegexOptions.Compiled);
-
         if (commit != null)
         {
-            Patch? patch = null;
-            if (!patchsCache.ContainsKey(commit.Sha))
-            {
-                if (!repository.InnerTags.Any(t => t.Target.Sha == commit.Sha && match.IsMatch(t.FriendlyName)))
-                {
-                    Tree commitTree = commit.Tree; // Main Tree
-                    Tree? parentCommitTree = commit.Parents.FirstOrDefault()?.Tree; // Secondary Tree
-                    patch = repository.InnerDiff.Compare<Patch>(parentCommitTree, commitTree); // Difference
-                }
-                patchsCache[commit.Sha] = patch;
-            }
+            var patchPaths = repository.FindPatchPaths(commit, context.Configuration.TagPrefixPattern);
 
-            patch = patchsCache[commit.Sha];
-            if (patch != null)
+            if (patchPaths != null)
             {
                 switch (mode)
                 {
                     case PathFilterMode.Inclusive:
-                        if (!paths.Any(path => patch.Any(p => p.Path.StartsWith(path, StringComparison.OrdinalIgnoreCase))))
+                        if (!paths.Any(path => patchPaths.Any(p => p.StartsWith(path, StringComparison.OrdinalIgnoreCase))))
                         {
                             reason = "Source was ignored due to commit path is not present";
                             return true;
                         }
                         break;
                     case PathFilterMode.Exclusive:
-                        if (paths.Any(path => patch.All(p => p.Path.StartsWith(path, StringComparison.OrdinalIgnoreCase))))
+                        if (paths.Any(path => patchPaths.All(p => p.StartsWith(path, StringComparison.OrdinalIgnoreCase))))
                         {
                             reason = "Source was ignored due to commit path excluded";
                             return true;

src/GitVersion.LibGit2Sharp/Git/GitRepository.cs

@@ -1,3 +1,4 @@
+using System.Text.RegularExpressions;
 using GitVersion.Extensions;
 using GitVersion.Helpers;
 using LibGit2Sharp;
@@ -7,6 +8,7 @@ namespace GitVersion.Git;
 internal sealed partial class GitRepository
 {
     private Lazy<IRepository>? repositoryLazy;
+    private readonly static Dictionary<string, Patch> patchsCache = [];
 
     private IRepository RepositoryInstance
     {
@@ -28,9 +30,6 @@ private IRepository RepositoryInstance
     public IBranchCollection Branches => new BranchCollection(RepositoryInstance.Branches);
     public ICommitCollection Commits => new CommitCollection(RepositoryInstance.Commits);
     public IRemoteCollection Remotes => new RemoteCollection(RepositoryInstance.Network.Remotes);
-    public IQueryableCommitLog InnerCommits => RepositoryInstance.Commits;
-    public IEnumerable<LibGit2Sharp.Tag> InnerTags => RepositoryInstance.Tags;
-    public Diff InnerDiff => RepositoryInstance.Diff;
 
     public void DiscoverRepository(string? gitDirectory)
     {
@@ -56,6 +55,26 @@ public void DiscoverRepository(string? gitDirectory)
         });
     }
 
+    public IEnumerable<string>? FindPatchPaths(ICommit commit, string? tagPrefix)
+    {
+        Patch? patch = null;
+        var innerCommit = RepositoryInstance.Commits.First(c => c.Sha == commit.Sha);
+        var match = new Regex($"^({tagPrefix ?? ""}).*$", RegexOptions.Compiled);
+
+        if (!patchsCache.ContainsKey(commit.Sha))
+        {
+            if (!RepositoryInstance.Tags.Any(t => t.Target.Sha == commit.Sha && match.IsMatch(t.FriendlyName)))
+            {
+                Tree commitTree = innerCommit.Tree; // Main Tree
+                Tree? parentCommitTree = innerCommit.Parents.FirstOrDefault()?.Tree; // Secondary Tree
+                patch = RepositoryInstance.Diff.Compare<Patch>(parentCommitTree, commitTree); // Difference
+            }
+            patchsCache[commit.Sha] = patch;
+        }
+
+        return patch?.Select(p => p.Path);
+    }
+
     public int UncommittedChangesCount()
     {
         var retryAction = new RetryAction<LibGit2Sharp.LockedFileException, int>();