pr

Author: roeil

src/GitVersion.Configuration/IgnoreConfiguration.cs

@@ -24,12 +24,12 @@ public string? BeforeString
     [JsonPropertyDescription("A sequence of SHAs to be excluded from the version calculations.")]
     public HashSet<string> Shas { get; init; } = [];
 
-    [JsonIgnore]
-    public bool IsEmpty => Before == null && Shas.Count == 0 && Paths.Count == 0;
-
     IReadOnlyCollection<string> IIgnoreConfiguration.Paths => Paths;
 
     [JsonPropertyName("paths")]
     [JsonPropertyDescription("A sequence of file paths to be excluded from the version calculations.")]
     public Collection<string> Paths { get; init; } = [];
+
+    [JsonIgnore]
+    public bool IsEmpty => Before == null && Shas.Count == 0 && Paths.Count == 0;
 }

src/GitVersion.Core.Tests/VersionCalculation/Strategies/MergeMessageBaseVersionStrategyTests.cs

@@ -204,7 +204,7 @@ private class MockCommit : ICommit
         public IObjectId Id => throw new NotImplementedException();
         public string Sha => throw new NotImplementedException();
         public IReadOnlyList<ICommit> Parents => throw new NotImplementedException();
-        public IEnumerable<string> DiffPaths => throw new NotImplementedException();
+        public IReadOnlyList<string> DiffPaths => throw new NotImplementedException();
         public DateTimeOffset When => throw new NotImplementedException();
         public string Message => throw new NotImplementedException();
     }

src/GitVersion.Core/Configuration/IIgnoreConfiguration.cs

@@ -8,5 +8,5 @@ public interface IIgnoreConfiguration
 
     IReadOnlyCollection<string> Paths { get; }
 
-    bool IsEmpty => Before == null && Shas.Count == 0 && Paths.Count == 0;
+    bool IsEmpty { get; }
 }

src/GitVersion.Core/Extensions/ConfigurationExtensions.cs

@@ -25,7 +25,7 @@ public static EffectiveConfiguration GetEffectiveConfiguration(
         {
             fallbackConfiguration = parentConfiguration;
         }
-        return new EffectiveConfiguration(configuration, branchConfiguration, fallbackConfiguration: fallbackConfiguration);
+        return new EffectiveConfiguration(configuration, branchConfiguration, fallbackConfiguration);
     }
 
     public static IBranchConfiguration GetBranchConfiguration(this IGitVersionConfiguration configuration, IBranch branch)
@@ -44,7 +44,7 @@ public static IEnumerable<IVersionFilter> ToFilters(this IIgnoreConfiguration so
 
         if (source.Shas.Count != 0) yield return new ShaVersionFilter(source.Shas);
         if (source.Before.HasValue) yield return new MinDateVersionFilter(source.Before.Value);
-        if (source.Paths.Count != 0) yield return new PathFilter(source.Paths);
+        if (source.Paths.Count != 0) yield return new PathFilter(source.Paths.ToList());
     }
 
     private static IEnumerable<IBranchConfiguration> GetBranchConfigurations(IGitVersionConfiguration configuration, string branchName)

src/GitVersion.Core/Git/ICommit.cs

@@ -7,5 +7,5 @@ public interface ICommit : IEquatable<ICommit?>, IComparable<ICommit>, IGitObjec
     DateTimeOffset When { get; }
 
     string Message { get; }
-    IEnumerable<string> DiffPaths { get; }
+    IReadOnlyList<string> DiffPaths { get; }
 }

src/GitVersion.Core/Git/ITreeChanges.cs

@@ -2,5 +2,5 @@ namespace GitVersion.Git;
 
 public interface ITreeChanges
 {
-    IEnumerable<string> Paths { get; }
+    IReadOnlyList<string> Paths { get; }
 }

src/GitVersion.Core/PublicAPI.Unshipped.txt

@@ -1,6 +1,6 @@
 #nullable enable
 GitVersion.Configuration.IIgnoreConfiguration.Paths.get -> System.Collections.Generic.IReadOnlyCollection<string!>!
-GitVersion.Git.ICommit.DiffPaths.get -> System.Collections.Generic.IEnumerable<string!>!
+GitVersion.Git.ICommit.DiffPaths.get -> System.Collections.Generic.IReadOnlyList<string!>!
 GitVersion.Git.ITreeChanges
-GitVersion.Git.ITreeChanges.Paths.get -> System.Collections.Generic.IEnumerable<string!>!
+GitVersion.Git.ITreeChanges.Paths.get -> System.Collections.Generic.IReadOnlyList<string!>!
 GitVersion.VersionCalculation.IVersionFilter.Exclude(GitVersion.Git.ICommit! commit, out string? reason) -> bool

src/GitVersion.Core/VersionCalculation/PathFilter.cs

@@ -1,13 +1,14 @@
+using System.Collections.Concurrent;
 using System.Diagnostics.CodeAnalysis;
 using System.Text.RegularExpressions;
 using GitVersion.Git;
 
 namespace GitVersion.VersionCalculation;
 
-internal class PathFilter( IEnumerable<string> paths) : IVersionFilter
+internal class PathFilter(IReadOnlyList<string> paths) : IVersionFilter
 {
-    private readonly List<Regex> pathsRegexes = paths.Select(path => new Regex(path, RegexOptions.IgnoreCase | RegexOptions.Compiled)).ToList();
-    private readonly Dictionary<string, bool> pathMatchCache = [];
+    private readonly List<Regex> pathsRegexes = [.. paths.Select(path => new Regex(path, RegexOptions.IgnoreCase | RegexOptions.Compiled))];
+    private readonly ConcurrentDictionary<string, bool> pathMatchCache = [];
 
     public bool Exclude(IBaseVersion baseVersion, [NotNullWhen(true)] out string? reason)
     {
@@ -27,21 +28,18 @@ public bool Exclude(ICommit? commit, [NotNullWhen(true)] out string? reason)
         {
             var patchPaths = commit.DiffPaths;
 
-            if (patchPaths != null)
+            foreach (var path in patchPaths)
             {
-                foreach (var path in patchPaths)
+                if (!pathMatchCache.TryGetValue(path, out var isMatch))
                 {
-                    if (!pathMatchCache.TryGetValue(path, out var isMatch))
-                    {
-                        isMatch = this.pathsRegexes.Any(regex => regex.IsMatch(path));
-                        pathMatchCache[path] = isMatch;
-                    }
-
-                    if (isMatch)
-                    {
-                        reason = "Source was ignored due to commit path matching ignore regex";
-                        return true;
-                    }
+                    isMatch = this.pathsRegexes.Any(regex => regex.IsMatch(path));
+                    pathMatchCache[path] = isMatch;
+                }
+
+                if (isMatch)
+                {
+                    reason = "Source was ignored due to commit path matching ignore regex";
+                    return true;
                 }
             }
         }

src/GitVersion.LibGit2Sharp/Git/Commit.cs

@@ -28,19 +28,21 @@ internal Commit(LibGit2Sharp.Commit innerCommit, LibGit2Sharp.Diff repoDiff) : b
     public DateTimeOffset When { get; }
     public string Message => this.innerCommit.Message;
     // TODO implement tag prefix filtering before returning the paths.
-    public IEnumerable<string> DiffPaths
+    public IReadOnlyList<string> DiffPaths
     {
         get
         {
-            if (pathsCache.TryGetValue(this.Sha, out var paths))
-                return paths;
-            else
-                return this.CommitChanges?.Paths ?? [];
+            if (!pathsCache.TryGetValue(this.Sha, out var paths))
+            {
+                paths = this.CommitChanges?.Paths ?? [];
+                pathsCache[this.Sha] = paths;
+            }
+            return paths;
         }
     }
     public override bool Equals(object? obj) => Equals(obj as ICommit);
     public override int GetHashCode() => equalityHelper.GetHashCode(this);
     public override string ToString() => $"'{Id.ToString(7)}' - {this.innerCommit.MessageShort}";
     public static implicit operator LibGit2Sharp.Commit(Commit d) => d.innerCommit;
-    private ITreeChanges CommitChanges => new TreeChanges(this.repoDiff.Compare<LibGit2Sharp.TreeChanges>(this.innerCommit.Tree, this.innerCommit.Parents.FirstOrDefault()?.Tree));
+    private TreeChanges CommitChanges => new TreeChanges(this.repoDiff.Compare<LibGit2Sharp.TreeChanges>(this.innerCommit.Tree, this.innerCommit.Parents.FirstOrDefault()?.Tree));
 }

src/GitVersion.LibGit2Sharp/Git/GitRepository.cs

@@ -1,4 +1,3 @@
-using System.Collections.Concurrent;
 using GitVersion.Extensions;
 using GitVersion.Helpers;
 using LibGit2Sharp;
@@ -8,7 +7,6 @@ namespace GitVersion.Git;
 internal sealed partial class GitRepository
 {
     private Lazy<IRepository>? repositoryLazy;
-    private readonly ConcurrentDictionary<string, IReadOnlyList<string>?> patchPathsCache = new();
 
     private IRepository RepositoryInstance
     {

src/GitVersion.LibGit2Sharp/Git/TreeChanges.cs

@@ -4,5 +4,5 @@ internal sealed class TreeChanges(LibGit2Sharp.TreeChanges innerTreeChanges) : I
 {
     private readonly LibGit2Sharp.TreeChanges innerTreeChanges = innerTreeChanges ?? throw new ArgumentNullException(nameof(innerTreeChanges));
 
-    public IEnumerable<string> Paths => this.innerTreeChanges.Select(element => element.Path);
+    public IReadOnlyList<string> Paths => [.. this.innerTreeChanges.Select(element => element.Path)];
 }